diff --git a/.agents/skills/creating-new-builtin-plugins/SKILL.md b/.agents/skills/creating-new-builtin-plugins/SKILL.md new file mode 100644 index 0000000000..8a3c2d1e66 --- /dev/null +++ b/.agents/skills/creating-new-builtin-plugins/SKILL.md @@ -0,0 +1,291 @@ +--- +name: creating-new-builtin-plugins +description: Adding a new built-in plugin to Golem. Use when creating a brand new plugin that ships with Golem and is auto-provisioned at startup, covering project scaffolding, WASM compilation, provisioning wiring, CLI embedding, and test framework integration. +--- + +# Creating a New Built-in Plugin + +This skill covers how to add a **new** built-in plugin to Golem end-to-end. Built-in plugins are WASM components compiled with the Golem CLI, committed as `.wasm` files, embedded in the `golem` CLI binary, and automatically provisioned by the registry service at startup. + +For modifying an **existing** plugin, load the `modifying-builtin-plugins` skill instead. + +## Architecture Overview + +A built-in plugin has these integration points (all must be wired up): + +1. **Plugin source code** — a standalone Golem application under `plugins/` +2. **Compiled WASM artifact** — committed to git at `plugins/.wasm` +3. **Build task** — added to `Makefile.toml` under `build-plugins` +4. **Registry service config** — `BuiltinPluginsConfig` struct with WASM bytes/path fields +5. **Provisioner** — `builtin_plugin_provisioner.rs` creates the component, deploys it, registers the plugin, and grants it +6. **Bootstrap wiring** — `golem-registry-service/src/bootstrap/mod.rs` loads WASM and calls the provisioner +7. **CLI embedding** — `cli/golem/src/launch.rs` uses `include_bytes!` to embed the WASM +8. **Test framework** — `golem-test-framework/src/components/registry_service/` loads WASM from filesystem and passes it via env vars + +## Step-by-Step Guide + +### 1. Create the Plugin Project + +Create a new Golem application under `plugins/`: + +``` +plugins/ + my-plugin/ + components-rust/my-plugin/ + src/lib.rs # Plugin implementation + Cargo.toml # crate-type = ["cdylib"] + golem.yaml # Component manifest with copy command + Cargo.toml # Workspace Cargo.toml + golem.yaml # Application manifest + .gitignore # Ignore target/ and golem-temp/ +``` + +Use the existing `plugins/otlp-exporter/` as a template: + +**`plugins/my-plugin/.gitignore`:** +``` +target/ +golem-temp/ +``` + +**`plugins/my-plugin/Cargo.toml`** (workspace root): +```toml +[workspace] +resolver = "2" +members = ["components-rust/*"] + +[profile.release] +opt-level = "s" +lto = true + +[workspace.dependencies] +golem-rust = { path = "../../sdks/rust/golem-rust", features = ["export_oplog_processor"] } +# Add other dependencies as needed +``` + +Note: The `features` on `golem-rust` depend on the plugin type. For oplog processors use `export_oplog_processor`. Adjust based on the plugin kind. + +**`plugins/my-plugin/golem.yaml`:** +```yaml +app: my-plugin + +includes: + - components-*/*/golem.yaml + +environments: + local: + server: local + componentPresets: debug + cloud: + server: cloud + componentPresets: release +``` + +**`plugins/my-plugin/components-rust/my-plugin/Cargo.toml`:** +```toml +[package] +name = "my_plugin" +version = "0.0.1" +edition = "2021" + +[lib] +crate-type = ["cdylib"] +path = "src/lib.rs" + +[dependencies] +golem-rust = { workspace = true } +``` + +**`plugins/my-plugin/components-rust/my-plugin/golem.yaml`:** +```yaml +components: + my:plugin: + templates: rust + +customCommands: + copy: + - command: cp ../../golem-temp/agents/my_plugin_release.wasm ../../../my-plugin.wasm +``` + +The copy command filename is derived from the component name: colons become underscores, suffixed with `_release.wasm`. Verify the actual output filename in `golem-temp/agents/` after building. + +### 2. Implement the Plugin + +Write the plugin code in `plugins/my-plugin/components-rust/my-plugin/src/lib.rs`. The implementation depends on the plugin type (currently only `OplogProcessor` is supported): + +```rust +use golem_rust::oplog_processor::exports::golem::api::oplog_processor::Guest as OplogProcessorGuest; +use golem_rust::bindings::golem::api::oplog::{OplogEntry, OplogIndex}; +use golem_rust::golem_wasm::golem_core_1_5_x::types::{AgentId, ComponentId}; + +struct MyPluginComponent; + +impl OplogProcessorGuest for MyPluginComponent { + fn process( + _account_info: golem_rust::oplog_processor::exports::golem::api::oplog_processor::AccountInfo, + config: Vec<(String, String)>, + component_id: ComponentId, + worker_id: AgentId, + metadata: golem_rust::bindings::golem::api::host::AgentMetadata, + _first_entry_index: OplogIndex, + entries: Vec, + ) -> Result<(), String> { + // Plugin logic here + Ok(()) + } +} + +golem_rust::oplog_processor::export_oplog_processor!(MyPluginComponent with_types_in golem_rust::oplog_processor); +``` + +### 3. Build and Commit the WASM + +```shell +cd plugins/my-plugin +golem build -P release +golem exec -P release copy +``` + +Verify `plugins/my-plugin.wasm` was created, then **commit it to git**. This file is required at compile time by the CLI. + +### 4. Add to `Makefile.toml` + +Update the `build-plugins` task in `Makefile.toml` to include the new plugin: + +```toml +[tasks.build-plugins] +dependencies = ["build"] +description = "Builds built-in plugins (requires golem CLI to be built first)" +script_runner = "@duckscript" +script = ''' +cd plugins/otlp-exporter +exec --fail-on-error ../../target/debug/golem build -P release --force-build +exec --fail-on-error ../../target/debug/golem exec -P release copy +cd ../.. +cd plugins/my-plugin +exec --fail-on-error ../../target/debug/golem build -P release --force-build +exec --fail-on-error ../../target/debug/golem exec -P release copy +cd ../.. +''' +``` + +### 5. Add Config Fields + +In `golem-registry-service/src/config.rs`, add fields to `BuiltinPluginsConfig`: + +```rust +#[derive(Clone, Debug, Serialize, Deserialize, Default)] +pub struct BuiltinPluginsConfig { + pub enabled: bool, + #[serde(skip)] + pub otlp_exporter_wasm: Option>, + pub otlp_exporter_wasm_path: Option, + #[serde(skip)] + pub my_plugin_wasm: Option>, // New + pub my_plugin_wasm_path: Option, // New +} +``` + +The `#[serde(skip)]` field holds the in-memory WASM bytes (set programmatically). The path field is set via environment variable `GOLEM__BUILTIN_PLUGINS__MY_PLUGIN_WASM_PATH`. + +### 6. Wire Up Provisioning + +In `golem-registry-service/src/services/builtin_plugin_provisioner.rs`, add provisioning logic for the new plugin. The provisioner follows a consistent pattern: + +1. **Get or skip** — check if the WASM bytes are provided; skip if not +2. **Create component** — upload WASM into the `builtin-plugins` environment (idempotent: handle `ComponentWithNameAlreadyExists`) +3. **Deploy environment** — call `deployment_write_service.create_deployment()` so the component becomes deployed +4. **Register plugin** — create a `PluginRegistrationCreation` with the appropriate `PluginSpecDto` variant (idempotent: handle `PluginNameAndVersionAlreadyExists`) +5. **Grant to environments** — iterate all environments and grant the plugin + +All plugins share the same `golem-system` application and `builtin-plugins` environment. Add new component and plugin constants: + +```rust +const MY_PLUGIN_COMPONENT_NAME: &str = "my:plugin"; +const MY_PLUGIN_NAME: &str = "golem-my-plugin"; +const MY_PLUGIN_VERSION: &str = "1.0.0"; +``` + +### 7. Wire Up Bootstrap + +In `golem-registry-service/src/bootstrap/mod.rs`, load the new plugin's WASM from the filesystem path (similar to the OTLP exporter pattern): + +```rust +if builtin_plugins.my_plugin_wasm.is_none() { + if let Some(ref path) = builtin_plugins.my_plugin_wasm_path { + match std::fs::read(path) { + Ok(bytes) => { + tracing::info!("Loaded my-plugin WASM from {}", path.display()); + builtin_plugins.my_plugin_wasm = Some(Arc::from(bytes)); + } + Err(e) => { + return Err(anyhow!( + "Failed to read my-plugin WASM from {}: {e}", + path.display() + )); + } + } + } +} +``` + +### 8. Embed in the CLI + +In `cli/golem/src/launch.rs`, add an `include_bytes!` for the new WASM and pass it in the config: + +```rust +static MY_PLUGIN_WASM: &[u8] = include_bytes!("../../../plugins/my-plugin.wasm"); + +// In the BuiltinPluginsConfig construction: +builtin_plugins: BuiltinPluginsConfig { + enabled: true, + otlp_exporter_wasm: Some(Arc::from(OTLP_EXPORTER_WASM)), + my_plugin_wasm: Some(Arc::from(MY_PLUGIN_WASM)), + ..Default::default() +}, +``` + +### 9. Wire Up Test Framework + +In `golem-test-framework/src/components/registry_service/`: + +**`spawned.rs`** — load the WASM path: +```rust +let my_plugin_wasm = working_directory.join("../plugins/my-plugin.wasm"); +let my_plugin_wasm_path = if my_plugin_wasm.exists() { + Some(my_plugin_wasm.as_path()) +} else { + None +}; +``` + +**`mod.rs`** — pass the path as an env var in `env_vars()`: +```rust +// Add parameter: my_plugin_wasm_path: Option<&Path> +let builder = if let Some(wasm_path) = my_plugin_wasm_path { + builder.with( + "GOLEM__BUILTIN_PLUGINS__MY_PLUGIN_WASM_PATH", + wasm_path.to_string_lossy().to_string(), + ) +} else { + builder +}; +``` + +## Checklist + +- [ ] Plugin source created under `plugins//` +- [ ] Plugin compiles: `cd plugins/ && golem build -P release && golem exec -P release copy` +- [ ] `plugins/.wasm` exists and is committed to git +- [ ] `Makefile.toml` `build-plugins` task updated +- [ ] `BuiltinPluginsConfig` has new WASM and path fields +- [ ] `builtin_plugin_provisioner.rs` provisions the new plugin (create component, deploy, register, grant) +- [ ] `bootstrap/mod.rs` loads WASM from filesystem path +- [ ] `cli/golem/src/launch.rs` embeds WASM via `include_bytes!` +- [ ] Test framework passes WASM path via env var +- [ ] Plugin version constant defined in provisioner +- [ ] Integration test written (optional but recommended) + +## Plugin Types + +Currently only `OplogProcessor` plugins are supported (see `PluginSpecDto` enum in `golem-common/src/model/plugin_registration.rs`). If adding a new plugin type, you'll also need to extend `PluginSpecDto` and the associated model/repo/service code. diff --git a/.agents/skills/modifying-builtin-plugins/SKILL.md b/.agents/skills/modifying-builtin-plugins/SKILL.md new file mode 100644 index 0000000000..55fb884da5 --- /dev/null +++ b/.agents/skills/modifying-builtin-plugins/SKILL.md @@ -0,0 +1,157 @@ +--- +name: modifying-builtin-plugins +description: Building or modifying built-in plugins in plugins/. Use when changing the OTLP exporter plugin code, rebuilding plugin WASMs, or modifying the builtin plugin provisioning logic. +--- + +# Modifying Built-in Plugins + +Built-in plugins are WASM components that ship with Golem and are automatically provisioned at registry service startup. Currently the only built-in plugin is the **OTLP exporter** oplog processor. + +## Plugin Location + +``` +plugins/ + otlp-exporter/ # Golem application project (standalone workspace) + components-rust/otlp-exporter/ + src/lib.rs # Plugin entry point + src/config.rs # Configuration parsing + src/export.rs # OTLP HTTP export logic + src/processing.rs # Oplog entry processing + src/state.rs # Worker state management + src/otlp_json.rs # OTLP JSON types + src/helpers.rs # Utility functions + golem.yaml # Component manifest (includes copy command) + Cargo.toml # Workspace Cargo.toml (NOT part of main workspace) + golem.yaml # Application manifest + otlp-exporter.wasm # Compiled WASM — COMMITTED TO GIT +``` + +**Important:** The `plugins/otlp-exporter/` directory is a **standalone Golem application** with its own workspace. It is NOT part of the main Golem Cargo workspace. It depends on the Rust SDK at `sdks/rust/golem-rust` via a relative path. + +## Building Plugins + +**Important:** Plugin builds require the `golem` CLI binary built from the current source tree. Always build it first and use the binary from `target/debug/`. + +### Step 1: Build the golem CLI + +```shell +cargo make build +``` + +This compiles the `golem` binary to `target/debug/golem`. + +### Step 2: Build the plugin using the local golem binary + +### Using cargo-make (preferred for CI / full builds) + +```shell +cargo make build-plugins +``` + +This runs: +1. `target/debug/golem build -P release --force-build` in `plugins/otlp-exporter/` +2. `target/debug/golem exec -P release copy` to copy the output WASM to `plugins/otlp-exporter.wasm` + +### Manual build (for iterating on plugin code) + +Use the locally built binary (`GOLEM` below refers to the absolute path to `target/debug/golem`): + +```shell +cd plugins/otlp-exporter +../../target/debug/golem build -P release --force-build +../../target/debug/golem exec -P release copy +``` + +The `copy` custom command (defined in `components-rust/otlp-exporter/golem.yaml`) copies the release WASM from `golem-temp/agents/otlp_exporter_release.wasm` to `plugins/otlp-exporter.wasm`. + +### After rebuilding + +The compiled `plugins/otlp-exporter.wasm` **must be committed to git**. It is consumed at compile time by the `golem` CLI binary via `include_bytes!` and at runtime by the test framework. + +## How Plugins Are Loaded + +### In the `golem` CLI (local mode) + +The WASM is embedded at compile time: +```rust +// cli/golem/src/launch.rs +static OTLP_EXPORTER_WASM: &[u8] = include_bytes!("../../../plugins/otlp-exporter.wasm"); +``` + +### In the test framework + +The WASM is loaded from the filesystem at runtime: +```rust +// golem-test-framework/src/components/registry_service/spawned.rs +let otlp_wasm = working_directory.join("../plugins/otlp-exporter.wasm"); +``` + +The path is passed to the registry service via the `GOLEM__BUILTIN_PLUGINS__OTLP_EXPORTER_WASM_PATH` environment variable. + +### In the registry service + +The bootstrap code in `golem-registry-service/src/bootstrap/mod.rs` loads the WASM from the configured path, then calls `provision_builtin_plugins()` which: + +1. Creates or finds the `golem-system` application +2. Creates or finds the `builtin-plugins` environment +3. Uploads the WASM as the `otlp-exporter` component +4. Deploys the `builtin-plugins` environment +5. Registers the `golem-otlp-exporter` plugin (version defined in `builtin_plugin_provisioner.rs`) +6. Grants the plugin to all existing environments + +## Configuration + +The `BuiltinPluginsConfig` struct in `golem-registry-service/src/config.rs`: + +```rust +pub struct BuiltinPluginsConfig { + pub enabled: bool, + pub otlp_exporter_wasm: Option>, // Set programmatically + pub otlp_exporter_wasm_path: Option, // From config/env var +} +``` + +Environment variables: +- `GOLEM__BUILTIN_PLUGINS__ENABLED` — enable/disable plugin provisioning +- `GOLEM__BUILTIN_PLUGINS__OTLP_EXPORTER_WASM_PATH` — filesystem path to the WASM file + +## Plugin Versioning + +The plugin name and version are constants in `golem-registry-service/src/services/builtin_plugin_provisioner.rs`: + +```rust +const OTLP_PLUGIN_NAME: &str = "golem-otlp-exporter"; +const OTLP_PLUGIN_VERSION: &str = "1.5.0"; +``` + +When updating the plugin, bump `OTLP_PLUGIN_VERSION` if the plugin spec changes. + +## Common Workflows + +### Modifying plugin logic + +1. Edit source files in `plugins/otlp-exporter/components-rust/otlp-exporter/src/` +2. Build the golem CLI first: `cargo make build` +3. Build the plugin: `cd plugins/otlp-exporter && ../../target/debug/golem build -P release --force-build && ../../target/debug/golem exec -P release copy` +4. Verify `plugins/otlp-exporter.wasm` was updated +5. Commit the updated WASM file +6. Rebuild the main project (`cargo make build`) if testing with the embedded CLI + +### Changing the plugin SDK dependency + +The plugin uses `golem-rust` from `sdks/rust/golem-rust` with the `export_oplog_processor` feature. If the SDK changes: +1. Rebuild the SDK if needed (see `sdk-development` skill) +2. Build the golem CLI: `cargo make build` +3. Rebuild the plugin: `cd plugins/otlp-exporter && ../../target/debug/golem build -P release --force-build && ../../target/debug/golem exec -P release copy` +4. Commit the updated WASM + +### Modifying provisioning logic + +The provisioning code is in `golem-registry-service/src/services/builtin_plugin_provisioner.rs`. Changes there only require rebuilding `golem-registry-service`, not the plugin WASM. + +### Testing + +The OTLP plugin integration test is at `integration-tests/tests/otlp_plugin.rs`. Run it with: +```shell +cargo test -p integration-tests -- otlp_plugin --report-time +``` diff --git a/.agents/skills/rebuild-all-test-components/SKILL.md b/.agents/skills/rebuild-all-test-components/SKILL.md new file mode 100644 index 0000000000..c4d1d9ad3a --- /dev/null +++ b/.agents/skills/rebuild-all-test-components/SKILL.md @@ -0,0 +1,61 @@ +--- +name: rebuild-all-test-components +description: "Rebuilds all test WASM components from scratch. Use when explicitly asked to rebuild all test components, or when there are merge conflicts in any test-components/*.wasm files." +--- + +# Rebuild All Test Components + +Clean rebuild of every test WASM component in `test-components/`. This is a heavyweight operation — only use when all components need regeneration (e.g., after merge conflicts in `.wasm` files or major SDK/WIT changes). + +## Steps + +### 1. Build golem-cli + +The build scripts rely on `golem-cli` from the local build: + +```shell +cargo make build +``` + +### 2. Clean and rebuild the TypeScript SDK (including agent template) + +The TS test components depend on the TS SDK and its embedded agent template WASM: + +```shell +cd sdks/ts +npx pnpm run clean +npx pnpm install +npx pnpm run build +npx pnpm run build-agent-template +``` + +**Requires `cargo-component` v0.21.1** — install with: +```shell +cargo install cargo-component --version 0.21.1 +``` + +### 3. Clean all test components + +```shell +cd test-components +./build-components.sh clean +``` + +### 4. Build all test components + +```shell +cd test-components +./build-components.sh +``` + +If any component fails to build, fix the issue and re-run `./build-components.sh`. The script will rebuild all components. Repeat until all components build successfully. + +### 5. Verify + +After rebuilding, the `.wasm` files in `test-components/` should be updated. Commit all changed `.wasm` files. + +## Troubleshooting + +- **Missing `wasm-rquickjs-cli`**: Check the required version in `.github/workflows/ci.yaml` (`WASM_RQUICKJS_VERSION`) and install it: `cargo install wasm-rquickjs-cli --version ` +- **TS build failures**: Ensure `npx pnpm run build-agent-template` completed successfully before building TS test components +- **Rust build failures**: The script sets `GOLEM_RUST_PATH` automatically to `sdks/rust/golem-rust`; ensure the Rust SDK builds cleanly with `cargo build -p golem-rust` diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 49aef4bb0c..189977220d 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -268,6 +268,8 @@ jobs: description: "IT #5" - name: integration-tests-group6 description: "IT #6" + - name: integration-tests-group7 + description: "IT #7" - name: cli-integration-tests-group1 description: "CLI tests #1" - name: cli-integration-tests-group2 diff --git a/Cargo.lock b/Cargo.lock index ecb43e8c4b..ed8cc908bc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -241,6 +241,22 @@ dependencies = [ "syn 2.0.117", ] +[[package]] +name = "astral-tokio-tar" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec179a06c1769b1e42e1e2cbe74c7dcdb3d6383c838454d063eaac5bbb7ebbe5" +dependencies = [ + "filetime", + "futures-core", + "libc", + "portable-atomic", + "rustc-hash 2.1.1", + "tokio", + "tokio-stream", + "xattr", +] + [[package]] name = "async-broadcast" version = "0.7.2" @@ -1272,11 +1288,14 @@ dependencies = [ [[package]] name = "bollard" -version = "0.18.1" +version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97ccca1260af6a459d75994ad5acc1651bcabcbdbc41467cc9786519ab854c30" +checksum = "ee04c4c84f1f811b017f2fbb7dd8815c976e7ca98593de9c1e2afad0f636bff4" dependencies = [ + "async-stream", "base64 0.22.1", + "bitflags 2.11.0", + "bollard-buildkit-proto", "bollard-stubs", "bytes", "futures-core", @@ -1291,33 +1310,54 @@ dependencies = [ "hyper-util", "hyperlocal", "log", + "num", "pin-project-lite", + "rand 0.9.2", "rustls 0.23.37", "rustls-native-certs 0.8.3", - "rustls-pemfile", "rustls-pki-types", "serde", "serde_derive", "serde_json", - "serde_repr", "serde_urlencoded", "thiserror 2.0.18", + "time", "tokio", + "tokio-stream", "tokio-util", + "tonic 0.14.5", "tower-service", "url", "winapi", ] +[[package]] +name = "bollard-buildkit-proto" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85a885520bf6249ab931a764ffdb87b0ceef48e6e7d807cfdb21b751e086e1ad" +dependencies = [ + "prost 0.14.3", + "prost-types", + "tonic 0.14.5", + "tonic-prost", + "ureq", +] + [[package]] name = "bollard-stubs" -version = "1.47.1-rc.27.3.1" +version = "1.52.1-rc.29.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f179cfbddb6e77a5472703d4b30436bff32929c0aa8a9008ecf23d1d3cdd0da" +checksum = "0f0a8ca8799131c1837d1282c3f81f31e76ceb0ce426e04a7fe1ccee3287c066" dependencies = [ + "base64 0.22.1", + "bollard-buildkit-proto", + "bytes", + "prost 0.14.3", "serde", + "serde_json", "serde_repr", - "serde_with", + "time", ] [[package]] @@ -3161,6 +3201,16 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "etcetera" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96" +dependencies = [ + "cfg-if", + "windows-sys 0.61.2", +] + [[package]] name = "evcxr" version = "0.21.1" @@ -3290,6 +3340,17 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "ferroid" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb330bbd4cb7a5b9f559427f06f98a4f853a137c8298f3bd3f8ca57663e21986" +dependencies = [ + "portable-atomic", + "rand 0.9.2", + "web-time", +] + [[package]] name = "ff" version = "0.12.1" @@ -8968,15 +9029,6 @@ dependencies = [ "nom 7.1.3", ] -[[package]] -name = "redox_syscall" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" -dependencies = [ - "bitflags 1.3.2", -] - [[package]] name = "redox_syscall" version = "0.5.18" @@ -10510,7 +10562,7 @@ dependencies = [ "chrono", "crc", "dotenvy", - "etcetera", + "etcetera 0.8.0", "futures-channel", "futures-core", "futures-util", @@ -10911,18 +10963,21 @@ dependencies = [ [[package]] name = "testcontainers" -version = "0.23.3" +version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59a4f01f39bb10fc2a5ab23eb0d888b1e2bb168c157f61a1b98e6c501c639c74" +checksum = "c1c0624faaa317c56d6d19136580be889677259caf5c897941c6f446b4655068" dependencies = [ + "astral-tokio-tar", "async-trait", "bollard", - "bollard-stubs", "bytes", "docker_credential", "either", - "etcetera", + "etcetera 0.11.0", + "ferroid", "futures", + "http 1.4.0", + "itertools 0.14.0", "log", "memchr", "parse-display", @@ -10933,16 +10988,15 @@ dependencies = [ "thiserror 2.0.18", "tokio", "tokio-stream", - "tokio-tar", "tokio-util", "url", ] [[package]] name = "testcontainers-modules" -version = "0.11.6" +version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d43ed4e8f58424c3a2c6c56dbea6643c3c23e8666a34df13c54f0a184e6c707" +checksum = "e5985fde5befe4ffa77a052e035e16c2da86e8bae301baa9f9904ad3c494d357" dependencies = [ "testcontainers", ] @@ -11168,21 +11222,6 @@ dependencies = [ "tokio-util", ] -[[package]] -name = "tokio-tar" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d5714c010ca3e5c27114c1cdeb9d14641ace49874aa5626d7149e47aedace75" -dependencies = [ - "filetime", - "futures-core", - "libc", - "redox_syscall 0.3.5", - "tokio", - "tokio-stream", - "xattr", -] - [[package]] name = "tokio-tungstenite" version = "0.25.0" @@ -11940,6 +11979,33 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" +[[package]] +name = "ureq" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdc97a28575b85cfedf2a7e7d3cc64b3e11bd8ac766666318003abbacc7a21fc" +dependencies = [ + "base64 0.22.1", + "log", + "percent-encoding", + "rustls 0.23.37", + "rustls-pki-types", + "ureq-proto", + "utf-8", +] + +[[package]] +name = "ureq-proto" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d81f9efa9df032be5934a46a068815a10a042b494b6a58cb0a1a97bb5467ed6f" +dependencies = [ + "base64 0.22.1", + "http 1.4.0", + "httparse", + "log", +] + [[package]] name = "url" version = "2.5.8" diff --git a/Cargo.toml b/Cargo.toml index 76b76113a8..3c22e242d4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -245,8 +245,8 @@ tap = "1.0.1" tempfile = "3.18.0" terminal_size = "0.4.2" test-r = { version = "3.0.3", default-features = true } -testcontainers = { version = "0.23.3" } -testcontainers-modules = { version = "0.11.6", features = ["postgres", "redis", "minio", "mysql", ] } +testcontainers = { version = "0.27.1" } +testcontainers-modules = { version = "0.15.0", features = ["postgres", "redis", "minio", "mysql", ] } textwrap = "0.16.1" thiserror = "2.0.12" time = { version = "0.3.41", features = ["default", "macros"] } diff --git a/Makefile.toml b/Makefile.toml index 1abdeebe7c..79e6a6f683 100644 --- a/Makefile.toml +++ b/Makefile.toml @@ -417,11 +417,12 @@ dependencies = [ "integration-tests-group4", "integration-tests-group5", "integration-tests-group6", + "integration-tests-group7", "cli-integration-tests", ] [tasks.integration-tests-group1] -description = "Runs integration tests (group 1/6 - worker, fork)" +description = "Runs integration tests (group 1/7 - worker, fork)" dependencies = ["build-bins-non-ci"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true" } script = ''' @@ -429,7 +430,7 @@ cargo-test-r run --package integration-tests --test integration :tag:group1 -- - ''' [tasks.integration-tests-group2] -description = "Runs integration tests (group 2/6 - worker_local_agent_config, api, custom_api)" +description = "Runs integration tests (group 2/7 - worker_local_agent_config, api, custom_api)" dependencies = ["build-bins-non-ci"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true" } script = ''' @@ -437,7 +438,7 @@ cargo-test-r run --package integration-tests --test integration :tag:group2 -- - ''' [tasks.integration-tests-group3] -description = "Runs integration tests (group 3/6 - worker, fork with sqlite)" +description = "Runs integration tests (group 3/7 - worker, fork with sqlite)" dependencies = ["build-bins-non-ci"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true", "GOLEM_TEST_DB" = "sqlite" } script = ''' @@ -445,7 +446,7 @@ cargo-test-r run --package integration-tests --test integration :tag:group1 -- - ''' [tasks.integration-tests-group4] -description = "Runs integration tests (group 4/6 - worker_local_agent_config, api, custom_api with sqlite)" +description = "Runs integration tests (group 4/7 - worker_local_agent_config, api, custom_api with sqlite)" dependencies = ["build-bins-non-ci"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true", "GOLEM_TEST_DB" = "sqlite" } script = ''' @@ -453,7 +454,7 @@ cargo-test-r run --package integration-tests --test integration :tag:group2 -- - ''' [tasks.integration-tests-group5] -description = "Runs integration tests (group 5/6 - service tests)" +description = "Runs integration tests (group 5/7 - service tests)" dependencies = ["wit"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true" } script = ''' @@ -464,13 +465,21 @@ cargo-test-r run --package golem-debugging-service --test '*' -- --report-time $ ''' [tasks.integration-tests-group6] -description = "Runs integration tests (group 6/6 - sharding)" +description = "Runs integration tests (group 6/7 - sharding)" dependencies = ["build-bins-non-ci"] env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true", "GOLEM__WORKER_EXECUTOR_RETRIES__MAX_ATTEMPTS" = "20", "GOLEM__WORKER_EXECUTOR_RETRIES__MAX_DELAY" = "1s" } script = ''' cargo-test-r run --package integration-tests --test sharding -- --nocapture --report-time $JUNIT_OPTS ''' +[tasks.integration-tests-group7] +description = "Runs integration tests (group 7/7 - otlp_plugin, plugins)" +dependencies = ["build-bins-non-ci"] +env = { "RUST_LOG" = "info", "RUST_BACKTRACE" = "1", "QUIET" = "true" } +script = ''' +cargo-test-r run --package integration-tests --test integration :tag:group7 -- --nocapture --test-threads=1 --report-time $JUNIT_OPTS +''' + [tasks.cli-integration-tests] description = "Runs all CLI integration tests" dependencies = [ @@ -1140,6 +1149,18 @@ install_crate = "miniserve" command = "miniserve" args = ["--interfaces", "127.0.0.1", "--port", "41357", "cli/schema.golem.cloud"] +## PLUGINS +[tasks.build-plugins] +dependencies = ["build"] +description = "Builds built-in plugins (requires golem CLI to be built first)" +script_runner = "@duckscript" +script = ''' +cd plugins/otlp-exporter +exec --fail-on-error ../../target/debug/golem build -P release --force-build +exec --fail-on-error ../../target/debug/golem exec -P release copy +cd ../.. +''' + ## Cleanup [tasks.clear-v8] description = "Removes the v8 crate from the target directories" diff --git a/cli/golem-cli/src/command_handler/worker/stream.rs b/cli/golem-cli/src/command_handler/worker/stream.rs index 9e5155b2ed..75865c9755 100644 --- a/cli/golem-cli/src/command_handler/worker/stream.rs +++ b/cli/golem-cli/src/command_handler/worker/stream.rs @@ -23,7 +23,7 @@ use futures_util::stream::{SplitSink, SplitStream}; use futures_util::{future, pin_mut, SinkExt, StreamExt, TryStreamExt}; use golem_common::model::auth::TokenSecret; use golem_common::model::component::ComponentId; -use golem_common::model::{AgentEvent, IdempotencyKey, Timestamp}; +use golem_common::model::{AgentEvent, IdempotencyKey, LogLevel, Timestamp}; use native_tls::TlsConnector; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; @@ -310,6 +310,22 @@ impl WorkerConnection { } } } + AgentEvent::PluginError { + timestamp, + plugin_name, + message, + } => { + if matching { + output + .emit_log( + timestamp, + LogLevel::Error, + format!("plugin:{plugin_name}"), + message, + ) + .await; + } + } AgentEvent::ClientLagged { number_of_missed_messages, } => { diff --git a/cli/golem/src/launch.rs b/cli/golem/src/launch.rs index 29857d3739..d9775e939c 100644 --- a/cli/golem/src/launch.rs +++ b/cli/golem/src/launch.rs @@ -22,8 +22,8 @@ use golem_common::model::auth::{AccountRole, TokenSecret}; use golem_common::model::plan::{PlanId, PlanName}; use golem_common::model::Empty; use golem_registry_service::config::{ - ComponentCompilationEnabledConfig, LoginConfig, PrecreatedAccount, PrecreatedPlan, - RegistryServiceConfig, + BuiltinPluginsConfig, ComponentCompilationEnabledConfig, LoginConfig, PrecreatedAccount, + PrecreatedPlan, RegistryServiceConfig, }; use golem_registry_service::RegistryService; use golem_service_base::config::BlobStorageConfig; @@ -56,6 +56,7 @@ use tracing::Instrument; use uuid::uuid; const ADMIN_TOKEN: &str = golem_client::LOCAL_WELL_KNOWN_TOKEN; +const BUILTIN_PLUGIN_OWNER_TOKEN: &str = golem_client::LOCAL_WELL_KNOWN_BUILTIN_PLUGIN_OWNER_TOKEN; pub struct LaunchArgs { pub router_addr: String, @@ -215,8 +216,20 @@ fn registry_service_config( role: AccountRole::Admin, }, ); + accounts.insert( + "builtin-plugin-owner".to_string(), + PrecreatedAccount { + id: AccountId(uuid!("b0a654af-d67f-4d73-a824-cf75e122bfc0")), + name: "Builtin Plugin Owner".to_string(), + email: AccountEmail("builtin-plugin-owner@golem.cloud".to_string()), + token: TokenSecret::trusted(BUILTIN_PLUGIN_OWNER_TOKEN.to_string()), + plan_id, + role: AccountRole::BuiltinPluginOwner, + }, + ); accounts }, + builtin_plugins: BuiltinPluginsConfig { enabled: true }, ..Default::default() } } diff --git a/golem-api-grpc/proto/golem/auth/account_role.proto b/golem-api-grpc/proto/golem/auth/account_role.proto index c3dbc06345..3c21d32b66 100644 --- a/golem-api-grpc/proto/golem/auth/account_role.proto +++ b/golem-api-grpc/proto/golem/auth/account_role.proto @@ -6,4 +6,5 @@ enum AccountRole { ACCOUNT_ROLE_UNSPECIFIED = 0; ACCOUNT_ROLE_ADMIN = 1; ACCOUNT_ROLE_MARKETING_ADMIN = 2; + ACCOUNT_ROLE_BUILTIN_PLUGIN_OWNER = 3; } diff --git a/golem-api-grpc/proto/golem/worker/log_event.proto b/golem-api-grpc/proto/golem/worker/log_event.proto index 18cd77c6a4..2ed5db46c2 100644 --- a/golem-api-grpc/proto/golem/worker/log_event.proto +++ b/golem-api-grpc/proto/golem/worker/log_event.proto @@ -13,6 +13,7 @@ message LogEvent { InvocationStarted invocation_started = 4; InvocationFinished invocation_finished = 5; ClientLagged client_lagged = 6; + PluginError plugin_error = 7; } } @@ -54,6 +55,12 @@ message InvocationFinished { IdempotencyKey idempotency_key = 3; } +message PluginError { + google.protobuf.Timestamp timestamp = 1; + string plugin_name = 2; + string message = 3; +} + /** * The client fell behind and the point it left of is no longer in our buffer. * {number_of_skipped_messages} is the number of messages between the client left of and the point it is now at. diff --git a/golem-api-grpc/proto/golem/worker/public_oplog.proto b/golem-api-grpc/proto/golem/worker/public_oplog.proto index 4d4aa0303c..49d59bdacd 100644 --- a/golem-api-grpc/proto/golem/worker/public_oplog.proto +++ b/golem-api-grpc/proto/golem/worker/public_oplog.proto @@ -164,7 +164,7 @@ message PublicAgentInvocationResult { golem.common.Empty manual_update = 3; OptionalError load_snapshot = 4; SnapshotData save_snapshot = 5; - OptionalError process_oplog_entries = 6; + ProcessOplogEntriesResult process_oplog_entries = 6; } } @@ -172,6 +172,10 @@ message OptionalError { optional string error = 1; } +message ProcessOplogEntriesResult { + optional string error = 1; +} + message SnapshotData { oneof data { RawSnapshotData raw = 1; diff --git a/golem-client/src/lib.rs b/golem-client/src/lib.rs index fda5973540..8bd588ea23 100644 --- a/golem-client/src/lib.rs +++ b/golem-client/src/lib.rs @@ -22,6 +22,8 @@ use golem_common::model::plugin_registration::PluginRegistrationCreation; include!(concat!(env!("OUT_DIR"), "/src/lib.rs")); pub const LOCAL_WELL_KNOWN_TOKEN: &str = "5c832d93-ff85-4a8f-9803-513950fdfdb1"; +pub const LOCAL_WELL_KNOWN_BUILTIN_PLUGIN_OWNER_TOKEN: &str = + "32d6072d-64e9-4a4a-b8f9-fadf68bb446b"; #[cfg(test)] test_r::enable!(); diff --git a/golem-common/src/base_model/auth.rs b/golem-common/src/base_model/auth.rs index 26af7f973e..56dfb074e3 100644 --- a/golem-common/src/base_model/auth.rs +++ b/golem-common/src/base_model/auth.rs @@ -117,6 +117,7 @@ declare_enums! { pub enum AccountRole { Admin = 0, MarketingAdmin = 1, + BuiltinPluginOwner = 2, } #[derive(Hash, FromRepr, EnumIter, PartialOrd, Ord)] diff --git a/golem-common/src/base_model/oplog/public_types.rs b/golem-common/src/base_model/oplog/public_types.rs index 1d1724db29..595dc14200 100644 --- a/golem-common/src/base_model/oplog/public_types.rs +++ b/golem-common/src/base_model/oplog/public_types.rs @@ -333,6 +333,14 @@ pub struct SaveSnapshotResultParameters { pub snapshot: PublicSnapshotData, } +#[derive(Clone, Debug, Serialize, PartialEq, Deserialize)] +#[cfg_attr(feature = "full", derive(poem_openapi::Object, IntoValue, FromValue))] +#[cfg_attr(feature = "full", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct ProcessOplogEntriesResultParameters { + pub error: Option, +} + #[derive(Clone, Debug, Serialize, PartialEq, Deserialize)] #[cfg_attr(feature = "full", derive(poem_openapi::Union, IntoValue, FromValue))] #[cfg_attr(feature = "full", oai(discriminator_name = "type", one_of = true))] @@ -344,7 +352,7 @@ pub enum PublicAgentInvocationResult { ManualUpdate(Empty), LoadSnapshot(FallibleResultParameters), SaveSnapshot(SaveSnapshotResultParameters), - ProcessOplogEntries(FallibleResultParameters), + ProcessOplogEntries(ProcessOplogEntriesResultParameters), } #[derive(Clone, Debug, Serialize, PartialEq, Deserialize, IntoValue, FromValue)] diff --git a/golem-common/src/model/auth.rs b/golem-common/src/model/auth.rs index ee0f4036d7..02a86096e7 100644 --- a/golem-common/src/model/auth.rs +++ b/golem-common/src/model/auth.rs @@ -101,6 +101,7 @@ mod protobuf { match value { GrpcAccountRole::Admin => Ok(Self::Admin), GrpcAccountRole::MarketingAdmin => Ok(Self::MarketingAdmin), + GrpcAccountRole::BuiltinPluginOwner => Ok(Self::BuiltinPluginOwner), GrpcAccountRole::Unspecified => Err("unknown account role".to_string()), } } @@ -111,6 +112,7 @@ mod protobuf { match value { AccountRole::Admin => Self::Admin, AccountRole::MarketingAdmin => Self::MarketingAdmin, + AccountRole::BuiltinPluginOwner => Self::BuiltinPluginOwner, } } } diff --git a/golem-common/src/model/mod.rs b/golem-common/src/model/mod.rs index 4401604f96..441b0fc76f 100644 --- a/golem-common/src/model/mod.rs +++ b/golem-common/src/model/mod.rs @@ -1208,6 +1208,11 @@ pub enum AgentEvent { function: String, idempotency_key: IdempotencyKey, }, + PluginError { + timestamp: Timestamp, + plugin_name: String, + message: String, + }, /// The client fell behind and the point it left of is no longer in our buffer. /// {number_of_skipped_messages} is the number of messages between the client left of and the point it is now at. ClientLagged { number_of_missed_messages: u64 }, @@ -1252,6 +1257,13 @@ impl Display for AgentEvent { } => { write!(f, " {function} {idempotency_key}") } + AgentEvent::PluginError { + plugin_name, + message, + .. + } => { + write!(f, " [{plugin_name}] {message}") + } AgentEvent::ClientLagged { number_of_missed_messages, } => { diff --git a/golem-common/src/model/oplog/protobuf.rs b/golem-common/src/model/oplog/protobuf.rs index 329306e232..dcf9bf07c6 100644 --- a/golem-common/src/model/oplog/protobuf.rs +++ b/golem-common/src/model/oplog/protobuf.rs @@ -16,12 +16,13 @@ use super::{ AgentError, AgentInitializationParameters, AgentInvocationOutputParameters, AgentMethodInvocationParameters, AgentResourceId, FallibleResultParameters, JsonSnapshotData, LoadSnapshotParameters, LogLevel, ManualUpdateParameters, OplogCursor, - PluginInstallationDescription, ProcessOplogEntriesParameters, PublicAgentInvocation, - PublicAgentInvocationResult, PublicAttribute, PublicAttributeValue, PublicDurableFunctionType, - PublicExternalSpanData, PublicLocalSpanData, PublicOplogEntry, PublicOplogEntryWithIndex, - PublicRetryConfig, PublicSnapshotData, PublicSpanData, PublicUpdateDescription, - RawSnapshotData, SaveSnapshotResultParameters, SnapshotBasedUpdateParameters, - StringAttributeValue, WriteRemoteBatchedParameters, WriteRemoteTransactionParameters, + PluginInstallationDescription, ProcessOplogEntriesParameters, + ProcessOplogEntriesResultParameters, PublicAgentInvocation, PublicAgentInvocationResult, + PublicAttribute, PublicAttributeValue, PublicDurableFunctionType, PublicExternalSpanData, + PublicLocalSpanData, PublicOplogEntry, PublicOplogEntryWithIndex, PublicRetryConfig, + PublicSnapshotData, PublicSpanData, PublicUpdateDescription, RawSnapshotData, + SaveSnapshotResultParameters, SnapshotBasedUpdateParameters, StringAttributeValue, + WriteRemoteBatchedParameters, WriteRemoteTransactionParameters, }; use crate::base_model::OplogIndex; use crate::model::agent::DataValue; @@ -1464,11 +1465,13 @@ impl TryFrom SaveSnapshotResultParameters { snapshot: data }, )) } - ProtoResult::ProcessOplogEntries(opt_err) => Ok( - PublicAgentInvocationResult::ProcessOplogEntries(FallibleResultParameters { - error: opt_err.error, - }), - ), + ProtoResult::ProcessOplogEntries(result) => { + Ok(PublicAgentInvocationResult::ProcessOplogEntries( + ProcessOplogEntriesResultParameters { + error: result.error, + }, + )) + } } } } @@ -1536,10 +1539,10 @@ impl TryFrom }; ProtoResult::SaveSnapshot(snapshot_data) } - PublicAgentInvocationResult::ProcessOplogEntries(fallible) => { + PublicAgentInvocationResult::ProcessOplogEntries(result) => { ProtoResult::ProcessOplogEntries( - golem_api_grpc::proto::golem::worker::OptionalError { - error: fallible.error, + golem_api_grpc::proto::golem::worker::ProcessOplogEntriesResult { + error: result.error, }, ) } diff --git a/golem-common/src/model/protobuf.rs b/golem-common/src/model/protobuf.rs index 293dd25cfd..64b44f74d7 100644 --- a/golem-common/src/model/protobuf.rs +++ b/golem-common/src/model/protobuf.rs @@ -455,6 +455,13 @@ impl TryFrom for AgentEvent { number_of_missed_messages: event.number_of_missed_messages, }) } + golem::worker::log_event::Event::PluginError(event) => { + Ok(AgentEvent::PluginError { + timestamp: event.timestamp.ok_or("Missing timestamp")?.into(), + plugin_name: event.plugin_name, + message: event.message, + }) + } }, None => Err("Missing event".to_string()), } @@ -528,6 +535,19 @@ impl TryFrom for golem::worker::LogEvent { }, )), }), + AgentEvent::PluginError { + timestamp, + plugin_name, + message, + } => Ok(golem::worker::LogEvent { + event: Some(golem::worker::log_event::Event::PluginError( + golem::worker::PluginError { + timestamp: Some(timestamp.into()), + plugin_name, + message, + }, + )), + }), AgentEvent::ClientLagged { number_of_missed_messages, } => Ok(golem::worker::LogEvent { diff --git a/golem-debugging-service/src/model/params.rs b/golem-debugging-service/src/model/params.rs index 95aaab8556..e9f9186f25 100644 --- a/golem-debugging-service/src/model/params.rs +++ b/golem-debugging-service/src/model/params.rs @@ -119,6 +119,7 @@ impl LogNotification { context, message, }), + InternalWorkerEvent::PluginError { .. } => None, } } } diff --git a/golem-registry-service/config/registry-service.sample.env b/golem-registry-service/config/registry-service.sample.env index cf2fe7c380..0050921287 100644 --- a/golem-registry-service/config/registry-service.sample.env +++ b/golem-registry-service/config/registry-service.sample.env @@ -6,6 +6,7 @@ GOLEM__HTTP_PORT=8081 GOLEM__WORKSPACE="release" GOLEM__BLOB_STORAGE__TYPE="LocalFileSystem" GOLEM__BLOB_STORAGE__CONFIG__ROOT="../data/blob_storage" +GOLEM__BUILTIN_PLUGINS__ENABLED=false GOLEM__COMPONENT_COMPILATION__TYPE="Enabled" GOLEM__COMPONENT_COMPILATION__CONFIG__CONNECT_TIMEOUT="10s" GOLEM__COMPONENT_COMPILATION__CONFIG__HOST="localhost" @@ -26,6 +27,12 @@ GOLEM__DEPLOYMENT_EVENTS__RETENTION="1day" GOLEM__DOMAIN_PROVISIONER__TYPE="NoOp" GOLEM__GRPC__PORT=9090 GOLEM__GRPC__TLS__TYPE="Disabled" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__EMAIL="builtin-plugin-owner@golem.cloud" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__ID="adb2694f-cd9f-425d-905d-ca2888c9c5de" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__NAME="Builtin Plugin Owner" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__PLAN_ID="157dc684-00eb-496d-941c-da8fd1d15c63" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__ROLE="builtin-plugin-owner" +GOLEM__INITIAL_ACCOUNTS__BUILTIN-PLUGIN-OWNER__TOKEN="32d6072d-64e9-4a4a-b8f9-fadf68bb446b" GOLEM__INITIAL_ACCOUNTS__MARKETING__EMAIL="marketing@user" GOLEM__INITIAL_ACCOUNTS__MARKETING__ID="0e8a0431-94b9-4644-89ca-fbf403edb6e7" GOLEM__INITIAL_ACCOUNTS__MARKETING__NAME="Marketing User" diff --git a/golem-registry-service/config/registry-service.toml b/golem-registry-service/config/registry-service.toml index 7d515a3323..9f089c6b2b 100644 --- a/golem-registry-service/config/registry-service.toml +++ b/golem-registry-service/config/registry-service.toml @@ -10,6 +10,9 @@ type = "LocalFileSystem" [blob_storage.config] root = "../data/blob_storage" +[builtin_plugins] +enabled = false + [component_compilation] type = "Enabled" @@ -55,6 +58,14 @@ type = "Disabled" [grpc.tls.config] +[initial_accounts.builtin-plugin-owner] +email = "builtin-plugin-owner@golem.cloud" +id = "adb2694f-cd9f-425d-905d-ca2888c9c5de" +name = "Builtin Plugin Owner" +plan_id = "157dc684-00eb-496d-941c-da8fd1d15c63" +role = "builtin-plugin-owner" +token = "32d6072d-64e9-4a4a-b8f9-fadf68bb446b" + [initial_accounts.marketing] email = "marketing@user" id = "0e8a0431-94b9-4644-89ca-fbf403edb6e7" diff --git a/golem-registry-service/src/api/error.rs b/golem-registry-service/src/api/error.rs index b42f584fe8..8b4782ec12 100644 --- a/golem-registry-service/src/api/error.rs +++ b/golem-registry-service/src/api/error.rs @@ -428,6 +428,10 @@ impl From for ApiError { Self::Conflict(Json(ErrorBody { error, cause: None })) } + EnvironmentPluginGrantError::CannotDeleteBuiltinPluginGrant(_) => { + Self::Forbidden(Json(ErrorBody { error, cause: None })) + } + EnvironmentPluginGrantError::Unauthorized(inner) => inner.into(), EnvironmentPluginGrantError::InternalError(_) => Self::InternalError(Json(ErrorBody { error, diff --git a/golem-registry-service/src/bootstrap/mod.rs b/golem-registry-service/src/bootstrap/mod.rs index 8f5f7d1ae8..afa5e921b4 100644 --- a/golem-registry-service/src/bootstrap/mod.rs +++ b/golem-registry-service/src/bootstrap/mod.rs @@ -203,6 +203,15 @@ impl Services { let auth_service = Arc::new(AuthService::new(repos.account_repo.clone())); + let builtin_plugin_owner_account_id = config + .initial_accounts + .values() + .find(|a| a.role == golem_common::model::auth::AccountRole::BuiltinPluginOwner) + .map(|a| a.id) + .ok_or(anyhow!( + "No builtin-plugin-owner account found in initial_accounts" + ))?; + let application_service = Arc::new(ApplicationService::new( repos.application_repo.clone(), account_service.clone(), @@ -213,6 +222,8 @@ impl Services { repos.environment_repo.clone(), application_service.clone(), account_usage_service.clone(), + repos.plugin_repo.clone(), + builtin_plugin_owner_account_id, )); let environment_share_service = Arc::new(EnvironmentShareService::new( @@ -244,6 +255,7 @@ impl Services { repos.environment_plugin_grant_repo.clone(), environment_service.clone(), plugin_registration_service.clone(), + builtin_plugin_owner_account_id, )); let component_write_service = Arc::new(ComponentWriteService::new( @@ -336,6 +348,23 @@ impl Services { agent_secret_service.clone(), )); + if let Err(e) = crate::services::builtin_plugin_provisioner::provision_builtin_plugins( + &config.builtin_plugins, + builtin_plugin_owner_account_id, + &repos.plugin_repo, + &application_service, + &environment_service, + &component_service, + &component_write_service, + &deployment_service, + &deployment_write_service, + &plugin_registration_service, + ) + .await + { + tracing::warn!("Failed to provision built-in plugins: {e}"); + } + Ok(Self { account_service, account_usage_service, diff --git a/golem-registry-service/src/config.rs b/golem-registry-service/src/config.rs index 841378b506..233ed71690 100644 --- a/golem-registry-service/src/config.rs +++ b/golem-registry-service/src/config.rs @@ -47,6 +47,8 @@ pub struct RegistryServiceConfig { pub initial_accounts: HashMap, pub initial_plans: HashMap, #[serde(default)] + pub builtin_plugins: BuiltinPluginsConfig, + #[serde(default)] pub deployment_events: DeploymentEventsConfig, } @@ -91,6 +93,12 @@ impl SafeDisplay for RegistryServiceConfig { self.component_compilation.to_safe_string_indented() ); + let _ = writeln!( + &mut result, + "builtin plugins: enabled={}", + self.builtin_plugins.enabled, + ); + let _ = writeln!(&mut result, "deployment events:"); let _ = writeln!( &mut result, @@ -109,7 +117,7 @@ impl SafeDisplay for RegistryServiceConfig { impl Default for RegistryServiceConfig { fn default() -> Self { - let mut initial_accounts = HashMap::with_capacity(2); + let mut initial_accounts = HashMap::with_capacity(3); initial_accounts.insert( "root".to_string(), PrecreatedAccount { @@ -136,6 +144,17 @@ impl Default for RegistryServiceConfig { plan_id: PlanId(uuid!("157dc684-00eb-496d-941c-da8fd1d15c63")), }, ); + initial_accounts.insert( + "builtin-plugin-owner".to_string(), + PrecreatedAccount { + id: AccountId(uuid!("adb2694f-cd9f-425d-905d-ca2888c9c5de")), + name: "Builtin Plugin Owner".to_string(), + email: AccountEmail("builtin-plugin-owner@golem.cloud".to_string()), + token: TokenSecret::trusted("32d6072d-64e9-4a4a-b8f9-fadf68bb446b".to_string()), + role: AccountRole::BuiltinPluginOwner, + plan_id: PlanId(uuid!("157dc684-00eb-496d-941c-da8fd1d15c63")), + }, + ); let mut initial_plans = HashMap::with_capacity(1); initial_plans.insert( @@ -170,6 +189,7 @@ impl Default for RegistryServiceConfig { domain_provisioner: DomainProvisionerConfig::default(), initial_accounts, initial_plans, + builtin_plugins: BuiltinPluginsConfig::default(), deployment_events: DeploymentEventsConfig::default(), } } @@ -373,6 +393,11 @@ impl ComponentCompilationEnabledConfig { } } +#[derive(Clone, Debug, Serialize, Deserialize, Default)] +pub struct BuiltinPluginsConfig { + pub enabled: bool, +} + #[derive(Clone, Debug, Serialize, Deserialize)] pub struct PrecreatedAccount { pub id: AccountId, diff --git a/golem-registry-service/src/repo/environment.rs b/golem-registry-service/src/repo/environment.rs index 9b72937f7b..05333e2702 100644 --- a/golem-registry-service/src/repo/environment.rs +++ b/golem-registry-service/src/repo/environment.rs @@ -19,6 +19,7 @@ use crate::repo::model::BindFields; pub use crate::repo::model::environment::{ EnvironmentExtRecord, EnvironmentExtRevisionRecord, EnvironmentRevisionRecord, }; +use crate::repo::model::environment_plugin_grant::EnvironmentPluginGrantRecord; use async_trait::async_trait; use conditional_trait_gen::trait_gen; use futures::FutureExt; @@ -65,6 +66,13 @@ pub trait EnvironmentRepo: Send + Sync { revision: EnvironmentRevisionRecord, ) -> Result; + async fn create_with_plugin_grants( + &self, + application_id: Uuid, + revision: EnvironmentRevisionRecord, + plugin_grants: Vec, + ) -> Result; + async fn update( &self, revision: EnvironmentRevisionRecord, @@ -159,6 +167,19 @@ impl EnvironmentRepo for LoggedEnvironmentRepo { .await } + async fn create_with_plugin_grants( + &self, + application_id: Uuid, + revision: EnvironmentRevisionRecord, + plugin_grants: Vec, + ) -> Result { + let span = Self::span_app_id(application_id); + self.repo + .create_with_plugin_grants(application_id, revision, plugin_grants) + .instrument(span) + .await + } + async fn update( &self, revision: EnvironmentRevisionRecord, @@ -521,6 +542,85 @@ impl EnvironmentRepo for DbEnvironmentRepo { }.boxed()).await } + async fn create_with_plugin_grants( + &self, + application_id: Uuid, + revision: EnvironmentRevisionRecord, + plugin_grants: Vec, + ) -> Result { + self.with_tx_err("create_with_plugin_grants", |tx| async move { + let environment_record: EnvironmentExtRecord = tx.fetch_one_as( + sqlx::query_as(indoc! { r#" + INSERT INTO environments + (environment_id, name, application_id, created_at, updated_at, deleted_at, modified_by, current_revision_id) + VALUES + ($1, $2, $3, $4, $4, NULL, $5, 0) + RETURNING + environment_id, + name, + application_id, + created_at, + updated_at, + deleted_at, + modified_by, + current_revision_id, + + -- Owner account id via scalar subquery + (SELECT a.account_id + FROM applications ap + JOIN accounts a ON a.account_id = ap.account_id + WHERE ap.application_id = environments.application_id) AS owner_account_id, + + -- Hard-coded defaults + 0 AS environment_roles_from_shares, + NULL AS current_deployment_revision, + NULL AS current_deployment_deployment_revision, + NULL AS current_deployment_deployment_version, + NULL AS current_deployment_deployment_hash; + "# }) + .bind(revision.environment_id) + .bind(&revision.name) + .bind(application_id) + .bind(&revision.audit.created_at) + .bind(revision.audit.created_by) + ).await + .to_error_on_unique_violation(EnvironmentRepoError::EnvironmentViolatesUniqueness)?; + + let revision = Self::insert_revision(tx, revision).await?; + + for grant in plugin_grants { + tx.execute( + sqlx::query(indoc! {r#" + INSERT INTO environment_plugin_grants ( + environment_plugin_grant_id, environment_id, plugin_id, + created_at, created_by, deleted_at, deleted_by + ) + VALUES ($1, $2, $3, $4, $5, $6, $7) + ON CONFLICT (environment_id, plugin_id) WHERE deleted_at IS NULL DO NOTHING + "#}) + .bind(grant.environment_plugin_grant_id) + .bind(grant.environment_id) + .bind(grant.plugin_id) + .bind_immutable_audit(grant.audit), + ).await + .map_err(|e| EnvironmentRepoError::InternalError(e.into()))?; + } + + Ok(EnvironmentExtRevisionRecord { + application_id, + revision, + + owner_account_id: environment_record.owner_account_id, + environment_roles_from_shares: environment_record.environment_roles_from_shares, + + current_deployment_revision: environment_record.current_deployment_revision, + current_deployment_deployment_revision: environment_record.current_deployment_deployment_revision, + current_deployment_deployment_version: environment_record.current_deployment_deployment_version, + current_deployment_deployment_hash: environment_record.current_deployment_deployment_hash + }) + }.boxed()).await + } + async fn update( &self, revision: EnvironmentRevisionRecord, diff --git a/golem-registry-service/src/repo/model/account.rs b/golem-registry-service/src/repo/model/account.rs index 339f2f941a..abe4bf4602 100644 --- a/golem-registry-service/src/repo/model/account.rs +++ b/golem-registry-service/src/repo/model/account.rs @@ -131,6 +131,7 @@ fn role_bit(role: &AccountRole) -> i32 { match role { AccountRole::Admin => 1, AccountRole::MarketingAdmin => 1 << 1, + AccountRole::BuiltinPluginOwner => 1 << 2, } } diff --git a/golem-registry-service/src/services/builtin_plugin_provisioner.rs b/golem-registry-service/src/services/builtin_plugin_provisioner.rs new file mode 100644 index 0000000000..05cd4ef38f --- /dev/null +++ b/golem-registry-service/src/services/builtin_plugin_provisioner.rs @@ -0,0 +1,376 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::config::BuiltinPluginsConfig; +use crate::repo::plugin::PluginRepo; +use crate::services::application::{ApplicationError, ApplicationService}; +use crate::services::component::{ComponentError, ComponentService, ComponentWriteService}; +use crate::services::deployment::{DeploymentService, DeploymentWriteService}; +use crate::services::environment::{EnvironmentError, EnvironmentService}; + +use crate::services::plugin_registration::{PluginRegistrationError, PluginRegistrationService}; +use golem_common::golem_version; +use golem_common::model::account::AccountId; +use golem_common::model::application::{ + Application, ApplicationCreation, ApplicationId, ApplicationName, +}; +use golem_common::model::base64::Base64; +use golem_common::model::component::{ComponentCreation, ComponentName, ComponentUpdate}; +use golem_common::model::deployment::{DeploymentCreation, DeploymentVersion}; +use golem_common::model::diff; +use golem_common::model::environment::{ + Environment, EnvironmentCreation, EnvironmentId, EnvironmentName, +}; +use golem_common::model::plugin_registration::{ + OplogProcessorPluginSpec, PluginRegistrationCreation, PluginSpecDto, +}; +use golem_service_base::model::auth::AuthCtx; +use golem_service_base::model::component::Component; +use std::collections::BTreeMap; +use std::sync::Arc; +use uuid::Uuid; + +const SYSTEM_APP_NAME: &str = "golem-system"; +const SYSTEM_ENV_NAME: &str = "builtin-plugins"; + +struct BuiltinPluginDescriptor { + component_name: &'static str, + plugin_name: &'static str, + description: &'static str, + wasm_bytes: &'static [u8], +} + +impl BuiltinPluginDescriptor { + fn plugin_spec(&self, component: &Component) -> PluginSpecDto { + PluginSpecDto::OplogProcessor(OplogProcessorPluginSpec { + component_id: component.id, + component_revision: component.revision, + }) + } +} + +// Build with `cargo make build-plugins` first to ensure the WASM files exist. +static BUILTIN_PLUGINS: &[BuiltinPluginDescriptor] = &[BuiltinPluginDescriptor { + component_name: "otlp:exporter", + plugin_name: "golem-otlp-exporter", + description: "Built-in OTLP exporter oplog processor plugin", + wasm_bytes: include_bytes!("../../../plugins/otlp-exporter.wasm"), +}]; + +pub async fn provision_builtin_plugins( + config: &BuiltinPluginsConfig, + builtin_plugin_owner_account_id: AccountId, + plugin_repo: &Arc, + application_service: &Arc, + environment_service: &Arc, + component_service: &Arc, + component_write_service: &Arc, + deployment_service: &Arc, + deployment_write_service: &Arc, + plugin_registration_service: &Arc, +) -> anyhow::Result<()> { + if !config.enabled { + return Ok(()); + } + + let auth = AuthCtx::system(); + let plugin_version = golem_version().to_string(); + + let app = get_or_create_application( + application_service, + builtin_plugin_owner_account_id, + &ApplicationName(SYSTEM_APP_NAME.to_string()), + &auth, + ) + .await?; + + let env = get_or_create_environment( + environment_service, + app.id, + &EnvironmentName(SYSTEM_ENV_NAME.to_string()), + &auth, + ) + .await?; + + let mut components = Vec::new(); + for descriptor in BUILTIN_PLUGINS { + let component = upload_or_update_component( + component_service, + component_write_service, + env.id, + &ComponentName(descriptor.component_name.to_string()), + descriptor.wasm_bytes, + &auth, + ) + .await?; + components.push((descriptor, component)); + } + + deploy_environment(deployment_service, deployment_write_service, env.id, &auth).await; + + for (descriptor, component) in &components { + register_plugin( + plugin_registration_service, + plugin_repo, + builtin_plugin_owner_account_id, + descriptor, + &plugin_version, + component, + &auth, + ) + .await?; + } + + tracing::info!("Built-in plugins provisioned successfully"); + Ok(()) +} + +async fn get_or_create_application( + application_service: &Arc, + account_id: AccountId, + app_name: &ApplicationName, + auth: &AuthCtx, +) -> anyhow::Result { + match application_service + .get_in_account(account_id, app_name, auth) + .await + { + Ok(app) => Ok(app), + Err(ApplicationError::ApplicationByNameNotFound(_)) => { + match application_service + .create( + account_id, + ApplicationCreation { + name: app_name.clone(), + }, + auth, + ) + .await + { + Ok(app) => Ok(app), + Err(ApplicationError::ApplicationWithNameAlreadyExists) => application_service + .get_in_account(account_id, app_name, auth) + .await + .map_err(|e| { + anyhow::anyhow!("Failed to re-read application '{app_name}': {e}") + }), + Err(other) => Err(anyhow::anyhow!( + "Failed to create application '{app_name}': {other}" + )), + } + } + Err(other) => Err(anyhow::anyhow!( + "Failed to look up application '{app_name}': {other}" + )), + } +} + +async fn get_or_create_environment( + environment_service: &Arc, + app_id: ApplicationId, + env_name: &EnvironmentName, + auth: &AuthCtx, +) -> anyhow::Result { + match environment_service + .get_in_application(app_id, env_name, auth) + .await + { + Ok(env) => Ok(env), + Err(EnvironmentError::EnvironmentByNameNotFound(_)) => { + match environment_service + .create( + app_id, + EnvironmentCreation { + name: env_name.clone(), + compatibility_check: false, + version_check: false, + security_overrides: false, + }, + auth, + ) + .await + { + Ok(env) => Ok(env), + Err(EnvironmentError::EnvironmentWithNameAlreadyExists) => environment_service + .get_in_application(app_id, env_name, auth) + .await + .map_err(|e| { + anyhow::anyhow!("Failed to re-read environment '{env_name}': {e}") + }), + Err(other) => Err(anyhow::anyhow!( + "Failed to create environment '{env_name}': {other}" + )), + } + } + Err(other) => Err(anyhow::anyhow!( + "Failed to look up environment '{env_name}': {other}" + )), + } +} + +async fn upload_or_update_component( + component_service: &Arc, + component_write_service: &Arc, + env_id: EnvironmentId, + component_name: &ComponentName, + wasm_bytes: &[u8], + auth: &AuthCtx, +) -> anyhow::Result { + let embedded_wasm_hash = diff::Hash::new(blake3::hash(wasm_bytes)); + + match component_write_service + .create( + env_id, + ComponentCreation { + component_name: component_name.clone(), + file_options: BTreeMap::new(), + env: BTreeMap::new(), + config_vars: BTreeMap::new(), + agent_config: Vec::new(), + agent_types: Vec::new(), + plugins: Vec::new(), + }, + wasm_bytes.to_vec(), + None, + auth, + ) + .await + { + Ok(component) => Ok(component), + Err(ComponentError::ComponentWithNameAlreadyExists(_)) => { + let existing = component_service + .get_staged_component_by_name(env_id, component_name, auth) + .await + .map_err(|e| { + anyhow::anyhow!("Failed to get existing component '{component_name}': {e}") + })?; + + if existing.wasm_hash == embedded_wasm_hash { + tracing::info!( + "Component '{component_name}' is already up to date, skipping update" + ); + Ok(existing) + } else { + tracing::info!("Component '{component_name}' has changed, updating"); + component_write_service + .update( + existing.id, + ComponentUpdate { + current_revision: existing.revision, + removed_files: Vec::new(), + new_file_options: BTreeMap::new(), + env: None, + config_vars: None, + agent_config: None, + agent_types: None, + plugin_updates: Vec::new(), + }, + Some(wasm_bytes.to_vec()), + None, + auth, + ) + .await + .map_err(|e| { + anyhow::anyhow!("Failed to update component '{component_name}': {e}") + }) + } + } + Err(other) => Err(anyhow::anyhow!( + "Failed to create component '{component_name}': {other}" + )), + } +} + +async fn deploy_environment( + deployment_service: &Arc, + deployment_write_service: &Arc, + env_id: EnvironmentId, + auth: &AuthCtx, +) { + let plan = match deployment_service + .get_current_deployment_plan(env_id, auth) + .await + { + Ok(plan) => plan, + Err(e) => { + tracing::warn!("Failed to get deployment plan for environment {env_id}: {e}"); + return; + } + }; + + match deployment_write_service + .create_deployment( + env_id, + DeploymentCreation { + current_revision: plan.current_revision, + expected_deployment_hash: plan.deployment_hash, + version: DeploymentVersion(Uuid::new_v4().to_string()), + agent_secret_defaults: Vec::new(), + }, + auth, + ) + .await + { + Ok(_) => { + tracing::info!("Deployed environment {env_id}"); + } + Err(e) => { + tracing::warn!("Failed to deploy environment {env_id} (may already be deployed): {e}"); + } + } +} + +async fn register_plugin( + plugin_registration_service: &Arc, + plugin_repo: &Arc, + account_id: AccountId, + descriptor: &BuiltinPluginDescriptor, + plugin_version: &str, + component: &Component, + auth: &AuthCtx, +) -> anyhow::Result<()> { + let plugin_name = descriptor.plugin_name; + match plugin_registration_service + .register_plugin( + account_id, + PluginRegistrationCreation { + name: plugin_name.to_string(), + version: plugin_version.to_string(), + description: descriptor.description.to_string(), + icon: Base64(Vec::new()), + homepage: "https://golem.cloud".to_string(), + spec: descriptor.plugin_spec(component), + }, + auth, + ) + .await + { + Ok(_) => Ok(()), + Err(PluginRegistrationError::PluginNameAndVersionAlreadyExists) => { + let _record = plugin_repo + .get_by_name_and_version(account_id.0, plugin_name, plugin_version) + .await + .map_err(|e| { + anyhow::anyhow!("Failed to look up existing plugin '{plugin_name}': {e}") + })? + .ok_or_else(|| { + anyhow::anyhow!("Plugin '{plugin_name}' exists but could not be loaded") + })?; + Ok(()) + } + Err(other) => Err(anyhow::anyhow!( + "Failed to register plugin '{plugin_name}': {other}" + )), + } +} diff --git a/golem-registry-service/src/services/environment.rs b/golem-registry-service/src/services/environment.rs index cb82dd6cd4..ba698f0807 100644 --- a/golem-registry-service/src/services/environment.rs +++ b/golem-registry-service/src/services/environment.rs @@ -18,13 +18,16 @@ use super::application::ApplicationService; use crate::repo::environment::{EnvironmentRepo, EnvironmentRevisionRecord}; use crate::repo::model::audit::DeletableRevisionAuditFields; use crate::repo::model::environment::EnvironmentRepoError; +use crate::repo::model::environment_plugin_grant::EnvironmentPluginGrantRecord; +use crate::repo::plugin::PluginRepo; use crate::services::application::ApplicationError; -use golem_common::model::account::AccountEmail; +use golem_common::model::account::{AccountEmail, AccountId}; use golem_common::model::application::{ApplicationId, ApplicationName}; use golem_common::model::environment::{ Environment, EnvironmentCreation, EnvironmentId, EnvironmentName, EnvironmentRevision, EnvironmentUpdate, EnvironmentWithDetails, }; +use golem_common::model::plugin_registration::PluginRegistrationId; use golem_common::{IntoAnyhow, SafeDisplay, error_forwarding}; use golem_service_base::model::auth::{AccountAction, EnvironmentAction}; use golem_service_base::model::auth::{AuthCtx, AuthorizationError}; @@ -88,6 +91,8 @@ pub struct EnvironmentService { environment_repo: Arc, application_service: Arc, account_usage_service: Arc, + plugin_repo: Arc, + builtin_plugin_owner_account_id: AccountId, } impl EnvironmentService { @@ -95,11 +100,15 @@ impl EnvironmentService { environment_repo: Arc, application_service: Arc, account_usage_service: Arc, + plugin_repo: Arc, + builtin_plugin_owner_account_id: AccountId, ) -> Self { Self { environment_repo, application_service, account_usage_service, + plugin_repo, + builtin_plugin_owner_account_id, } } @@ -128,9 +137,25 @@ impl EnvironmentService { let record = EnvironmentRevisionRecord::creation(data, auth.account_id()); + let builtin_plugins = self + .plugin_repo + .list_by_account(self.builtin_plugin_owner_account_id.0) + .await?; + + let plugin_grants: Vec = builtin_plugins + .into_iter() + .map(|p| { + EnvironmentPluginGrantRecord::creation( + EnvironmentId(record.environment_id), + PluginRegistrationId(p.plugin_id), + auth.account_id(), + ) + }) + .collect(); + let result = self .environment_repo - .create(application_id.0, record) + .create_with_plugin_grants(application_id.0, record, plugin_grants) .await .map_err(|err| match err { EnvironmentRepoError::EnvironmentViolatesUniqueness => { diff --git a/golem-registry-service/src/services/environment_plugin_grant.rs b/golem-registry-service/src/services/environment_plugin_grant.rs index 1303327deb..1f62d502b6 100644 --- a/golem-registry-service/src/services/environment_plugin_grant.rs +++ b/golem-registry-service/src/services/environment_plugin_grant.rs @@ -18,6 +18,7 @@ use crate::repo::environment_plugin_grant::EnvironmentPluginGrantRepo; use crate::repo::model::environment_plugin_grant::{ EnvironmentPluginGrantRecord, EnvironmentPluginGrantRepoError, }; +use golem_common::model::account::AccountId; use golem_common::model::environment::{Environment, EnvironmentId}; use golem_common::model::environment_plugin_grant::{ EnvironmentPluginGrant, EnvironmentPluginGrantCreation, EnvironmentPluginGrantId, @@ -39,6 +40,8 @@ pub enum EnvironmentPluginGrantError { EnvironmentPluginGrantNotFound(EnvironmentPluginGrantId), #[error("Grant for this plugin already exists in this environment")] GrantForPluginAlreadyExists, + #[error("Cannot delete built-in plugin grant {0}")] + CannotDeleteBuiltinPluginGrant(EnvironmentPluginGrantId), #[error(transparent)] Unauthorized(#[from] AuthorizationError), #[error(transparent)] @@ -50,6 +53,7 @@ impl SafeDisplay for EnvironmentPluginGrantError { match self { Self::EnvironmentPluginGrantNotFound(_) => self.to_string(), Self::GrantForPluginAlreadyExists => self.to_string(), + Self::CannotDeleteBuiltinPluginGrant(_) => self.to_string(), Self::ReferencedPluginNotFound(_) => self.to_string(), Self::ParentEnvironmentNotFound(_) => self.to_string(), Self::Unauthorized(inner) => inner.to_safe_string(), @@ -69,6 +73,7 @@ pub struct EnvironmentPluginGrantService { environment_plugin_grant_repo: Arc, environment_service: Arc, plugin_registration_service: Arc, + builtin_plugin_owner_account_id: AccountId, } impl EnvironmentPluginGrantService { @@ -76,11 +81,13 @@ impl EnvironmentPluginGrantService { environment_plugin_grant_repo: Arc, environment_service: Arc, plugin_registration_service: Arc, + builtin_plugin_owner_account_id: AccountId, ) -> Self { Self { environment_plugin_grant_repo, environment_service, plugin_registration_service, + builtin_plugin_owner_account_id, } } @@ -143,7 +150,7 @@ impl EnvironmentPluginGrantService { environment_plugin_grant_id: EnvironmentPluginGrantId, auth: &AuthCtx, ) -> Result<(), EnvironmentPluginGrantError> { - let (_, environment) = self + let (grant, environment) = self .get_by_id_with_environment(environment_plugin_grant_id, false, auth) .await?; @@ -153,6 +160,12 @@ impl EnvironmentPluginGrantService { EnvironmentAction::DeleteEnvironmentPluginGrant, )?; + if grant.plugin_account.id == self.builtin_plugin_owner_account_id { + return Err(EnvironmentPluginGrantError::CannotDeleteBuiltinPluginGrant( + environment_plugin_grant_id, + )); + } + self.environment_plugin_grant_repo .delete(environment_plugin_grant_id.0, auth.account_id().0) .await?; diff --git a/golem-registry-service/src/services/mod.rs b/golem-registry-service/src/services/mod.rs index 327202464c..726c03770e 100644 --- a/golem-registry-service/src/services/mod.rs +++ b/golem-registry-service/src/services/mod.rs @@ -17,6 +17,7 @@ pub mod account_usage; pub mod agent_secret; pub mod application; pub mod auth; +pub mod builtin_plugin_provisioner; pub mod component; pub mod component_compilation; pub mod component_object_store; diff --git a/golem-test-framework/src/components/docker.rs b/golem-test-framework/src/components/docker.rs index dc6f34d7cf..9b0ff6af8e 100644 --- a/golem-test-framework/src/components/docker.rs +++ b/golem-test-framework/src/components/docker.rs @@ -39,7 +39,7 @@ pub(super) async fn get_docker_container_name(prefix: &str, container_id: &str) .await .expect("Failed to get docker client instance"); let network = client - .inspect_network::(&network(prefix), None) + .inspect_network(&network(prefix), None) .await .expect("Failed to get network"); let containers = network.containers.expect("Containers not found in network"); diff --git a/golem-test-framework/src/components/jaeger/docker.rs b/golem-test-framework/src/components/jaeger/docker.rs new file mode 100644 index 0000000000..1ef14c980c --- /dev/null +++ b/golem-test-framework/src/components/jaeger/docker.rs @@ -0,0 +1,92 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::components::docker::ContainerHandle; +use crate::components::jaeger::{wait_for_startup, Jaeger}; +use async_trait::async_trait; +use std::fmt::{Debug, Formatter}; +use std::time::Duration; +use testcontainers::core::{IntoContainerPort, WaitFor}; +use testcontainers::runners::AsyncRunner; +use testcontainers::{ContainerAsync, GenericImage, ImageExt}; +use tracing::info; + +pub struct DockerJaeger { + container: ContainerHandle, + otlp_http_port: u16, + query_port: u16, +} + +impl DockerJaeger { + const OTLP_HTTP_PORT: u16 = 4318; + const QUERY_PORT: u16 = 16686; + + pub async fn new() -> Self { + info!("Starting Jaeger container"); + + let container: ContainerAsync = tryhard::retry_fn(|| { + GenericImage::new("jaegertracing/all-in-one", "1.76.0") + .with_wait_for(WaitFor::seconds(5)) + .with_exposed_port(Self::OTLP_HTTP_PORT.tcp()) + .with_exposed_port(Self::QUERY_PORT.tcp()) + .with_env_var("COLLECTOR_OTLP_ENABLED", "true") + .start() + }) + .retries(5) + .exponential_backoff(Duration::from_millis(10)) + .max_delay(Duration::from_secs(10)) + .await + .expect("Failed to start Jaeger container"); + + let otlp_http_port = container + .get_host_port_ipv4(Self::OTLP_HTTP_PORT) + .await + .expect("Failed to get OTLP HTTP host port"); + + let query_port = container + .get_host_port_ipv4(Self::QUERY_PORT) + .await + .expect("Failed to get Jaeger query host port"); + + let query_url = format!("http://localhost:{query_port}"); + wait_for_startup(&query_url, Duration::from_secs(30)).await; + + Self { + container: ContainerHandle::new(container), + otlp_http_port, + query_port, + } + } +} + +#[async_trait] +impl Jaeger for DockerJaeger { + fn otlp_http_endpoint(&self) -> String { + format!("http://localhost:{}", self.otlp_http_port) + } + + fn query_url(&self) -> String { + format!("http://localhost:{}", self.query_port) + } + + async fn kill(&self) { + self.container.kill().await + } +} + +impl Debug for DockerJaeger { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "DockerJaeger") + } +} diff --git a/golem-test-framework/src/components/jaeger/mod.rs b/golem-test-framework/src/components/jaeger/mod.rs new file mode 100644 index 0000000000..4b9066ec52 --- /dev/null +++ b/golem-test-framework/src/components/jaeger/mod.rs @@ -0,0 +1,302 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use async_trait::async_trait; +use serde::Deserialize; +use std::collections::HashSet; +use std::fmt::Debug; +use std::time::Duration; +use tokio::time::Instant; +use tracing::{debug, info}; + +mod docker; + +#[async_trait] +pub trait Jaeger: Send + Sync { + fn otlp_http_endpoint(&self) -> String; + fn query_url(&self) -> String; + async fn kill(&self); +} + +pub use docker::DockerJaeger; + +pub struct JaegerQueryClient { + client: reqwest::Client, + base_url: String, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JaegerQueryResponse { + pub data: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JaegerTrace { + #[serde(rename = "traceID")] + pub trace_id: String, + pub spans: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JaegerSpan { + #[serde(rename = "traceID")] + pub trace_id: String, + #[serde(rename = "spanID")] + pub span_id: String, + #[serde(rename = "operationName")] + pub operation_name: String, + pub references: Vec, + pub tags: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JaegerReference { + #[serde(rename = "refType")] + pub ref_type: String, + #[serde(rename = "traceID")] + pub trace_id: String, + #[serde(rename = "spanID")] + pub span_id: String, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JaegerTag { + pub key: String, + #[serde(rename = "type")] + pub tag_type: String, + pub value: serde_json::Value, +} + +impl JaegerTrace { + /// Returns the set of all span IDs in this trace. + pub fn span_ids(&self) -> HashSet<&str> { + self.spans.iter().map(|s| s.span_id.as_str()).collect() + } + + /// Logs each span with its parent relationship status. + /// + /// `known_external_parent_ids` contains span IDs that are expected to be + /// outside this trace (e.g. the caller's span ID from a `traceparent` header). + /// References to these IDs are labelled `[external-caller]` rather than + /// `[DISCONNECTED]`. + pub fn dump_spans(&self, known_external_parent_ids: &HashSet<&str>) { + let span_ids = self.span_ids(); + for span in &self.spans { + let parent_id = span.parent_span_id().unwrap_or("(root)"); + let parent_status = if parent_id == "(root)" { + "" + } else if span_ids.contains(parent_id) { + " [connected]" + } else if known_external_parent_ids.contains(parent_id) { + " [external-caller]" + } else { + " [DISCONNECTED]" + }; + let tags_summary: Vec = span + .tags + .iter() + .filter(|t| { + !t.key.starts_with("otel.scope") + && t.key != "span.kind" + && t.key != "w3c.tracestate" + }) + .map(|t| format!("{}={}", t.key, t.value)) + .collect(); + info!( + " span {} '{}' parent={}{} tags=[{}]", + span.span_id, + span.operation_name, + parent_id, + parent_status, + tags_summary.join(", ") + ); + } + } + + /// Returns span IDs whose parent references a span not present in this + /// trace and not listed in `known_external_parent_ids`. + pub fn disconnected_spans( + &self, + known_external_parent_ids: &HashSet<&str>, + ) -> Vec<(&str, &str)> { + let span_ids = self.span_ids(); + self.spans + .iter() + .filter_map(|s| { + s.parent_span_id().and_then(|pid| { + if !span_ids.contains(pid) && !known_external_parent_ids.contains(pid) { + Some((s.span_id.as_str(), pid)) + } else { + None + } + }) + }) + .collect() + } + + /// Returns operation names of spans that have `otel.status_code = ERROR`. + pub fn error_spans(&self) -> Vec<&str> { + self.spans + .iter() + .filter(|s| { + s.tags + .iter() + .any(|t| t.key == "otel.status_code" && t.value == "ERROR") + }) + .map(|s| s.operation_name.as_str()) + .collect() + } + + /// Returns span IDs of spans whose operation name is `"unknown"`. + pub fn unknown_name_spans(&self) -> Vec<&str> { + self.spans + .iter() + .filter(|s| s.operation_name == "unknown") + .map(|s| s.span_id.as_str()) + .collect() + } +} + +impl JaegerSpan { + /// Returns the parent span ID from the first CHILD_OF reference, if any. + pub fn parent_span_id(&self) -> Option<&str> { + self.references.first().map(|r| r.span_id.as_str()) + } + + /// Returns the value of a tag by key, if present. + pub fn tag_value(&self, key: &str) -> Option<&serde_json::Value> { + self.tags.iter().find(|t| t.key == key).map(|t| &t.value) + } +} + +#[derive(Debug, Clone, Deserialize)] +struct JaegerServicesResponse { + data: Vec, +} + +impl JaegerQueryClient { + pub fn new(base_url: &str) -> Self { + Self { + client: reqwest::Client::new(), + base_url: base_url.trim_end_matches('/').to_string(), + } + } + + pub async fn get_trace(&self, trace_id: &str) -> anyhow::Result> { + let url = format!("{}/api/traces/{}", self.base_url, trace_id); + let response = self.client.get(&url).send().await?; + + if response.status() == reqwest::StatusCode::NOT_FOUND { + return Ok(None); + } + + let response = response.error_for_status()?; + let body: JaegerQueryResponse = response.json().await?; + Ok(body.data.into_iter().next()) + } + + pub async fn wait_for_trace( + &self, + trace_id: &str, + timeout: Duration, + ) -> anyhow::Result { + let start = Instant::now(); + loop { + match self.get_trace(trace_id).await { + Ok(Some(trace)) => return Ok(trace), + Ok(None) => {} + Err(e) => { + debug!("Error fetching trace {trace_id}: {e}"); + } + } + if start.elapsed() > timeout { + anyhow::bail!( + "Timed out waiting for trace {trace_id} after {}s", + timeout.as_secs() + ); + } + tokio::time::sleep(Duration::from_secs(1)).await; + } + } + + pub async fn wait_for_trace_with_min_spans( + &self, + trace_id: &str, + min_spans: usize, + timeout: Duration, + ) -> anyhow::Result { + let start = Instant::now(); + let mut last_count = 0; + loop { + match self.get_trace(trace_id).await { + Ok(Some(trace)) if trace.spans.len() >= min_spans => return Ok(trace), + Ok(Some(trace)) => { + if trace.spans.len() != last_count { + info!( + "Trace {trace_id} has {} spans so far, waiting for at least {min_spans}", + trace.spans.len() + ); + last_count = trace.spans.len(); + } + } + Ok(None) => {} + Err(e) => { + debug!("Error fetching trace {trace_id}: {e}"); + } + } + if start.elapsed() > timeout { + anyhow::bail!( + "Timed out waiting for trace {trace_id} with {min_spans} spans after {}s (last seen: {last_count} spans)", + timeout.as_secs() + ); + } + tokio::time::sleep(Duration::from_secs(1)).await; + } + } + + pub async fn get_services(&self) -> anyhow::Result> { + let url = format!("{}/api/services", self.base_url); + let response = self.client.get(&url).send().await?.error_for_status()?; + let body: JaegerServicesResponse = response.json().await?; + Ok(body.data) + } +} + +async fn wait_for_startup(query_url: &str, timeout: Duration) { + info!( + "Waiting for Jaeger start at {query_url}, timeout: {}s", + timeout.as_secs() + ); + let client = reqwest::Client::new(); + let url = format!("{}/api/services", query_url.trim_end_matches('/')); + let start = Instant::now(); + loop { + match client.get(&url).send().await { + Ok(resp) if resp.status().is_success() => { + info!("Jaeger is ready at {query_url}"); + return; + } + Ok(resp) => { + debug!("Jaeger not ready yet, status: {}", resp.status()); + } + Err(e) => { + debug!("Jaeger not ready yet: {e}"); + } + } + if start.elapsed() > timeout { + panic!("Failed to verify that Jaeger is running at {query_url}"); + } + tokio::time::sleep(Duration::from_secs(1)).await; + } +} diff --git a/golem-test-framework/src/components/mod.rs b/golem-test-framework/src/components/mod.rs index bdf0b18809..3cf73f7574 100644 --- a/golem-test-framework/src/components/mod.rs +++ b/golem-test-framework/src/components/mod.rs @@ -31,6 +31,8 @@ pub mod blob_storage; pub mod component_compilation_service; mod docker; mod dynamic_span; +pub mod jaeger; +pub mod otel_collector; pub mod rdb; pub mod redis; pub mod redis_monitor; diff --git a/golem-test-framework/src/components/otel_collector/docker.rs b/golem-test-framework/src/components/otel_collector/docker.rs new file mode 100644 index 0000000000..a842d0ae63 --- /dev/null +++ b/golem-test-framework/src/components/otel_collector/docker.rs @@ -0,0 +1,158 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::components::docker::ContainerHandle; +use crate::components::otel_collector::{wait_for_collector_startup, OtelCollector}; +use async_trait::async_trait; +use std::fmt::{Debug, Formatter}; +use std::path::{Path, PathBuf}; +use std::time::Duration; +use testcontainers::core::{IntoContainerPort, Mount, WaitFor}; +use testcontainers::runners::AsyncRunner; +use testcontainers::{ContainerAsync, GenericImage, ImageExt}; +use tracing::info; + +pub struct DockerOtelCollector { + container: ContainerHandle, + otlp_http_port: u16, + output_dir: PathBuf, +} + +impl DockerOtelCollector { + const OTLP_HTTP_PORT: u16 = 4318; + const HEALTH_PORT: u16 = 13133; + + const COLLECTOR_CONFIG: &'static str = r#"receivers: + otlp: + protocols: + http: + endpoint: "0.0.0.0:4318" + +exporters: + file/traces: + path: /otel-output/otlp-traces.jsonl + flush_interval: 1s + file/logs: + path: /otel-output/otlp-logs.jsonl + flush_interval: 1s + file/metrics: + path: /otel-output/otlp-metrics.jsonl + flush_interval: 1s + +extensions: + health_check: + endpoint: "0.0.0.0:13133" + +service: + extensions: [health_check] + pipelines: + traces: + receivers: [otlp] + exporters: [file/traces] + logs: + receivers: [otlp] + exporters: [file/logs] + metrics: + receivers: [otlp] + exporters: [file/metrics] +"#; + + pub async fn new() -> Self { + info!("Starting OTel Collector container"); + + let output_dir = tempfile::Builder::new() + .prefix("otel-output-") + .tempdir_in("/tmp") + .expect("Failed to create temp dir for OTel output") + .keep(); + + for filename in ["otlp-traces.jsonl", "otlp-logs.jsonl", "otlp-metrics.jsonl"] { + std::fs::File::create(output_dir.join(filename)) + .unwrap_or_else(|e| panic!("Failed to create {filename}: {e}")); + } + + let config_dir = tempfile::Builder::new() + .prefix("otel-config-") + .tempdir_in("/tmp") + .expect("Failed to create temp dir for collector config") + .keep(); + let config_path = config_dir.join("config.yaml"); + std::fs::write(&config_path, Self::COLLECTOR_CONFIG) + .expect("Failed to write collector config"); + + let container: ContainerAsync = tryhard::retry_fn(|| { + GenericImage::new("otel/opentelemetry-collector-contrib", "0.120.0") + .with_wait_for(WaitFor::message_on_stderr("Everything is ready.")) + .with_exposed_port(Self::OTLP_HTTP_PORT.tcp()) + .with_exposed_port(Self::HEALTH_PORT.tcp()) + .with_mount(Mount::bind_mount( + output_dir.to_str().unwrap(), + "/otel-output", + )) + .with_mount(Mount::bind_mount( + config_dir.to_str().unwrap(), + "/etc/otelcol", + )) + .with_cmd(["--config", "/etc/otelcol/config.yaml"]) + .with_user("0") + .with_startup_timeout(Duration::from_secs(120)) + .start() + }) + .retries(5) + .exponential_backoff(Duration::from_millis(10)) + .max_delay(Duration::from_secs(10)) + .await + .expect("Failed to start OTel Collector container"); + + let otlp_http_port = container + .get_host_port_ipv4(Self::OTLP_HTTP_PORT) + .await + .expect("Failed to get OTLP HTTP host port"); + + let health_port = container + .get_host_port_ipv4(Self::HEALTH_PORT) + .await + .expect("Failed to get health check host port"); + + let health_url = format!("http://localhost:{health_port}"); + wait_for_collector_startup(&health_url, Duration::from_secs(30)).await; + + Self { + container: ContainerHandle::new(container), + otlp_http_port, + output_dir, + } + } +} + +#[async_trait] +impl OtelCollector for DockerOtelCollector { + fn otlp_http_endpoint(&self) -> String { + format!("http://localhost:{}", self.otlp_http_port) + } + + fn output_dir(&self) -> &Path { + &self.output_dir + } + + async fn kill(&self) { + self.container.kill().await + } +} + +impl Debug for DockerOtelCollector { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "DockerOtelCollector") + } +} diff --git a/golem-test-framework/src/components/otel_collector/mod.rs b/golem-test-framework/src/components/otel_collector/mod.rs new file mode 100644 index 0000000000..49049ce9dc --- /dev/null +++ b/golem-test-framework/src/components/otel_collector/mod.rs @@ -0,0 +1,262 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use async_trait::async_trait; +use serde::Deserialize; +use std::path::Path; +use std::time::Duration; +use tokio::time::Instant; +use tracing::{debug, info}; + +mod docker; + +pub use docker::DockerOtelCollector; + +#[async_trait] +pub trait OtelCollector: Send + Sync { + fn otlp_http_endpoint(&self) -> String; + fn output_dir(&self) -> &Path; + async fn kill(&self); +} + +/// Reads and parses the OTLP JSON lines file for logs. +/// Each line is an `ExportLogsServiceRequest` JSON object. +pub async fn read_otlp_logs(output_dir: &Path) -> anyhow::Result> { + let path = output_dir.join("otlp-logs.jsonl"); + read_otlp_log_records(&path).await +} + +/// Reads and parses the OTLP JSON lines file for metrics. +pub async fn read_otlp_metrics(output_dir: &Path) -> anyhow::Result> { + let path = output_dir.join("otlp-metrics.jsonl"); + read_otlp_metric_records(&path).await +} + +// --- Deserialization types for OTLP JSON file exporter output --- + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FileExportLogsRequest { + pub resource_logs: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResourceLogs { + pub scope_logs: Vec, + #[serde(default)] + pub resource: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ScopeLogs { + pub log_records: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OtlpLogRecord { + #[serde(default)] + pub time_unix_nano: Option, + #[serde(default)] + pub severity_number: Option, + #[serde(default)] + pub severity_text: Option, + #[serde(default)] + pub body: Option, + #[serde(default)] + pub attributes: Vec, + #[serde(default)] + pub trace_id: Option, + #[serde(default)] + pub span_id: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FileExportMetricsRequest { + pub resource_metrics: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResourceMetrics { + pub scope_metrics: Vec, + #[serde(default)] + pub resource: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ScopeMetrics { + pub metrics: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OtlpMetricRecord { + pub name: String, + #[serde(default)] + pub unit: Option, + #[serde(default)] + pub description: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OtlpResource { + #[serde(default)] + pub attributes: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OtlpKeyValue { + pub key: String, + #[serde(default)] + pub value: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct OtlpAnyValue { + #[serde(default)] + pub string_value: Option, + #[serde(default)] + pub int_value: Option, + #[serde(default)] + pub bool_value: Option, +} + +async fn read_otlp_log_records(path: &Path) -> anyhow::Result> { + let content = tokio::fs::read_to_string(path).await?; + let mut records = Vec::new(); + for line in content.lines() { + if line.trim().is_empty() { + continue; + } + let request: FileExportLogsRequest = serde_json::from_str(line) + .map_err(|e| anyhow::anyhow!("Failed to parse OTLP logs line: {e}\nLine: {line}"))?; + for rl in request.resource_logs { + for sl in rl.scope_logs { + records.extend(sl.log_records); + } + } + } + Ok(records) +} + +async fn read_otlp_metric_records(path: &Path) -> anyhow::Result> { + let content = tokio::fs::read_to_string(path).await?; + let mut records = Vec::new(); + for line in content.lines() { + if line.trim().is_empty() { + continue; + } + let request: FileExportMetricsRequest = serde_json::from_str(line) + .map_err(|e| anyhow::anyhow!("Failed to parse OTLP metrics line: {e}\nLine: {line}"))?; + for rm in request.resource_metrics { + for sm in rm.scope_metrics { + records.extend(sm.metrics); + } + } + } + Ok(records) +} + +pub async fn wait_for_otlp_logs( + output_dir: &Path, + min_records: usize, + timeout: Duration, +) -> anyhow::Result> { + let start = Instant::now(); + loop { + match read_otlp_logs(output_dir).await { + Ok(records) if records.len() >= min_records => return Ok(records), + Ok(records) => { + debug!( + "OTLP logs file has {} records, waiting for at least {min_records}", + records.len() + ); + } + Err(e) => { + debug!("Error reading OTLP logs: {e}"); + } + } + if start.elapsed() > timeout { + anyhow::bail!( + "Timed out waiting for {min_records} OTLP log records after {}s", + timeout.as_secs() + ); + } + tokio::time::sleep(Duration::from_secs(2)).await; + } +} + +pub async fn wait_for_otlp_metrics( + output_dir: &Path, + min_records: usize, + timeout: Duration, +) -> anyhow::Result> { + let start = Instant::now(); + loop { + match read_otlp_metrics(output_dir).await { + Ok(records) if records.len() >= min_records => return Ok(records), + Ok(records) => { + debug!( + "OTLP metrics file has {} records, waiting for at least {min_records}", + records.len() + ); + } + Err(e) => { + debug!("Error reading OTLP metrics: {e}"); + } + } + if start.elapsed() > timeout { + anyhow::bail!( + "Timed out waiting for {min_records} OTLP metric records after {}s", + timeout.as_secs() + ); + } + tokio::time::sleep(Duration::from_secs(2)).await; + } +} + +async fn wait_for_collector_startup(health_url: &str, timeout: Duration) { + info!( + "Waiting for OTel Collector start at {health_url}, timeout: {}s", + timeout.as_secs() + ); + let client = reqwest::Client::new(); + let start = Instant::now(); + loop { + match client.get(health_url).send().await { + Ok(resp) if resp.status().is_success() => { + info!("OTel Collector is ready"); + return; + } + Ok(resp) => { + debug!("OTel Collector not ready yet, status: {}", resp.status()); + } + Err(e) => { + debug!("OTel Collector not ready yet: {e}"); + } + } + if start.elapsed() > timeout { + panic!("Failed to verify that OTel Collector is running at {health_url}"); + } + tokio::time::sleep(Duration::from_secs(1)).await; + } +} diff --git a/golem-test-framework/src/components/registry_service/mod.rs b/golem-test-framework/src/components/registry_service/mod.rs index 3d8977b818..4571fde244 100644 --- a/golem-test-framework/src/components/registry_service/mod.rs +++ b/golem-test-framework/src/components/registry_service/mod.rs @@ -25,6 +25,7 @@ use golem_common::model::account::{AccountEmail, AccountId}; use golem_common::model::auth::TokenSecret; use golem_common::model::plan::PlanId; use std::collections::HashMap; +use std::path::Path; use std::process::Child; use std::sync::Arc; use std::time::Duration; @@ -87,6 +88,7 @@ async fn env_vars( default_plan_id: &PlanId, low_fuel_plan_id: &PlanId, otlp: bool, + otlp_wasm_path: Option<&Path>, ) -> HashMap { let builder = EnvVarBuilder::golem_service(verbosity) .with_str("GOLEM__BLOB_STORAGE__TYPE", "LocalFileSystem") @@ -111,12 +113,13 @@ async fn env_vars( _ => builder.with_str("GOLEM__COMPONENT_COMPILATION__TYPE", "Disabled"), }; - builder + let builder = builder // users .with( "GOLEM__INITIAL_ACCOUNTS__ROOT__ID", admin_account_id.to_string(), ) + .with_str("GOLEM__INITIAL_ACCOUNTS__ROOT__NAME", "Root") .with( "GOLEM__INITIAL_ACCOUNTS__ROOT__EMAIL", admin_account_email.to_string(), @@ -129,6 +132,31 @@ async fn env_vars( "GOLEM__INITIAL_ACCOUNTS__ROOT__TOKEN", admin_token.secret().to_string(), ) + .with_str("GOLEM__INITIAL_ACCOUNTS__ROOT__ROLE", "admin") + .with_str( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__ID", + "adb2694f-cd9f-425d-905d-ca2888c9c5de", + ) + .with_str( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__NAME", + "Builtin Plugin Owner", + ) + .with_str( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__EMAIL", + "builtin-plugin-owner@golem.cloud", + ) + .with( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__PLAN_ID", + default_plan_id.to_string(), + ) + .with_str( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__TOKEN", + golem_client::LOCAL_WELL_KNOWN_BUILTIN_PLUGIN_OWNER_TOKEN, + ) + .with_str( + "GOLEM__INITIAL_ACCOUNTS__BUILTIN_PLUGIN_OWNER__ROLE", + "builtin-plugin-owner", + ) // plans .with( "GOLEM__INITIAL_PLANS__DEFAULT__PLAN_ID", @@ -230,6 +258,18 @@ async fn env_vars( .with("GOLEM__GRPC__PORT", grpc_port.to_string()) .with("GOLEM__HTTP_PORT", http_port.to_string()) .with_all(rdb.info().env("golem_registry", rdb_private_connection)) - .with_optional_otlp("registry_service", otlp) - .build() + .with_optional_otlp("registry_service", otlp); + + let builder = if let Some(wasm_path) = otlp_wasm_path { + builder + .with_str("GOLEM__BUILTIN_PLUGINS__ENABLED", "true") + .with( + "GOLEM__BUILTIN_PLUGINS__OTLP_EXPORTER_WASM_PATH", + wasm_path.to_string_lossy().to_string(), + ) + } else { + builder + }; + + builder.build() } diff --git a/golem-test-framework/src/components/registry_service/spawned.rs b/golem-test-framework/src/components/registry_service/spawned.rs index b963b46f0e..dcceea09bd 100644 --- a/golem-test-framework/src/components/registry_service/spawned.rs +++ b/golem-test-framework/src/components/registry_service/spawned.rs @@ -70,6 +70,13 @@ impl SpawnedRegistryService { let default_plan_id = PlanId(uuid!("8e3e354a-e45e-4e30-bae4-27c30c74d9ee")); let low_fuel_plan_id = PlanId(uuid!("301fd75c-dcc5-48e3-967e-e7c33df52493")); + let otlp_wasm = working_directory.join("../plugins/otlp-exporter.wasm"); + let otlp_wasm_path = if otlp_wasm.exists() { + Some(otlp_wasm.as_path()) + } else { + None + }; + let mut child = Command::new(executable) .current_dir(working_directory) .envs( @@ -87,6 +94,7 @@ impl SpawnedRegistryService { &default_plan_id, &low_fuel_plan_id, otlp, + otlp_wasm_path, ) .await, ) diff --git a/golem-test-framework/src/dsl/mod.rs b/golem-test-framework/src/dsl/mod.rs index 3530751879..9da96885a2 100644 --- a/golem-test-framework/src/dsl/mod.rs +++ b/golem-test-framework/src/dsl/mod.rs @@ -909,6 +909,7 @@ pub fn log_event_to_string(event: &LogEvent) -> String { Some(log_event::Event::InvocationFinished(_)) => "".to_string(), Some(log_event::Event::InvocationStarted(_)) => "".to_string(), Some(log_event::Event::ClientLagged { .. }) => "".to_string(), + Some(log_event::Event::PluginError(err)) => err.message.clone(), None => std::panic!("Unexpected event type"), } } diff --git a/golem-worker-executor/src/model/event.rs b/golem-worker-executor/src/model/event.rs index e6d727e77b..ad108ff380 100644 --- a/golem-worker-executor/src/model/event.rs +++ b/golem-worker-executor/src/model/event.rs @@ -28,6 +28,11 @@ pub enum InternalWorkerEvent { function: String, idempotency_key: IdempotencyKey, }, + PluginError { + timestamp: Timestamp, + plugin_name: String, + message: String, + }, } impl InternalWorkerEvent { @@ -70,6 +75,14 @@ impl InternalWorkerEvent { } } + pub fn plugin_error(plugin_name: &str, message: &str) -> Self { + Self::PluginError { + timestamp: Timestamp::now_utc(), + plugin_name: plugin_name.to_string(), + message: message.to_string(), + } + } + pub fn as_oplog_entry(&self) -> Option { match self { Self::StdOut { timestamp, bytes } => Some(OplogEntry::Log { @@ -104,6 +117,7 @@ impl InternalWorkerEvent { }), Self::InvocationStart { .. } => None, Self::InvocationFinished { .. } => None, + Self::PluginError { .. } => None, } } } @@ -142,6 +156,15 @@ impl From for AgentEvent { function, idempotency_key, }, + InternalWorkerEvent::PluginError { + timestamp, + plugin_name, + message, + } => Self::PluginError { + timestamp, + plugin_name, + message, + }, } } } diff --git a/golem-worker-executor/src/model/public_oplog/mod.rs b/golem-worker-executor/src/model/public_oplog/mod.rs index a3c38b30d2..23c00ed359 100644 --- a/golem-worker-executor/src/model/public_oplog/mod.rs +++ b/golem-worker-executor/src/model/public_oplog/mod.rs @@ -42,10 +42,11 @@ use golem_common::model::oplog::{ AgentMethodInvocationParameters, FallibleResultParameters, HostRequest, HostRequestGolemRpcInvoke, HostRequestGolemRpcScheduledInvocation, HostResponse, JsonSnapshotData, LoadSnapshotParameters, ManualUpdateParameters, OplogEntry, OplogIndex, - PluginInstallationDescription, ProcessOplogEntriesParameters, PublicAgentInvocation, - PublicAgentInvocationResult, PublicAttribute, PublicOplogEntry, PublicSnapshotData, - PublicUpdateDescription, RawSnapshotData, SaveSnapshotResultParameters, - SnapshotBasedUpdateParameters, UpdateDescription, + PluginInstallationDescription, ProcessOplogEntriesParameters, + ProcessOplogEntriesResultParameters, PublicAgentInvocation, PublicAgentInvocationResult, + PublicAttribute, PublicOplogEntry, PublicSnapshotData, PublicUpdateDescription, + RawSnapshotData, SaveSnapshotResultParameters, SnapshotBasedUpdateParameters, + UpdateDescription, }; use golem_common::model::{ AgentId, AgentInvocation, AgentInvocationPayload, AgentInvocationResult, Empty, OwnedAgentId, @@ -987,9 +988,11 @@ async fn agent_invocation_result_to_public( snapshot: raw_snapshot_to_public(snapshot), }), ), - AgentInvocationResult::ProcessOplogEntries { error } => Ok( - PublicAgentInvocationResult::ProcessOplogEntries(FallibleResultParameters { error }), - ), + AgentInvocationResult::ProcessOplogEntries { error } => { + Ok(PublicAgentInvocationResult::ProcessOplogEntries( + ProcessOplogEntriesResultParameters { error }, + )) + } } } diff --git a/golem-worker-executor/src/model/public_oplog/wit.rs b/golem-worker-executor/src/model/public_oplog/wit.rs index 74383e2103..bda7b2c79f 100644 --- a/golem-worker-executor/src/model/public_oplog/wit.rs +++ b/golem-worker-executor/src/model/public_oplog/wit.rs @@ -547,9 +547,11 @@ impl From for oplog::AgentInvocationResult { }, }) } - PublicAgentInvocationResult::ProcessOplogEntries(FallibleResultParameters { - error, - }) => Self::ProcessOplogEntries(oplog::FallibleResultParameters { error }), + PublicAgentInvocationResult::ProcessOplogEntries(result) => { + Self::ProcessOplogEntries(oplog::FallibleResultParameters { + error: result.error, + }) + } } } } diff --git a/golem-worker-executor/src/services/oplog/plugin.rs b/golem-worker-executor/src/services/oplog/plugin.rs index 4b4e12d258..bd8c5eaa12 100644 --- a/golem-worker-executor/src/services/oplog/plugin.rs +++ b/golem-worker-executor/src/services/oplog/plugin.rs @@ -12,11 +12,13 @@ // See the License for the specific language governing permissions and // limitations under the License. +use crate::model::event::InternalWorkerEvent; use crate::model::ExecutionStatus; use crate::services::component::ComponentService; use crate::services::oplog::{CommitLevel, OpenOplogs, Oplog, OplogConstructor, OplogService}; use crate::services::shard::ShardService; use crate::services::worker_activator::WorkerActivator; +use crate::services::worker_event::WorkerEventService; use crate::services::worker_proxy::WorkerProxy; use crate::services::{ HasComponentService, HasOplogProcessorPlugin, HasShardService, HasWorkerActivator, @@ -74,7 +76,8 @@ pub trait OplogProcessorPlugin: Send + Sync { plugin: &InstalledPlugin, ) -> Result; - /// Sends oplog entries to the specified target plugin worker. + /// Enqueues oplog entries to the specified target plugin worker. + /// Any `Ok(())` means durable delivery — the batch has been accepted. async fn send( &self, worker_metadata: AgentMetadata, @@ -84,6 +87,10 @@ pub trait OplogProcessorPlugin: Send + Sync { entries: Vec, ) -> Result<(), WorkerExecutorError>; + /// Evicts the cached plugin worker for the given plugin, forcing a fresh + /// instance to be created on the next `resolve_target` call. + async fn invalidate_target(&self, environment_id: EnvironmentId, plugin: &InstalledPlugin); + async fn on_shard_assignment_changed(&self) -> Result<(), WorkerExecutorError>; async fn is_local(&self, agent_id: &AgentId) -> Result; @@ -281,7 +288,8 @@ impl OplogProcessorPlugin for PerExecutorOplogProcessorPlugin OplogProcessorPlugin for PerExecutorOplogProcessorPlugin Result { let assignment = self.shard_service.current_assignment()?; let shard_id = ShardId::from_agent_id(agent_id, assignment.number_of_shards); @@ -694,6 +707,9 @@ impl ForwardingOplog { components, inner: inner.clone(), plugin_state, + pending_direct_commits: BTreeMap::new(), + worker_event_service: None, + monitor_tasks: Vec::new(), })); let timer = tokio::spawn({ @@ -716,6 +732,14 @@ impl ForwardingOplog { close_fn: Some(close_fn), } } + + pub async fn set_worker_event_service( + &self, + worker_event_service: Arc, + ) { + let mut state = self.state.lock().await; + state.worker_event_service = Some(worker_event_service); + } } impl Debug for ForwardingOplog { @@ -732,6 +756,13 @@ impl Drop for ForwardingOplog { if let Some(timer) = self.timer.take() { timer.abort(); } + // Abort all background monitor tasks to prevent them from + // outliving this oplog and causing resource contention. + if let Some(mut state) = self.state.try_lock() { + for task in state.monitor_tasks.drain(..) { + task.abort(); + } + } } } @@ -750,7 +781,7 @@ impl Oplog for ForwardingOplog { async fn commit(&self, level: CommitLevel) -> BTreeMap { let mut state = self.state.lock().await; - let result = self.inner.commit(level).await; + let mut result = self.inner.commit(level).await; // Update last_committed_idx from committed entries if let Some(max_idx) = result.keys().max() { if *max_idx > state.last_committed_idx { @@ -761,6 +792,9 @@ impl Oplog for ForwardingOplog { if state.commit_count >= self.max_commit_count { state.try_flush().await; } + // Merge entries committed directly to inner during flush + // so the Worker folds them into AgentStatusRecord + result.append(&mut state.pending_direct_commits); result } @@ -823,6 +857,12 @@ struct ForwardingOplogState { components: Arc, inner: Arc, plugin_state: HashMap, + /// Entries committed directly to inner (bypassing `ForwardingOplog::commit()`), + /// to be surfaced in the next `ForwardingOplog::commit()` return value + /// so the Worker folds them into `AgentStatusRecord`. + pending_direct_commits: BTreeMap, + worker_event_service: Option>, + monitor_tasks: Vec>, } impl ForwardingOplogState { @@ -927,6 +967,10 @@ impl ForwardingOplogState { } /// Flush a single plugin: resolve target, read entries, write checkpoints, send. + /// + /// Uses enqueue-and-confirm: after a successful `send()` (which only enqueues + /// the invocation), we immediately write the confirmation checkpoint. A background + /// monitoring task is spawned to observe errors and emit plugin_error events. async fn flush_one_plugin( &mut self, grant_id: EnvironmentPluginGrantId, @@ -1011,13 +1055,14 @@ impl ForwardingOplogState { } // If ALL entries are checkpoint entries, skip — nothing meaningful to deliver. - // Don't advance cursors: when a real entry arrives later, it will be included - // in the batch alongside these checkpoints and sent together. + // Advance the cursor past them so we don't re-read the same range forever. if entries .iter() .all(|e| matches!(e, OplogEntry::OplogProcessorCheckpoint { .. })) { if let Some(s) = self.plugin_state.get_mut(&grant_id) { + s.confirmed_up_to = batch_end; + s.sending_up_to = batch_end; s.send_in_progress = false; } return; @@ -1049,6 +1094,7 @@ impl ForwardingOplogState { .await { Ok(()) => { + // Enqueue succeeded — immediately confirm self.write_checkpoint( grant_id, &target_agent_id, @@ -1063,11 +1109,99 @@ impl ForwardingOplogState { s.send_in_progress = false; s.last_batch_start = batch_start; } + + // Spawn background monitoring task to observe errors. + // Compute the idempotency key here so only lightweight data + // needs to be moved into the task. + let idempotency_key = oplog_processor_idempotency_key( + &metadata.agent_id, + &plugin.environment_plugin_grant_id, + batch_start, + batch_end, + ); + let worker_event_service = self.worker_event_service.clone(); + let oplog_plugins = self.oplog_plugins.clone(); + let environment_id = metadata.environment_id; + let plugin_clone = plugin.clone(); + let target_clone = target_agent_id.clone(); + let monitor = tokio::spawn( + async move { + // Poll until the invocation completes, with a timeout + let deadline = Instant::now() + Duration::from_secs(300); + loop { + if Instant::now() >= deadline { + tracing::warn!( + "Plugin {grant_id}: monitoring timed out for batch [{batch_start}..{batch_end}]" + ); + break; + } + + tokio::time::sleep(Duration::from_secs(1)).await; + + match oplog_plugins + .lookup_invocation_status( + environment_id, + &plugin_clone, + &target_clone, + &idempotency_key, + ) + .await + { + Ok(InvocationStatus::Complete) => { + // Completed — nothing to do + break; + } + Ok(InvocationStatus::Unknown) => { + tracing::warn!( + "Plugin {grant_id}: invocation status unknown for batch [{batch_start}..{batch_end}]" + ); + break; + } + Ok(_) => { + // Still pending — continue polling + } + Err(err) => { + tracing::error!( + "Plugin {grant_id} error monitoring batch [{batch_start}..{batch_end}]: {err}" + ); + if let Some(event_service) = &worker_event_service { + event_service.emit_event( + InternalWorkerEvent::plugin_error( + &format!("{grant_id}"), + &format!("Error monitoring batch [{batch_start}..{batch_end}]: {err}"), + ), + true, + ); + } + break; + } + } + } + } + .in_current_span(), + ); + self.monitor_tasks.push(monitor); } Err(err) => { - tracing::error!("Failed to send oplog entries to plugin {grant_id}: {err}"); + // Pre-enqueue failure — permanent for this target instance + tracing::error!("Failed to enqueue oplog entries to plugin {grant_id}: {err}"); + if let Some(event_service) = &self.worker_event_service { + event_service.emit_event( + InternalWorkerEvent::plugin_error( + &format!("{grant_id}"), + &format!("Failed to enqueue batch [{batch_start}..{batch_end}]: {err}"), + ), + true, + ); + } + // Invalidate target — next flush will create a fresh instance + self.oplog_plugins + .invalidate_target(metadata.environment_id, &plugin) + .await; if let Some(s) = self.plugin_state.get_mut(&grant_id) { + s.target_agent_id = None; s.send_in_progress = false; + // Leave cursors unchanged — same batch retried on new target } } } @@ -1121,14 +1255,15 @@ impl ForwardingOplogState { last_batch_start, }; self.buffer.push_back(checkpoint.clone()); - self.inner.add(checkpoint).await; + let idx = self.inner.add(checkpoint).await; + self.last_oplog_idx = idx; let committed = self.inner.commit(CommitLevel::Always).await; - self.last_oplog_idx = self.last_oplog_idx.next(); - if let Some(max_idx) = committed.keys().max() { - if *max_idx > self.last_committed_idx { - self.last_committed_idx = *max_idx; - } + if let Some(max_idx) = committed.keys().max().copied() { + self.last_committed_idx = self.last_committed_idx.max(max_idx); } + // Track all directly committed entries so ForwardingOplog::commit() + // can surface them to the Worker for status folding + self.pending_direct_commits.extend(committed); } /// Prune buffer: drain entries that ALL active/in-flight plugins have confirmed past. @@ -1163,6 +1298,8 @@ impl ForwardingOplogState { fn finish_flush_cycle(&mut self) { self.last_send = Instant::now(); self.commit_count = 0; + // Prune completed monitor tasks + self.monitor_tasks.retain(|h| !h.is_finished()); } /// Periodic locality recovery: for each plugin whose target worker is on a @@ -1528,6 +1665,14 @@ mod tests { Ok(()) } + async fn invalidate_target( + &self, + _environment_id: EnvironmentId, + _plugin: &InstalledPlugin, + ) { + // no-op in tests + } + async fn is_local(&self, _agent_id: &AgentId) -> Result { Ok(true) } @@ -1793,6 +1938,9 @@ mod tests { last_batch_start: OplogIndex::NONE, }, )]), + pending_direct_commits: BTreeMap::new(), + worker_event_service: None, + monitor_tasks: Vec::new(), }; // No committed entries (last_committed_idx = NONE) — try_flush should be a no-op @@ -1832,6 +1980,9 @@ mod tests { components, inner, plugin_state: HashMap::new(), + pending_direct_commits: BTreeMap::new(), + worker_event_service: None, + monitor_tasks: Vec::new(), }; state.try_flush().await; @@ -1891,6 +2042,9 @@ mod tests { last_batch_start: OplogIndex::NONE, }, )]), + pending_direct_commits: BTreeMap::new(), + worker_event_service: None, + monitor_tasks: Vec::new(), }; state.try_flush().await; diff --git a/golem-worker-executor/src/services/worker_event.rs b/golem-worker-executor/src/services/worker_event.rs index 24a806784a..f1cf43c470 100644 --- a/golem-worker-executor/src/services/worker_event.rs +++ b/golem-worker-executor/src/services/worker_event.rs @@ -210,6 +210,7 @@ fn label(event: &InternalWorkerEvent) -> &'static str { InternalWorkerEvent::Log { .. } => "log", InternalWorkerEvent::InvocationStart { .. } => "invocation_start", InternalWorkerEvent::InvocationFinished { .. } => "invocation_finished", + InternalWorkerEvent::PluginError { .. } => "plugin_error", } } diff --git a/golem-worker-executor/src/worker/invocation.rs b/golem-worker-executor/src/worker/invocation.rs index fa8fc51eb7..6e93e3ffaa 100644 --- a/golem-worker-executor/src/worker/invocation.rs +++ b/golem-worker-executor/src/worker/invocation.rs @@ -814,7 +814,7 @@ fn wrap_output_as_agent_result( }) } AgentInvocationKind::ProcessOplogEntries => { - let error = decode_result_error(output, "process-oplog-entries")?; + let error = decode_result_error(output, "process")?; Ok(InvokeResult::Succeeded { consumed_fuel, result: AgentInvocationResult::ProcessOplogEntries { error }, diff --git a/golem-worker-executor/src/worker/mod.rs b/golem-worker-executor/src/worker/mod.rs index d917fec5cc..8b490fea58 100644 --- a/golem-worker-executor/src/worker/mod.rs +++ b/golem-worker-executor/src/worker/mod.rs @@ -27,7 +27,8 @@ use crate::durable_host::recover_stderr_logs; use crate::model::{AgentConfig, ExecutionStatus, LookupResult, ReadFileResult, TrapType}; use crate::services::events::{Event, EventsSubscription}; use crate::services::golem_config::SnapshotPolicy; -use crate::services::oplog::{CommitLevel, Oplog, OplogOps}; +use crate::services::oplog::plugin::ForwardingOplog; +use crate::services::oplog::{downcast_oplog, CommitLevel, Oplog, OplogOps}; use crate::services::worker::GetWorkerMetadataResult; use crate::services::worker_event::{WorkerEventService, WorkerEventServiceDefault}; use crate::services::{ @@ -320,6 +321,14 @@ impl Worker { snapshot_recovery_disabled: AtomicBool::new(false), }; + // Wire the worker event service into the forwarding oplog so plugin errors + // can be emitted as live events without writing to the oplog. + if let Some(forwarding_oplog) = downcast_oplog::(&worker.oplog) { + forwarding_oplog + .set_worker_event_service(worker.worker_event_service.clone()) + .await; + } + // just some sanity checking assert!(last_oplog_idx >= OplogIndex::INITIAL); @@ -339,8 +348,6 @@ impl Worker { .await .expect("Failed enqueuing initial agent invocations to worker"); } - } else { - warn!("Unexpected non-agentic worker"); // TODO: change this once oplog-processors are finalized }; Ok(worker) } @@ -1299,12 +1306,13 @@ impl Worker { } } } else { - let is_pending = self - .pending_invocations() - .await + let status = self.last_known_status.read().await; + let is_pending = status + .pending_invocations .iter() .any(|entry| entry.invocation.has_idempotency_key(key)); - if is_pending { + let is_current = status.current_idempotency_key.as_ref() == Some(key); + if is_pending || is_current { LookupResult::Pending } else { LookupResult::New @@ -1354,6 +1362,9 @@ impl Worker { match previous_instance_state { WorkerInstance::Unloaded { .. } | WorkerInstance::WaitingForPermit(_) => { + if let Some(ref error) = fail_pending_invocations { + self.fail_pending_invocations(error.clone()).await; + } **instance_guard = final_state.into_instance(); StopResult::Stopped } @@ -1370,6 +1381,9 @@ impl Worker { // If we're stopping for deletion, upgrade the final state if matches!(final_state, FinalWorkerState::Deleting) { stopping.final_state = FinalWorkerState::Deleting; + if let Some(ref error) = fail_pending_invocations { + self.fail_pending_invocations(error.clone()).await; + } } let notify = stopping.notify.clone(); **instance_guard = WorkerInstance::Stopping(stopping); @@ -1423,6 +1437,25 @@ impl Worker { run_loop_handle.await.expect("Failed to join run loop"); let mut instance_guard = self.instance.lock().await; + let is_deleting = match &*instance_guard { + WorkerInstance::Stopping(stopping) => { + matches!(stopping.final_state, FinalWorkerState::Deleting) + } + _ => false, + }; + + // After the invocation loop has fully exited, fail any remaining + // unresolved invocations (e.g. the currently running one that was + // in progress when deletion was requested). + if is_deleting { + drop(instance_guard); + self.fail_pending_invocations(WorkerExecutorError::invalid_request( + "Worker is being deleted", + )) + .await; + instance_guard = self.instance.lock().await; + } + match std::mem::replace( &mut *instance_guard, WorkerInstance::Unloaded { @@ -1461,19 +1494,46 @@ impl Worker { } } - // Also handle pending invocations from last_known_status + // Collect all idempotency keys to fail: pending invocations + currently running invocation let status = self.last_known_status.read().await.clone(); - for invocation in &status.pending_invocations { - if let Some(idempotency_key) = invocation.invocation.idempotency_key() { - self.events().publish(Event::InvocationCompleted { - agent_id: self.owned_agent_id.agent_id(), - idempotency_key: idempotency_key.clone(), - result: Err(error.clone()), - }); - // Clean up the span entry - spans_map.remove(idempotency_key); + let mut keys_to_fail: Vec = status + .pending_invocations + .iter() + .filter_map(|inv| inv.invocation.idempotency_key().cloned()) + .collect(); + if let Some(current_key) = &status.current_idempotency_key { + if !keys_to_fail.contains(current_key) { + keys_to_fail.push(current_key.clone()); } } + + let mut invocation_results = self.invocation_results.write().await; + for idempotency_key in &keys_to_fail { + if invocation_results.contains_key(idempotency_key) { + continue; + } + invocation_results.insert( + idempotency_key.clone(), + InvocationResult::Cached { + result: Err(FailedInvocationResult { + trap_type: TrapType::Error { + error: golem_common::model::oplog::AgentError::Unknown( + error.to_string(), + ), + retry_from: OplogIndex::INITIAL, + }, + stderr: String::new(), + }), + }, + ); + self.events().publish(Event::InvocationCompleted { + agent_id: self.owned_agent_id.agent_id(), + idempotency_key: idempotency_key.clone(), + result: Err(error.clone()), + }); + // Clean up the span entry + spans_map.remove(idempotency_key); + } } // Lock a worker not in stopping state. diff --git a/integration-tests/tests/lib.rs b/integration-tests/tests/lib.rs index b76148bfa3..4ee4ace3d7 100644 --- a/integration-tests/tests/lib.rs +++ b/integration-tests/tests/lib.rs @@ -16,6 +16,7 @@ mod agent_config; mod api; mod custom_api; mod fork; +mod otlp_plugin; mod plugins; mod worker; @@ -34,6 +35,12 @@ tag_suite!(agent_config, group2); tag_suite!(api, group2); tag_suite!(custom_api, group2); +tag_suite!(otlp_plugin, group7); +tag_suite!(plugins, group7); + +test_r::sequential_suite!(otlp_plugin); +test_r::sequential_suite!(plugins); + #[derive(Debug)] pub struct Tracing; diff --git a/integration-tests/tests/otlp_plugin.rs b/integration-tests/tests/otlp_plugin.rs new file mode 100644 index 0000000000..6d89434975 --- /dev/null +++ b/integration-tests/tests/otlp_plugin.rs @@ -0,0 +1,290 @@ +// Copyright 2024-2026 Golem Cloud +// +// Licensed under the Golem Source License v1.1 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::Tracing; +use golem_client::api::RegistryServiceClient; +use golem_common::model::agent::AgentTypeName; +use golem_common::model::environment::EnvironmentId; +use golem_common::model::environment_plugin_grant::EnvironmentPluginGrantId; +use golem_common::model::http_api_deployment::{ + HttpApiDeploymentAgentOptions, HttpApiDeploymentCreation, +}; +use golem_common::model::invocation_context::{SpanId, TraceId}; +use golem_test_framework::components::jaeger::{DockerJaeger, Jaeger, JaegerQueryClient}; +use golem_test_framework::components::otel_collector::{ + wait_for_otlp_logs, wait_for_otlp_metrics, DockerOtelCollector, OtelCollector, +}; +use golem_test_framework::config::{EnvBasedTestDependencies, TestDependencies}; +use golem_test_framework::dsl::{TestDsl, TestDslExtended}; +use reqwest::Client; +use std::collections::{BTreeMap, HashSet}; +use std::time::Duration; +use test_r::{inherit_test_dep, test, test_dep, timeout}; +use tracing::info; + +inherit_test_dep!(Tracing); +inherit_test_dep!(EnvBasedTestDependencies); + +#[test_dep] +async fn create_jaeger(_tracing: &Tracing) -> DockerJaeger { + DockerJaeger::new().await +} + +#[test_dep] +async fn create_otel_collector(_tracing: &Tracing) -> DockerOtelCollector { + DockerOtelCollector::new().await +} + +async fn find_otlp_plugin_grant( + client: &impl RegistryServiceClient, + environment_id: &EnvironmentId, +) -> anyhow::Result { + let grants = client + .list_environment_plugin_grants(&environment_id.0) + .await + .map_err(|e| anyhow::anyhow!("Failed to list plugin grants: {e}"))?; + + let grant = grants + .values + .iter() + .find(|g| g.plugin.name == "golem-otlp-exporter") + .ok_or_else(|| { + anyhow::anyhow!( + "golem-otlp-exporter plugin grant not found. Available grants: {:?}", + grants + .values + .iter() + .map(|g| &g.plugin.name) + .collect::>() + ) + })?; + + Ok(grant.id) +} + +#[test] +#[tracing::instrument] +#[timeout("4m")] +async fn otlp_basic_trace_export( + deps: &EnvBasedTestDependencies, + jaeger: &DockerJaeger, +) -> anyhow::Result<()> { + let user = deps.user().await?; + let client = user.registry_service_client().await; + let (_, env) = user.app_and_env().await?; + + let otlp_grant_id = find_otlp_plugin_grant(&client, &env.id).await?; + info!("Found OTLP plugin grant: {otlp_grant_id:?}"); + + let mut plugin_params = BTreeMap::new(); + plugin_params.insert("endpoint".to_string(), jaeger.otlp_http_endpoint()); + + let _component = user + .component(&env.id, "golem_it_agent_invocation_context") + .name("golem-it:agent-invocation-context") + .with_parametrized_plugin(&otlp_grant_id, 0, plugin_params) + .store() + .await?; + + let domain = user.register_domain(&env.id).await?; + + let http_api_deployment_creation = HttpApiDeploymentCreation { + domain: domain.clone(), + agents: BTreeMap::from_iter([( + AgentTypeName("InvocationContextAgent".to_string()), + HttpApiDeploymentAgentOptions::default(), + )]), + webhooks_url: HttpApiDeploymentCreation::default_webhooks_url(), + }; + + client + .create_http_api_deployment(&env.id.0, &http_api_deployment_creation) + .await?; + + user.deploy_environment(env.id).await?; + + let trace_id = TraceId::generate(); + let parent_span_id = SpanId::generate(); + + let http_client = Client::builder().build().unwrap(); + let response = http_client + .post(format!( + "http://localhost:{}/otlp-test/test-path-1", + deps.worker_service().custom_request_port() + )) + .header("host", domain.0.clone()) + .header("traceparent", format!("00-{trace_id}-{parent_span_id}-01")) + .header("tracestate", "test=value") + .send() + .await?; + + let status = response.status(); + let body = response.text().await?; + info!("HTTP response: {status} - {body}"); + + let jaeger_client = JaegerQueryClient::new(&jaeger.query_url()); + + let jaeger_trace_id = format!("{trace_id}"); + info!("Waiting for trace {jaeger_trace_id} in Jaeger"); + + let trace = jaeger_client + .wait_for_trace_with_min_spans(&jaeger_trace_id, 5, Duration::from_secs(90)) + .await?; + + info!("Found trace with {} spans", trace.spans.len()); + + assert!( + !trace.spans.is_empty(), + "Trace should have at least one span" + ); + assert_eq!(trace.trace_id, jaeger_trace_id); + + let parent_span_id_str = format!("{parent_span_id}"); + let external_parents = HashSet::from([parent_span_id_str.as_str()]); + trace.dump_spans(&external_parents); + + let unknown = trace.unknown_name_spans(); + assert!( + unknown.is_empty(), + "Found spans with 'unknown' name: {unknown:?}" + ); + + let disconnected = trace.disconnected_spans(&external_parents); + assert!( + disconnected.is_empty(), + "Found disconnected spans: {disconnected:?}" + ); + + let errors = trace.error_spans(); + assert!( + errors.is_empty(), + "Found spans with ERROR status: {errors:?}" + ); + + Ok(()) +} + +#[test] +#[tracing::instrument] +#[timeout("4m")] +async fn otlp_all_signals_export( + deps: &EnvBasedTestDependencies, + otel_collector: &DockerOtelCollector, +) -> anyhow::Result<()> { + let user = deps.user().await?; + let client = user.registry_service_client().await; + let (_, env) = user.app_and_env().await?; + + let otlp_grant_id = find_otlp_plugin_grant(&client, &env.id).await?; + info!("Found OTLP plugin grant: {otlp_grant_id:?}"); + + let mut plugin_params = BTreeMap::new(); + plugin_params.insert("endpoint".to_string(), otel_collector.otlp_http_endpoint()); + plugin_params.insert("signals".to_string(), "traces,logs,metrics".to_string()); + + let _component = user + .component(&env.id, "golem_it_agent_invocation_context") + .name("golem-it:agent-invocation-context") + .with_parametrized_plugin(&otlp_grant_id, 0, plugin_params) + .store() + .await?; + + let domain = user.register_domain(&env.id).await?; + + let http_api_deployment_creation = HttpApiDeploymentCreation { + domain: domain.clone(), + agents: BTreeMap::from_iter([( + AgentTypeName("InvocationContextAgent".to_string()), + HttpApiDeploymentAgentOptions::default(), + )]), + webhooks_url: HttpApiDeploymentCreation::default_webhooks_url(), + }; + + client + .create_http_api_deployment(&env.id.0, &http_api_deployment_creation) + .await?; + + user.deploy_environment(env.id).await?; + + let trace_id = TraceId::generate(); + let parent_span_id = SpanId::generate(); + + let http_client = Client::builder().build().unwrap(); + let response = http_client + .post(format!( + "http://localhost:{}/otlp-test/test-path-1", + deps.worker_service().custom_request_port() + )) + .header("host", domain.0.clone()) + .header("traceparent", format!("00-{trace_id}-{parent_span_id}-01")) + .header("tracestate", "test=value") + .send() + .await?; + + let status = response.status(); + let body = response.text().await?; + info!("HTTP response: {status} - {body}"); + + let output_dir = otel_collector.output_dir(); + + // Wait for log records — the test component uses println! which produces + // OplogEntry::Log entries, converted to OTLP log records by the plugin. + // We expect at least 2: "Sending context ... through HTTP" and a broadcast result. + info!("Waiting for OTLP log records"); + let logs = wait_for_otlp_logs(output_dir, 2, Duration::from_secs(90)).await?; + info!("Collected {} OTLP log records", logs.len()); + + let has_sending_context = logs.iter().any(|r| { + r.body + .as_ref() + .and_then(|b| b.string_value.as_deref()) + .is_some_and(|s| s.contains("Sending context")) + }); + assert!( + has_sending_context, + "Expected a log record containing 'Sending context', got: {logs:?}" + ); + + let has_stdout_severity = logs + .iter() + .any(|r| r.severity_text.as_deref() == Some("STDOUT")); + assert!( + has_stdout_severity, + "Expected at least one log record with severity_text=STDOUT (from println!), got: {logs:?}" + ); + + // Wait for metric records — the invocation produces many metrics from + // Create, AgentInvocationStarted/Finished, HostCall, GrowMemory, Log entries. + info!("Waiting for OTLP metric records"); + let metrics = wait_for_otlp_metrics(output_dir, 5, Duration::from_secs(90)).await?; + info!("Collected {} OTLP metric records", metrics.len()); + + let metric_names: HashSet<&str> = metrics.iter().map(|m| m.name.as_str()).collect(); + info!("Unique metric names: {metric_names:?}"); + + let expected_metrics = [ + "golem.invocation.count", + "golem.invocation.fuel_consumed", + "golem.host_call.count", + "golem.log.count", + ]; + for expected in &expected_metrics { + assert!( + metric_names.contains(expected), + "Expected metric '{expected}' not found. Got: {metric_names:?}" + ); + } + + Ok(()) +} diff --git a/integration-tests/tests/plugins.rs b/integration-tests/tests/plugins.rs index 9c34212296..3a0f6ec37d 100644 --- a/integration-tests/tests/plugins.rs +++ b/integration-tests/tests/plugins.rs @@ -790,6 +790,7 @@ async fn oplog_processor_crash_stress(deps: &EnvBasedTestDependencies) -> anyhow let fn_names = extract_function_names(&batches); let add_count = fn_names.iter().filter(|f| *f == "add").count(); + let unknown_count = fn_names.iter().filter(|f| *f == "unknown").count(); let init_count = fn_names .iter() .filter(|f| *f == "agent-initialization") @@ -804,9 +805,16 @@ async fn oplog_processor_crash_stress(deps: &EnvBasedTestDependencies) -> anyhow // Subtract 1 for agent-initialization's InvocationFinished let completed_adds_in_oplog = completed_invocations_in_oplog.saturating_sub(1); + // "unknown" callbacks come from AgentInvocationFinished entries whose + // matching AgentInvocationStarted was in a prior batch sent to a + // different plugin worker instance (e.g. after shard reassignment / + // locality recovery). These are still valid add invocations; they + // just couldn't be labelled. + let effective_add_count = add_count + unknown_count; + tracing::info!( "After {CRASH_ROUNDS} crash rounds: received {} invocations \ - ({add_count} adds, {init_count} inits). \ + ({add_count} adds, {unknown_count} unknown, {init_count} inits). \ Oplog has {completed_adds_in_oplog} completed adds (expected {expected_total_adds}).", invocation_count(&batches), ); @@ -821,11 +829,14 @@ async fn oplog_processor_crash_stress(deps: &EnvBasedTestDependencies) -> anyhow ); // Every completed add must have exactly one callback delivery. + // Some may be labelled "unknown" when a batch boundary splits + // AgentInvocationStarted / AgentInvocationFinished and locality + // recovery migrated to a new plugin worker in between. assert_eq!( - add_count, completed_adds_in_oplog, + effective_add_count, completed_adds_in_oplog, "Oplog processor must deliver exactly one callback per completed invocation. \ Worker completed {completed_adds_in_oplog} adds but oplog processor delivered \ - {add_count} add callbacks." + {effective_add_count} callbacks ({add_count} add + {unknown_count} unknown)." ); Ok(()) diff --git a/openapi/golem-registry-service.yaml b/openapi/golem-registry-service.yaml index c263484b5f..e2a692362e 100644 --- a/openapi/golem-registry-service.yaml +++ b/openapi/golem-registry-service.yaml @@ -7118,6 +7118,7 @@ components: enum: - admin - marketing-admin + - builtin-plugin-owner AccountSetPlan: type: object title: AccountSetPlan diff --git a/openapi/golem-service.yaml b/openapi/golem-service.yaml index 81dc2c49d9..5b7a05c129 100644 --- a/openapi/golem-service.yaml +++ b/openapi/golem-service.yaml @@ -10162,6 +10162,12 @@ components: type: string required: - idempotencyKey + ProcessOplogEntriesResultParameters: + title: ProcessOplogEntriesResultParameters + type: object + properties: + error: + type: string PublicAgentInvocation: discriminator: propertyName: type @@ -10189,7 +10195,7 @@ components: ManualUpdate: '#/components/schemas/PublicAgentInvocationResult_Empty' LoadSnapshot: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' SaveSnapshot: '#/components/schemas/PublicAgentInvocationResult_SaveSnapshotResultParameters' - ProcessOplogEntries: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' + ProcessOplogEntries: '#/components/schemas/PublicAgentInvocationResult_ProcessOplogEntriesResultParameters' type: object oneOf: - $ref: '#/components/schemas/PublicAgentInvocationResult_AgentInvocationOutputParameters' @@ -10197,7 +10203,7 @@ components: - $ref: '#/components/schemas/PublicAgentInvocationResult_Empty' - $ref: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' - $ref: '#/components/schemas/PublicAgentInvocationResult_SaveSnapshotResultParameters' - - $ref: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' + - $ref: '#/components/schemas/PublicAgentInvocationResult_ProcessOplogEntriesResultParameters' PublicAgentInvocationResult_AgentInvocationOutputParameters: allOf: - type: object @@ -10223,6 +10229,18 @@ components: - type - $ref: '#/components/schemas/Empty' PublicAgentInvocationResult_FallibleResultParameters: + allOf: + - type: object + properties: + type: + example: LoadSnapshot + type: string + enum: + - LoadSnapshot + required: + - type + - $ref: '#/components/schemas/FallibleResultParameters' + PublicAgentInvocationResult_ProcessOplogEntriesResultParameters: allOf: - type: object properties: @@ -10233,7 +10251,7 @@ components: - ProcessOplogEntries required: - type - - $ref: '#/components/schemas/FallibleResultParameters' + - $ref: '#/components/schemas/ProcessOplogEntriesResultParameters' PublicAgentInvocationResult_SaveSnapshotResultParameters: allOf: - type: object @@ -12442,6 +12460,7 @@ components: enum: - admin - marketing-admin + - builtin-plugin-owner AccountSetPlan: title: AccountSetPlan type: object diff --git a/openapi/golem-worker-service.yaml b/openapi/golem-worker-service.yaml index e626a955a0..7878d5c5bc 100644 --- a/openapi/golem-worker-service.yaml +++ b/openapi/golem-worker-service.yaml @@ -3030,6 +3030,12 @@ components: properties: idempotencyKey: type: string + ProcessOplogEntriesResultParameters: + type: object + title: ProcessOplogEntriesResultParameters + properties: + error: + type: string PublicAgentInvocation: type: object oneOf: @@ -3056,7 +3062,7 @@ components: - $ref: '#/components/schemas/PublicAgentInvocationResult_Empty' - $ref: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' - $ref: '#/components/schemas/PublicAgentInvocationResult_SaveSnapshotResultParameters' - - $ref: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' + - $ref: '#/components/schemas/PublicAgentInvocationResult_ProcessOplogEntriesResultParameters' discriminator: propertyName: type mapping: @@ -3065,7 +3071,7 @@ components: ManualUpdate: '#/components/schemas/PublicAgentInvocationResult_Empty' LoadSnapshot: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' SaveSnapshot: '#/components/schemas/PublicAgentInvocationResult_SaveSnapshotResultParameters' - ProcessOplogEntries: '#/components/schemas/PublicAgentInvocationResult_FallibleResultParameters' + ProcessOplogEntries: '#/components/schemas/PublicAgentInvocationResult_ProcessOplogEntriesResultParameters' PublicAgentInvocationResult_AgentInvocationOutputParameters: allOf: - type: object @@ -3091,6 +3097,18 @@ components: example: ManualUpdate - $ref: '#/components/schemas/Empty' PublicAgentInvocationResult_FallibleResultParameters: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - LoadSnapshot + example: LoadSnapshot + - $ref: '#/components/schemas/FallibleResultParameters' + PublicAgentInvocationResult_ProcessOplogEntriesResultParameters: allOf: - type: object required: @@ -3101,7 +3119,7 @@ components: enum: - ProcessOplogEntries example: ProcessOplogEntries - - $ref: '#/components/schemas/FallibleResultParameters' + - $ref: '#/components/schemas/ProcessOplogEntriesResultParameters' PublicAgentInvocationResult_SaveSnapshotResultParameters: allOf: - type: object diff --git a/plugins/otlp-exporter.wasm b/plugins/otlp-exporter.wasm new file mode 100644 index 0000000000..8007f1c339 Binary files /dev/null and b/plugins/otlp-exporter.wasm differ diff --git a/plugins/otlp-exporter/.gitignore b/plugins/otlp-exporter/.gitignore new file mode 100644 index 0000000000..c40c531469 --- /dev/null +++ b/plugins/otlp-exporter/.gitignore @@ -0,0 +1,2 @@ +target/ +golem-temp/ diff --git a/plugins/otlp-exporter/Cargo.lock b/plugins/otlp-exporter/Cargo.lock new file mode 100644 index 0000000000..5a029b5d14 --- /dev/null +++ b/plugins/otlp-exporter/Cargo.lock @@ -0,0 +1,1194 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "bitflags" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" + +[[package]] +name = "bumpalo" +version = "3.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cc" +version = "1.2.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "chrono" +version = "0.4.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "fastrand" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be" +dependencies = [ + "instant", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-io" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" + +[[package]] +name = "futures-lite" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "memchr", + "parking", + "pin-project-lite", + "waker-fn", +] + +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", + "wasip3", +] + +[[package]] +name = "golem-rust" +version = "0.0.0" +dependencies = [ + "golem-rust-macro", + "golem-wasm", + "http", + "log", + "serde", + "serde_json", + "uuid", + "wasi-logger", + "wasip2", + "wit-bindgen 0.53.1", + "wstd", +] + +[[package]] +name = "golem-rust-macro" +version = "0.0.0" +dependencies = [ + "heck 0.5.0", + "humantime", + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "golem-wasm" +version = "0.0.0" +dependencies = [ + "chrono", + "itertools", + "uuid", + "wasip2", + "wit-bindgen-rt 0.44.0", + "wstd", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "foldhash 0.2.0", +] + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "humantime" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", + "serde", + "serde_core", +] + +[[package]] +name = "instant" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" + +[[package]] +name = "js-sys" +version = "0.3.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "leb128" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.183" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "otlp_exporter" +version = "0.0.1" +dependencies = [ + "golem-rust", + "serde", + "serde_json", + "uuid", + "wstd", +] + +[[package]] +name = "parking" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "sha1_smol" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d" + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "spdx" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" +dependencies = [ + "smallvec", +] + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "toml_datetime" +version = "1.0.0+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.4+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7193cbd0ce53dc966037f54351dbbcf0d5a642c7f0038c382ef9e677ce8c13f2" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.0.9+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4" +dependencies = [ + "winnow", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-segmentation" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "uuid" +version = "1.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37" +dependencies = [ + "getrandom", + "js-sys", + "serde_core", + "sha1_smol", + "wasm-bindgen", +] + +[[package]] +name = "waker-fn" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "317211a0dc0ceedd78fb2ca9a44aed3d7b9b26f81870d485c07122b4350673b7" + +[[package]] +name = "wasi-logger" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58aa5201b7f5d96ef2e747a1f60a6dbc38bdd1287ce5e046d1498bd7a793f74b" +dependencies = [ + "log", + "wit-bindgen 0.24.0", +] + +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen 0.51.0", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen 0.51.0", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.202.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfd106365a7f5f7aa3c1916a98cbb3ad477f5ff96ddb130285a91c6e7429e67a" +dependencies = [ + "leb128", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasm-encoder" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9dca005e69bf015e45577e415b9af8c67e8ee3c0e38b5b0add5aa92581ed5c" +dependencies = [ + "leb128fmt", + "wasmparser 0.245.1", +] + +[[package]] +name = "wasm-metadata" +version = "0.202.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "094aea3cb90e09f16ee25a4c0e324b3e8c934e7fd838bfa039aef5352f44a917" +dependencies = [ + "anyhow", + "indexmap", + "serde", + "serde_derive", + "serde_json", + "spdx", + "wasm-encoder 0.202.0", + "wasmparser 0.202.0", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder 0.244.0", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasm-metadata" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da55e60097e8b37b475a0fa35c3420dd71d9eb7bd66109978ab55faf56a57efb" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder 0.245.1", + "wasmparser 0.245.1", +] + +[[package]] +name = "wasmparser" +version = "0.202.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6998515d3cf3f8b980ef7c11b29a9b1017d4cf86b99ae93b546992df9931413" +dependencies = [ + "bitflags", + "indexmap", + "semver", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags", + "hashbrown 0.15.5", + "indexmap", + "semver", +] + +[[package]] +name = "wasmparser" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f08c9adee0428b7bddf3890fc27e015ac4b761cc608c822667102b8bfd6995e" +dependencies = [ + "bitflags", + "hashbrown 0.16.1", + "indexmap", + "semver", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb4e7653763780be47e38f479e9aa83c768aa6a3b2ed086dc2826fdbbb7e7f5" +dependencies = [ + "wit-bindgen-rt 0.24.0", + "wit-bindgen-rust-macro 0.24.0", +] + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "bitflags", + "wit-bindgen-rust-macro 0.51.0", +] + +[[package]] +name = "wit-bindgen" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e915216dde3e818093168df8380a64fba25df468d626c80dd5d6a184c87e7c7" +dependencies = [ + "bitflags", + "wit-bindgen-rust-macro 0.53.1", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b67e11c950041849a10828c7600ea62a4077c01e8af72e8593253575428f91b" +dependencies = [ + "anyhow", + "wit-parser 0.202.0", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck 0.5.0", + "wit-parser 0.244.0", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3deda4b7e9f522d994906f6e6e0fc67965ea8660306940a776b76732be8f3933" +dependencies = [ + "anyhow", + "heck 0.5.0", + "wit-parser 0.245.1", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0780cf7046630ed70f689a098cd8d56c5c3b22f2a7379bbdb088879963ff96" +dependencies = [ + "bitflags", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "653c85dd7aee6fe6f4bded0d242406deadae9819029ce6f7d258c920c384358a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30acbe8fb708c3a830a33c4cb705df82659bf831b492ec6ca1a17a369cfeeafb" +dependencies = [ + "anyhow", + "heck 0.4.1", + "indexmap", + "wasm-metadata 0.202.0", + "wit-bindgen-core 0.24.0", + "wit-component 0.202.0", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck 0.5.0", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata 0.244.0", + "wit-bindgen-core 0.51.0", + "wit-component 0.244.0", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863a7ab3c4dfee58db196811caeb0718b88412a0aef3d1c2b02fcbae1e37c688" +dependencies = [ + "anyhow", + "heck 0.5.0", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata 0.245.1", + "wit-bindgen-core 0.53.1", + "wit-component 0.245.1", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b1b06eae85feaecdf9f2854f7cac124e00d5a6e5014bfb02eb1ecdeb5f265b9" +dependencies = [ + "anyhow", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core 0.24.0", + "wit-bindgen-rust 0.24.0", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core 0.51.0", + "wit-bindgen-rust 0.51.0", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d14f3a9bfa3804bb0e9ab7f66da047f210eded6a1297ae3ba5805b384d64797f" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core 0.53.1", + "wit-bindgen-rust 0.53.1", +] + +[[package]] +name = "wit-component" +version = "0.202.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c836b1fd9932de0431c1758d8be08212071b6bba0151f7bac826dbc4312a2a9" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder 0.202.0", + "wasm-metadata 0.202.0", + "wasmparser 0.202.0", + "wit-parser 0.202.0", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder 0.244.0", + "wasm-metadata 0.244.0", + "wasmparser 0.244.0", + "wit-parser 0.244.0", +] + +[[package]] +name = "wit-component" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4894f10d2d5cbc17c77e91f86a1e48e191a788da4425293b55c98b44ba3fcac9" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder 0.245.1", + "wasm-metadata 0.245.1", + "wasmparser 0.245.1", + "wit-parser 0.245.1", +] + +[[package]] +name = "wit-parser" +version = "0.202.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "744237b488352f4f27bca05a10acb79474415951c450e52ebd0da784c1df2bcc" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.202.0", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.244.0", +] + +[[package]] +name = "wit-parser" +version = "0.245.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330698718e82983499419494dd1e3d7811a457a9bf9f69734e8c5f07a2547929" +dependencies = [ + "anyhow", + "hashbrown 0.16.1", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.245.1", +] + +[[package]] +name = "wstd" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f743611ee524c2416bc1513157eb3235ca24f4270d1b3ab19f93676fcff21398" +dependencies = [ + "anyhow", + "async-task", + "bytes", + "futures-lite", + "http", + "http-body", + "http-body-util", + "itoa", + "pin-project-lite", + "serde", + "serde_json", + "slab", + "wasip2", + "wstd-macro", +] + +[[package]] +name = "wstd-macro" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5db5d13d6e3f2b180b04be8ff8d5c35b37d5621d3e2d0aa85ab99adf817a780" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/plugins/otlp-exporter/Cargo.toml b/plugins/otlp-exporter/Cargo.toml new file mode 100644 index 0000000000..a83055a676 --- /dev/null +++ b/plugins/otlp-exporter/Cargo.toml @@ -0,0 +1,14 @@ +[workspace] +resolver = "2" +members = ["components-rust/*"] + +[profile.release] +opt-level = "s" +lto = true + +[workspace.dependencies] +golem-rust = { path = "../../sdks/rust/golem-rust", features = ["export_oplog_processor"] } +wstd = { version = "=0.6.5", features = ["default", "json"] } +serde_json = "1" +serde = { version = "1", features = ["derive"] } +uuid = "1" diff --git a/plugins/otlp-exporter/components-rust/.gitignore b/plugins/otlp-exporter/components-rust/.gitignore new file mode 100644 index 0000000000..2f7896d1d1 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/.gitignore @@ -0,0 +1 @@ +target/ diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/Cargo.toml b/plugins/otlp-exporter/components-rust/otlp-exporter/Cargo.toml new file mode 100644 index 0000000000..cb11a3cca8 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "otlp_exporter" +version = "0.0.1" +edition = "2021" + +[lib] +crate-type = ["cdylib"] +path = "src/lib.rs" + +[dependencies] +golem-rust = { workspace = true } +wstd = { workspace = true } +serde_json = { workspace = true } +serde = { workspace = true } +uuid = { workspace = true } diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/golem.yaml b/plugins/otlp-exporter/components-rust/otlp-exporter/golem.yaml new file mode 100644 index 0000000000..580db44f9b --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/golem.yaml @@ -0,0 +1,7 @@ +components: + otlp:exporter: + templates: rust + +customCommands: + copy: + - command: cp ../../golem-temp/agents/otlp_exporter_release.wasm ../../../otlp-exporter.wasm diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/config.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/config.rs new file mode 100644 index 0000000000..d7dbe056e8 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/config.rs @@ -0,0 +1,109 @@ +pub(crate) struct ExporterConfig { + pub(crate) endpoint: String, + pub(crate) headers: Vec<(String, String)>, + pub(crate) service_name_mode: ServiceNameMode, + pub(crate) signals: SignalConfig, +} + +pub(crate) struct SignalConfig { + pub(crate) traces: bool, + pub(crate) logs: bool, + pub(crate) metrics: bool, +} + +pub(crate) enum ServiceNameMode { + AgentId, + AgentType, +} + +impl ExporterConfig { + pub(crate) fn from_params(config: &[(String, String)]) -> Result, String> { + let endpoint = match config.iter().find(|(k, _)| k == "endpoint") { + Some((_, v)) if v.is_empty() => { + return Err("'endpoint' is configured but empty".to_string()); + } + Some((_, v)) => v.clone(), + None => return Ok(None), + }; + + if !endpoint.starts_with("http://") && !endpoint.starts_with("https://") { + return Err(format!( + "'endpoint' must start with http:// or https://, got: '{endpoint}'" + )); + } + + let headers = match config.iter().find(|(k, _)| k == "headers") { + Some((_, v)) => { + let mut parsed = Vec::new(); + for pair in v.split(',') { + let mut parts = pair.splitn(2, '='); + let key = parts.next().unwrap().trim().to_string(); + match parts.next() { + Some(val) => parsed.push((key, val.trim().to_string())), + None => { + return Err(format!( + "malformed header entry: '{}', expected 'key=value' format", + pair + )); + } + } + } + parsed + } + None => Vec::new(), + }; + + let service_name_mode = match config.iter().find(|(k, _)| k == "service-name-mode") { + Some((_, v)) if v == "agent-id" => ServiceNameMode::AgentId, + Some((_, v)) if v == "agent-type" => ServiceNameMode::AgentType, + Some((_, v)) => { + return Err(format!( + "invalid 'service-name-mode' value: '{}', expected 'agent-id' or 'agent-type'", + v + )); + } + None => ServiceNameMode::AgentId, + }; + + let signals = match config.iter().find(|(k, _)| k == "signals") { + Some((_, v)) if v.is_empty() => { + return Err("'signals' is configured but empty".to_string()); + } + Some((_, v)) => { + let mut traces = false; + let mut logs = false; + let mut metrics = false; + for signal in v.split(',') { + match signal.trim() { + "traces" => traces = true, + "logs" => logs = true, + "metrics" => metrics = true, + other => { + return Err(format!( + "unknown signal '{}', expected 'traces', 'logs', or 'metrics'", + other + )); + } + } + } + SignalConfig { + traces, + logs, + metrics, + } + } + None => SignalConfig { + traces: true, + logs: false, + metrics: false, + }, + }; + + Ok(Some(ExporterConfig { + endpoint, + headers, + service_name_mode, + signals, + })) + } +} diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/export.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/export.rs new file mode 100644 index 0000000000..7b12167308 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/export.rs @@ -0,0 +1,175 @@ +use crate::config::{ExporterConfig, ServiceNameMode}; +use crate::helpers::{format_uuid, infer_span_kind}; +use crate::otlp_json::{ + ExportLogsServiceRequest, ExportMetricsServiceRequest, ExportTraceServiceRequest, KeyValue, + OtlpSpan, OtlpValue, SpanStatus, +}; +use crate::state::PendingSpan; +use golem_rust::golem_wasm::golem_core_1_5_x::types::{AgentId, ComponentId}; +use wstd::http::{Body, Client, Request}; +use wstd::runtime::block_on; + +pub(crate) fn build_otel_span( + trace_id: &str, + trace_state: Option<&str>, + mut pending: PendingSpan, + end_time_ns: u128, + is_error: bool, + error_message: Option<&str>, +) -> OtlpSpan { + let name = pending + .attributes + .remove("name") + .filter(|s| !s.trim().is_empty()) + .or_else(|| { + match ( + pending.attributes.get("request.method"), + pending.attributes.get("request.uri"), + ) { + (Some(method), Some(uri)) if !method.is_empty() && !uri.is_empty() => { + Some(format!("{method} {uri}")) + } + _ => None, + } + }) + .unwrap_or_else(|| "unknown".to_string()); + let kind = infer_span_kind(&name, &pending.attributes); + + let attributes: Vec = pending + .attributes + .into_iter() + .map(|(key, value)| KeyValue { + key, + value: OtlpValue { + string_value: value, + }, + }) + .collect(); + + let status = if is_error { + Some(SpanStatus { + code: 2, // ERROR + message: error_message.map(|s| s.to_string()), + }) + } else { + None + }; + + OtlpSpan { + trace_id: trace_id.to_string(), + span_id: pending.span_id, + parent_span_id: pending.parent_span_id, + name, + kind, + start_time_unix_nano: pending.start_time_ns.to_string(), + end_time_unix_nano: end_time_ns.to_string(), + attributes, + trace_state: trace_state.map(|s| s.to_string()), + status, + } +} + +fn build_service_name( + config: &ExporterConfig, + component_id: &ComponentId, + worker_id: &AgentId, +) -> String { + match config.service_name_mode { + ServiceNameMode::AgentId => { + let comp_uuid = + format_uuid(component_id.uuid.high_bits, component_id.uuid.low_bits); + format!("{}/{}", comp_uuid, worker_id.agent_id) + } + ServiceNameMode::AgentType => worker_id.agent_id.clone(), + } +} + +pub(crate) fn build_resource_attributes( + config: &ExporterConfig, + component_id: &ComponentId, + worker_id: &AgentId, + metadata: &golem_rust::bindings::golem::api::host::AgentMetadata, +) -> Vec { + let component_id_str = + format_uuid(component_id.uuid.high_bits, component_id.uuid.low_bits); + let agent_id_str = format!("{}/{}", component_id_str, worker_id.agent_id); + let service_name = build_service_name(config, component_id, worker_id); + + vec![ + KeyValue { + key: "service.name".to_string(), + value: OtlpValue { + string_value: service_name, + }, + }, + KeyValue { + key: "golem.agent.id".to_string(), + value: OtlpValue { + string_value: agent_id_str, + }, + }, + KeyValue { + key: "golem.component.id".to_string(), + value: OtlpValue { + string_value: component_id_str, + }, + }, + KeyValue { + key: "golem.component.version".to_string(), + value: OtlpValue { + string_value: metadata.component_revision.to_string(), + }, + }, + ] +} + +fn send_otlp_request(config: &ExporterConfig, path: &str, json: String) -> Result<(), String> { + block_on(async { + let url = format!("{}{}", config.endpoint.trim_end_matches('/'), path); + + let mut builder = Request::post(&url).header("Content-Type", "application/json"); + + for (key, value) in &config.headers { + builder = builder.header(key.as_str(), value.as_str()); + } + + let body = Body::from(json.into_bytes()); + let request = builder.body(body).map_err(|e| e.to_string())?; + + let response = Client::new() + .send(request) + .await + .map_err(|e| format!("OTLP transport error: {e}"))?; + + let status = response.status(); + if !status.is_success() { + return Err(format!("OTLP export failed with HTTP status: {status}")); + } + + Ok(()) + }) +} + +pub(crate) fn send_spans( + config: &ExporterConfig, + request_body: ExportTraceServiceRequest, +) -> Result<(), String> { + let json = serde_json::to_string(&request_body).map_err(|e| e.to_string())?; + send_otlp_request(config, "/v1/traces", json) +} + +pub(crate) fn send_logs( + config: &ExporterConfig, + request_body: ExportLogsServiceRequest, +) -> Result<(), String> { + let json = serde_json::to_string(&request_body).map_err(|e| e.to_string())?; + send_otlp_request(config, "/v1/logs", json) +} + +pub(crate) fn send_metrics( + config: &ExporterConfig, + request_body: ExportMetricsServiceRequest, +) -> Result<(), String> { + let json = serde_json::to_string(&request_body).map_err(|e| e.to_string())?; + send_otlp_request(config, "/v1/metrics", json) +} diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/helpers.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/helpers.rs new file mode 100644 index 0000000000..8083c2288b --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/helpers.rs @@ -0,0 +1,78 @@ +use golem_rust::bindings::golem::api::context::AttributeValue; +use golem_rust::bindings::golem::api::oplog::{Timestamp, WrappedFunctionType, WorkerError}; +use golem_rust::golem_wasm::golem_core_1_5_x::types::{AgentId, ComponentId}; +use golem_rust::wasip2::clocks::wall_clock::Datetime; +use std::collections::HashMap; + +pub(crate) fn datetime_to_nanos(dt: &Datetime) -> u128 { + (dt.seconds as u128) * 1_000_000_000 + (dt.nanoseconds as u128) +} + +pub(crate) fn timestamp_to_nanos(ts: &Timestamp) -> u128 { + datetime_to_nanos(&ts.timestamp) +} + +pub(crate) fn worker_key(component_id: &ComponentId, worker_id: &AgentId) -> String { + format!( + "{:016x}{:016x}/{}", + component_id.uuid.high_bits, component_id.uuid.low_bits, worker_id.agent_id + ) +} + +pub(crate) fn format_uuid(high: u64, low: u64) -> String { + uuid::Uuid::from_u64_pair(high, low).to_string() +} + +pub(crate) fn attribute_value_to_string(v: &AttributeValue) -> String { + match v { + AttributeValue::String(s) => s.clone(), + } +} + +pub(crate) fn infer_span_kind(name: &str, attributes: &HashMap) -> u32 { + match name { + "invoke-exported-function" => 2, // SERVER + "rpc-connection" | "rpc-invocation" | "outgoing-http-request" => 3, // CLIENT + _ => { + if attributes.contains_key("request.method") && attributes.contains_key("request.uri") + { + 2 // SERVER — HTTP gateway root span + } else { + 1 // INTERNAL + } + } + } +} + +pub(crate) fn wrapped_function_type_name(t: &WrappedFunctionType) -> &'static str { + match t { + WrappedFunctionType::ReadLocal => "read-local", + WrappedFunctionType::WriteLocal => "write-local", + WrappedFunctionType::ReadRemote => "read-remote", + WrappedFunctionType::WriteRemote => "write-remote", + WrappedFunctionType::WriteRemoteBatched(_) => "write-remote-batched", + WrappedFunctionType::WriteRemoteTransaction(_) => "write-remote-transaction", + } +} + +pub(crate) fn oplog_payload_size( + payload: &golem_rust::bindings::golem::api::oplog::OplogPayload, +) -> Option { + match payload { + golem_rust::bindings::golem::api::oplog::OplogPayload::Inline(data) => { + Some(data.len() as u64) + } + golem_rust::bindings::golem::api::oplog::OplogPayload::External(_) => None, + } +} + +pub(crate) fn worker_error_to_string(e: &WorkerError) -> String { + match e { + WorkerError::Unknown(s) => format!("unknown: {s}"), + WorkerError::InvalidRequest(s) => format!("invalid request: {s}"), + WorkerError::StackOverflow => "stack overflow".to_string(), + WorkerError::OutOfMemory => "out of memory".to_string(), + WorkerError::ExceededMemoryLimit => "exceeded memory limit".to_string(), + WorkerError::InternalError(s) => format!("internal error: {s}"), + } +} diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/lib.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/lib.rs new file mode 100644 index 0000000000..f48f0a75e9 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/lib.rs @@ -0,0 +1,153 @@ +mod config; +mod export; +mod helpers; +mod otlp_json; +mod processing; +mod state; + +use config::ExporterConfig; +use export::{build_resource_attributes, send_logs, send_metrics, send_spans}; +use helpers::worker_key; +use otlp_json::{ + ExportLogsServiceRequest, ExportMetricsServiceRequest, ExportTraceServiceRequest, + InstrumentationScope, OtlpResource, ResourceLogs, ResourceMetrics, ResourceSpans, ScopeLogs, + ScopeMetrics, ScopeSpans, +}; +use processing::process_entries; +use state::WORKER_STATES; + +use golem_rust::bindings::golem::api::oplog::{OplogEntry, OplogIndex}; +use golem_rust::golem_wasm::golem_core_1_5_x::types::{AgentId, ComponentId}; +use golem_rust::oplog_processor::exports::golem::api::oplog_processor::Guest as OplogProcessorGuest; + +use std::collections::HashMap; + +struct OtlpExporterComponent; + +impl OplogProcessorGuest for OtlpExporterComponent { + fn process( + _account_info: golem_rust::oplog_processor::exports::golem::api::oplog_processor::AccountInfo, + config: Vec<(String, String)>, + component_id: ComponentId, + worker_id: AgentId, + metadata: golem_rust::bindings::golem::api::host::AgentMetadata, + _first_entry_index: OplogIndex, + entries: Vec, + ) -> Result<(), String> { + if entries.is_empty() { + return Ok(()); + } + + let exporter_config = match ExporterConfig::from_params(&config) { + Ok(Some(c)) => c, + Ok(None) => return Ok(()), + Err(e) => { + return Err(format!( + "OTLP exporter: configuration error: {e}" + )); + } + }; + + let key = worker_key(&component_id, &worker_id); + + // Clone current state for processing — do NOT mutate the stored state yet + let mut working_state = WORKER_STATES.with(|states| { + let states = states.borrow(); + states.get(&key).cloned().unwrap_or_else(|| state::WorkerState { + trace_id: String::new(), + trace_states: Vec::new(), + pending_spans: HashMap::new(), + implicit_spans: Vec::new(), + terminal_error: None, + inherited_span_parents: HashMap::new(), + invocation_start_ns: None, + total_memory_bytes: 0, + active_resources: 0, + }) + }); + + let output = process_entries(&mut working_state, entries); + + let has_traces = exporter_config.signals.traces && !output.spans.is_empty(); + let has_logs = exporter_config.signals.logs && !output.log_records.is_empty(); + let has_metrics = exporter_config.signals.metrics && !output.metrics.is_empty(); + + if !has_traces && !has_logs && !has_metrics { + WORKER_STATES.with(|states| { + let mut states = states.borrow_mut(); + if working_state.is_empty() { + states.remove(&key); + } else { + states.insert(key, working_state); + } + }); + return Ok(()); + } + + let resource_attrs = + build_resource_attributes(&exporter_config, &component_id, &worker_id, &metadata); + + let scope = InstrumentationScope { + name: "golem-otlp-exporter".to_string(), + version: "1.5.0".to_string(), + }; + + if has_traces { + let request_body = ExportTraceServiceRequest { + resource_spans: vec![ResourceSpans { + resource: OtlpResource { + attributes: resource_attrs.clone(), + }, + scope_spans: vec![ScopeSpans { + scope: scope.clone(), + spans: output.spans, + }], + }], + }; + send_spans(&exporter_config, request_body)?; + } + + if has_logs { + let request_body = ExportLogsServiceRequest { + resource_logs: vec![ResourceLogs { + resource: OtlpResource { + attributes: resource_attrs.clone(), + }, + scope_logs: vec![ScopeLogs { + scope: scope.clone(), + log_records: output.log_records, + }], + }], + }; + send_logs(&exporter_config, request_body)?; + } + + if has_metrics { + let request_body = ExportMetricsServiceRequest { + resource_metrics: vec![ResourceMetrics { + resource: OtlpResource { + attributes: resource_attrs, + }, + scope_metrics: vec![ScopeMetrics { + scope, + metrics: output.metrics, + }], + }], + }; + send_metrics(&exporter_config, request_body)?; + } + + WORKER_STATES.with(|states| { + let mut states = states.borrow_mut(); + if working_state.is_empty() { + states.remove(&key); + } else { + states.insert(key, working_state); + } + }); + + Ok(()) + } +} + +golem_rust::oplog_processor::export_oplog_processor!(OtlpExporterComponent with_types_in golem_rust::oplog_processor); diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/otlp_json.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/otlp_json.rs new file mode 100644 index 0000000000..feaee3ae92 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/otlp_json.rs @@ -0,0 +1,175 @@ +// We intentionally use small manual OTLP/HTTP JSON structs rather than `opentelemetry-proto`, +// because this plugin emits OTLP JSON (not protobuf) and the generated proto types are a poor +// fit for the JSON wire format in this WASM build. + +use serde::Serialize; + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ExportTraceServiceRequest { + pub(crate) resource_spans: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ResourceSpans { + pub(crate) resource: OtlpResource, + pub(crate) scope_spans: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpResource { + pub(crate) attributes: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ScopeSpans { + pub(crate) scope: InstrumentationScope, + pub(crate) spans: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct InstrumentationScope { + pub(crate) name: String, + pub(crate) version: String, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpSpan { + pub(crate) trace_id: String, + pub(crate) span_id: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) parent_span_id: Option, + pub(crate) name: String, + pub(crate) kind: u32, + pub(crate) start_time_unix_nano: String, + pub(crate) end_time_unix_nano: String, + pub(crate) attributes: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) trace_state: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) status: Option, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct SpanStatus { + pub(crate) code: u32, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) message: Option, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct KeyValue { + pub(crate) key: String, + pub(crate) value: OtlpValue, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpValue { + pub(crate) string_value: String, +} + +// ── Logs (POST /v1/logs) ──────────────────────────────────────────── + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ExportLogsServiceRequest { + pub(crate) resource_logs: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ResourceLogs { + pub(crate) resource: OtlpResource, + pub(crate) scope_logs: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ScopeLogs { + pub(crate) scope: InstrumentationScope, + pub(crate) log_records: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpLogRecord { + pub(crate) time_unix_nano: String, + pub(crate) observed_time_unix_nano: String, + pub(crate) severity_number: u32, + pub(crate) severity_text: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) body: Option, + pub(crate) attributes: Vec, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) trace_id: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) span_id: Option, +} + +// ── Metrics (POST /v1/metrics) ────────────────────────────────────── + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ExportMetricsServiceRequest { + pub(crate) resource_metrics: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ResourceMetrics { + pub(crate) resource: OtlpResource, + pub(crate) scope_metrics: Vec, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct ScopeMetrics { + pub(crate) scope: InstrumentationScope, + pub(crate) metrics: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpMetric { + pub(crate) name: String, + pub(crate) unit: String, + pub(crate) description: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) sum: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) gauge: Option, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpSum { + pub(crate) aggregation_temporality: u32, + pub(crate) is_monotonic: bool, + pub(crate) data_points: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpGauge { + pub(crate) data_points: Vec, +} + +#[derive(Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct OtlpNumberDataPoint { + pub(crate) start_time_unix_nano: String, + pub(crate) time_unix_nano: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) as_int: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) as_double: Option, + pub(crate) attributes: Vec, +} diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/processing.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/processing.rs new file mode 100644 index 0000000000..02a8f6e934 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/processing.rs @@ -0,0 +1,958 @@ +use crate::export::build_otel_span; +use crate::helpers::{ + attribute_value_to_string, datetime_to_nanos, oplog_payload_size, timestamp_to_nanos, + worker_error_to_string, wrapped_function_type_name, +}; +use crate::otlp_json::{ + KeyValue, OtlpGauge, OtlpLogRecord, OtlpMetric, OtlpNumberDataPoint, OtlpSpan, OtlpSum, + OtlpValue, +}; +use crate::state::{PendingSpan, WorkerState}; +use golem_rust::bindings::golem::api::oplog::{ + FailedUpdateParameters, FinishSpanParameters, GrowMemoryParameters, LogLevel, LogParameters, + OplogEntry, RawAgentInvocationFinishedParameters, RawAgentInvocationStartedParameters, + RawCreateParameters, RawCreateResourceParameters, RawDropResourceParameters, + RawHostCallParameters, RawOplogProcessorCheckpointParameters, RawSnapshotParameters, + RawSuccessfulUpdateParameters, RemoteTransactionParameters, SetSpanAttributeParameters, + SpanData, StartSpanParameters, +}; +use std::collections::HashMap; + +pub(crate) struct ProcessingOutput { + pub(crate) spans: Vec, + pub(crate) log_records: Vec, + pub(crate) metrics: Vec, +} + +pub(crate) fn process_entries( + state: &mut WorkerState, + entries: Vec, +) -> ProcessingOutput { + let mut completed_spans: Vec = Vec::new(); + let mut log_records: Vec = Vec::new(); + let mut metrics: Vec = Vec::new(); + + for entry in entries { + match entry { + OplogEntry::Create(params) => { + handle_create(state, params, &mut metrics); + } + OplogEntry::AgentInvocationStarted(params) => { + handle_invocation_started(state, params, &mut metrics); + } + OplogEntry::StartSpan(params) => { + handle_start_span(state, params); + } + OplogEntry::SetSpanAttribute(params) => { + handle_set_span_attribute(state, params); + } + OplogEntry::FinishSpan(params) => { + handle_finish_span(state, params, &mut completed_spans); + } + OplogEntry::AgentInvocationFinished(params) => { + handle_invocation_finished( + state, + params, + &mut completed_spans, + &mut metrics, + ); + } + OplogEntry::Error(params) => { + let error_msg = worker_error_to_string(¶ms.error); + state.terminal_error = Some(error_msg.clone()); + + let time_ns = datetime_to_nanos(¶ms.timestamp); + + handle_terminal(state, time_ns, true, &mut completed_spans); + + metrics.push(counter_metric( + "golem.error.count", + "1", + "Agent errors", + &time_ns.to_string(), + vec![KeyValue { + key: "error.type".to_string(), + value: OtlpValue { + string_value: worker_error_variant_name(¶ms.error), + }, + }], + )); + + log_records.push(OtlpLogRecord { + time_unix_nano: time_ns.to_string(), + observed_time_unix_nano: time_ns.to_string(), + severity_number: 17, + severity_text: "ERROR".to_string(), + body: Some(OtlpValue { + string_value: error_msg, + }), + attributes: vec![KeyValue { + key: "error.type".to_string(), + value: OtlpValue { + string_value: worker_error_variant_name(¶ms.error), + }, + }], + trace_id: non_empty_trace_id(&state.trace_id), + span_id: None, + }); + } + OplogEntry::Interrupted(ts) => { + let time_ns = timestamp_to_nanos(&ts); + state.terminal_error = Some("interrupted".to_string()); + handle_terminal(state, time_ns, true, &mut completed_spans); + + metrics.push(counter_metric( + "golem.interruption.count", + "1", + "Agent interruptions", + &time_ns.to_string(), + Vec::new(), + )); + + log_records.push(OtlpLogRecord { + time_unix_nano: time_ns.to_string(), + observed_time_unix_nano: time_ns.to_string(), + severity_number: 13, + severity_text: "WARN".to_string(), + body: Some(OtlpValue { + string_value: "Agent interrupted".to_string(), + }), + attributes: Vec::new(), + trace_id: non_empty_trace_id(&state.trace_id), + span_id: None, + }); + } + OplogEntry::Exited(ts) => { + let time_ns = timestamp_to_nanos(&ts); + state.terminal_error = Some("exited".to_string()); + handle_terminal(state, time_ns, true, &mut completed_spans); + + metrics.push(counter_metric( + "golem.exit.count", + "1", + "Agent exits", + &time_ns.to_string(), + Vec::new(), + )); + + log_records.push(OtlpLogRecord { + time_unix_nano: time_ns.to_string(), + observed_time_unix_nano: time_ns.to_string(), + severity_number: 9, + severity_text: "INFO".to_string(), + body: Some(OtlpValue { + string_value: "Agent exited".to_string(), + }), + attributes: Vec::new(), + trace_id: non_empty_trace_id(&state.trace_id), + span_id: None, + }); + } + OplogEntry::Log(params) => { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + metrics.push(counter_metric( + "golem.log.count", + "1", + "Log message count", + &time_ns, + vec![KeyValue { + key: "level".to_string(), + value: OtlpValue { + string_value: log_level_severity_text(¶ms.level).to_string(), + }, + }], + )); + handle_log(state, params, &mut log_records); + } + OplogEntry::GrowMemory(params) => { + handle_grow_memory(state, params, &mut metrics); + } + OplogEntry::HostCall(params) => { + handle_host_call(params, &mut metrics); + } + OplogEntry::PendingAgentInvocation(params) => { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + metrics.push(counter_metric( + "golem.invocation.pending_count", + "1", + "Pending invocation requests", + &time_ns, + Vec::new(), + )); + } + OplogEntry::CreateResource(params) => { + handle_create_resource(state, params, &mut metrics); + } + OplogEntry::DropResource(params) => { + handle_drop_resource(state, params, &mut metrics); + } + OplogEntry::Restart(ts) => { + let time_ns = timestamp_to_nanos(&ts).to_string(); + metrics.push(counter_metric( + "golem.restart.count", + "1", + "Agent restarts", + &time_ns, + Vec::new(), + )); + } + OplogEntry::SuccessfulUpdate(params) => { + handle_successful_update(params, &mut metrics); + } + OplogEntry::FailedUpdate(params) => { + handle_failed_update(params, &mut metrics); + } + OplogEntry::CommittedRemoteTransaction(params) => { + handle_committed_transaction(params, &mut metrics); + } + OplogEntry::RolledBackRemoteTransaction(params) => { + handle_rolled_back_transaction(params, &mut metrics); + } + OplogEntry::Snapshot(params) => { + handle_snapshot(params, &mut metrics); + } + OplogEntry::OplogProcessorCheckpoint(params) => { + handle_oplog_processor_checkpoint(params, &mut metrics); + } + _ => {} // ignore all other entry types + } + } + + ProcessingOutput { + spans: completed_spans, + log_records, + metrics, + } +} + +fn non_empty_trace_id(trace_id: &str) -> Option { + if trace_id.is_empty() { + None + } else { + Some(trace_id.to_string()) + } +} + +fn worker_error_variant_name( + e: &golem_rust::bindings::golem::api::oplog::WorkerError, +) -> String { + match e { + golem_rust::bindings::golem::api::oplog::WorkerError::Unknown(_) => { + "Unknown".to_string() + } + golem_rust::bindings::golem::api::oplog::WorkerError::InvalidRequest(_) => { + "InvalidRequest".to_string() + } + golem_rust::bindings::golem::api::oplog::WorkerError::StackOverflow => { + "StackOverflow".to_string() + } + golem_rust::bindings::golem::api::oplog::WorkerError::OutOfMemory => { + "OutOfMemory".to_string() + } + golem_rust::bindings::golem::api::oplog::WorkerError::ExceededMemoryLimit => { + "ExceededMemoryLimit".to_string() + } + golem_rust::bindings::golem::api::oplog::WorkerError::InternalError(_) => { + "InternalError".to_string() + } + } +} + +fn log_level_severity_number(level: &LogLevel) -> u32 { + match level { + LogLevel::Stdout => 1, + LogLevel::Stderr => 13, + LogLevel::Trace => 1, + LogLevel::Debug => 5, + LogLevel::Info => 9, + LogLevel::Warn => 13, + LogLevel::Error => 17, + LogLevel::Critical => 21, + } +} + +fn log_level_severity_text(level: &LogLevel) -> &'static str { + match level { + LogLevel::Stdout => "STDOUT", + LogLevel::Stderr => "STDERR", + LogLevel::Trace => "TRACE", + LogLevel::Debug => "DEBUG", + LogLevel::Info => "INFO", + LogLevel::Warn => "WARN", + LogLevel::Error => "ERROR", + LogLevel::Critical => "CRITICAL", + } +} + +fn handle_log( + state: &WorkerState, + params: LogParameters, + log_records: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + let mut attributes = Vec::new(); + if !params.context.is_empty() { + attributes.push(KeyValue { + key: "log.context".to_string(), + value: OtlpValue { + string_value: params.context, + }, + }); + } + + log_records.push(OtlpLogRecord { + time_unix_nano: time_ns.clone(), + observed_time_unix_nano: time_ns, + severity_number: log_level_severity_number(¶ms.level), + severity_text: log_level_severity_text(¶ms.level).to_string(), + body: Some(OtlpValue { + string_value: params.message, + }), + attributes, + trace_id: non_empty_trace_id(&state.trace_id), + span_id: None, + }); +} + +fn counter_metric( + name: &str, + unit: &str, + description: &str, + time_ns: &str, + attributes: Vec, +) -> OtlpMetric { + OtlpMetric { + name: name.to_string(), + unit: unit.to_string(), + description: description.to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.to_string(), + time_unix_nano: time_ns.to_string(), + as_int: Some("1".to_string()), + as_double: None, + attributes, + }], + }), + gauge: None, + } +} + +fn gauge_metric( + name: &str, + unit: &str, + description: &str, + time_ns: &str, + value: u64, +) -> OtlpMetric { + OtlpMetric { + name: name.to_string(), + unit: unit.to_string(), + description: description.to_string(), + sum: None, + gauge: Some(OtlpGauge { + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.to_string(), + time_unix_nano: time_ns.to_string(), + as_int: Some(value.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + } +} + +fn handle_create( + state: &mut WorkerState, + params: RawCreateParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + + state.total_memory_bytes = params.initial_total_linear_memory_size; + + metrics.push(gauge_metric( + "golem.memory.initial_bytes", + "By", + "Initial linear memory size", + &time_ns, + params.initial_total_linear_memory_size, + )); + + metrics.push(gauge_metric( + "golem.memory.total_bytes", + "By", + "Total linear memory size", + &time_ns, + state.total_memory_bytes, + )); + + metrics.push(gauge_metric( + "golem.component.size_bytes", + "By", + "Component size", + &time_ns, + params.component_size, + )); +} + +fn handle_grow_memory(state: &mut WorkerState, params: GrowMemoryParameters, metrics: &mut Vec) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + + state.total_memory_bytes += params.delta; + + metrics.push(OtlpMetric { + name: "golem.memory.growth_bytes".to_string(), + unit: "By".to_string(), + description: "Linear memory growth".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns.clone(), + as_int: Some(params.delta.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); + + metrics.push(gauge_metric( + "golem.memory.total_bytes", + "By", + "Total linear memory size", + &time_ns, + state.total_memory_bytes, + )); +} + +fn handle_host_call(params: RawHostCallParameters, metrics: &mut Vec) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + let fn_type = wrapped_function_type_name(¶ms.durable_function_type); + metrics.push(OtlpMetric { + name: "golem.host_call.count".to_string(), + unit: "1".to_string(), + description: "Host function calls".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some("1".to_string()), + as_double: None, + attributes: vec![ + KeyValue { + key: "function.name".to_string(), + value: OtlpValue { + string_value: params.function_name, + }, + }, + KeyValue { + key: "durable_function_type".to_string(), + value: OtlpValue { + string_value: fn_type.to_string(), + }, + }, + ], + }], + }), + gauge: None, + }); +} + +fn handle_invocation_started( + state: &mut WorkerState, + params: RawAgentInvocationStartedParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp); + state.invocation_start_ns = Some(time_ns); + + metrics.push(counter_metric( + "golem.invocation.count", + "1", + "Invocation count", + &time_ns.to_string(), + Vec::new(), + )); + + if !state.pending_spans.is_empty() || !state.implicit_spans.is_empty() { + println!( + "OTLP exporter: new invocation started with {} pending and {} implicit spans still open, discarding", + state.pending_spans.len(), + state.implicit_spans.len() + ); + } + state.pending_spans.clear(); + state.implicit_spans.clear(); + state.terminal_error = None; + state.inherited_span_parents.clear(); + + state.trace_id = params.trace_id; + state.trace_states = params.trace_states; + + // First pass: build a raw map of inherited span_id → parent_span_id. + // External spans are roots in the inherited chain (parent = None). + let mut raw_inherited: HashMap> = HashMap::new(); + + for span_data in ¶ms.invocation_context { + match span_data { + SpanData::LocalSpan(local) if local.inherited => { + raw_inherited.insert(local.span_id.clone(), local.parent.clone()); + } + SpanData::ExternalSpan(ext) => { + raw_inherited.insert(ext.span_id.clone(), None); + } + _ => {} + } + } + + // Resolve each inherited entry: follow the parent chain through the + // inherited map until reaching a parent that is NOT in the map (i.e. it + // was exported by the originating worker) or None (root). + let resolved: HashMap> = raw_inherited + .keys() + .map(|span_id| { + let resolved_parent = resolve_inherited_parent(span_id, &raw_inherited); + (span_id.clone(), resolved_parent) + }) + .collect(); + + state.inherited_span_parents = resolved; + + // Second pass: collect non-inherited local spans, resolving parents + // through the inherited map when necessary. + for span_data in params.invocation_context { + match span_data { + SpanData::LocalSpan(local) if !local.inherited => { + let attrs: HashMap = local + .attributes + .into_iter() + .map(|a| (a.key, attribute_value_to_string(&a.value))) + .collect(); + + let parent = resolve_parent_through_inherited( + local.parent, + &state.inherited_span_parents, + ); + + state.implicit_spans.push(PendingSpan { + span_id: local.span_id, + parent_span_id: parent, + start_time_ns: datetime_to_nanos(&local.start), + attributes: attrs, + }); + } + _ => {} + } + } +} + +/// Given a span_id in the inherited map, follow the parent chain until we find +/// a parent that is NOT itself in the map (meaning it was exported by the +/// originating worker), or `None` if the chain ends at a root. +fn resolve_inherited_parent( + span_id: &str, + inherited: &HashMap>, +) -> Option { + let mut current = span_id; + loop { + match inherited.get(current) { + Some(Some(parent)) => { + if inherited.contains_key(parent.as_str()) { + current = parent.as_str(); + } else { + // Parent is not inherited — it's the real ancestor + return Some(parent.clone()); + } + } + Some(None) => { + // This entry is a root (external span or chain end) + return None; + } + None => { + // Not in the map — shouldn't happen for the initial call + return None; + } + } + } +} + +/// If `parent` points to an inherited span, resolve through the inherited map +/// to find the real (non-inherited) ancestor. Otherwise return as-is. +fn resolve_parent_through_inherited( + parent: Option, + inherited: &HashMap>, +) -> Option { + match parent { + Some(ref pid) if inherited.contains_key(pid.as_str()) => { + inherited.get(pid.as_str()).cloned().flatten() + } + other => other, + } +} + +fn handle_start_span(state: &mut WorkerState, params: StartSpanParameters) { + let attrs: HashMap = params + .attributes + .into_iter() + .map(|a| (a.key, attribute_value_to_string(&a.value))) + .collect(); + + let parent = resolve_parent_through_inherited(params.parent, &state.inherited_span_parents); + + state.pending_spans.insert( + params.span_id.clone(), + PendingSpan { + span_id: params.span_id, + parent_span_id: parent, + start_time_ns: datetime_to_nanos(¶ms.timestamp), + attributes: attrs, + }, + ); +} + +fn handle_set_span_attribute(state: &mut WorkerState, params: SetSpanAttributeParameters) { + let value = attribute_value_to_string(¶ms.value); + + if let Some(span) = state.pending_spans.get_mut(¶ms.span_id) { + span.attributes.insert(params.key, value); + return; + } + + for span in &mut state.implicit_spans { + if span.span_id == params.span_id { + span.attributes.insert(params.key, value); + return; + } + } + + println!( + "OTLP exporter: set-span-attribute for unknown span {}", + params.span_id + ); +} + +fn handle_finish_span( + state: &mut WorkerState, + params: FinishSpanParameters, + completed: &mut Vec, +) { + if let Some(span) = state.pending_spans.remove(¶ms.span_id) { + let end_time_ns = datetime_to_nanos(¶ms.timestamp); + let trace_state = combined_trace_state(&state.trace_states); + completed.push(build_otel_span( + &state.trace_id, + trace_state.as_deref(), + span, + end_time_ns, + false, + None, + )); + } else { + println!( + "OTLP exporter: finish-span for unknown span {}", + params.span_id + ); + } +} + +fn handle_invocation_finished( + state: &mut WorkerState, + params: RawAgentInvocationFinishedParameters, + completed: &mut Vec, + metrics: &mut Vec, +) { + let end_time_ns = datetime_to_nanos(¶ms.timestamp); + flush_implicit_spans(state, end_time_ns, false, completed); + flush_remaining_explicit_spans(state, end_time_ns, false, completed); + + let time_ns = end_time_ns.to_string(); + + if let Some(start_ns) = state.invocation_start_ns.take() { + let duration_ns = end_time_ns.saturating_sub(start_ns); + metrics.push(OtlpMetric { + name: "golem.invocation.duration_ns".to_string(), + unit: "ns".to_string(), + description: "Invocation duration".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns.clone(), + as_int: Some(duration_ns.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); + } + + if params.consumed_fuel > 0 { + metrics.push(OtlpMetric { + name: "golem.invocation.fuel_consumed".to_string(), + unit: "1".to_string(), + description: "Fuel consumed by the invocation".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some(params.consumed_fuel.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); + } +} + +fn handle_terminal( + state: &mut WorkerState, + end_time_ns: u128, + is_error: bool, + completed: &mut Vec, +) { + flush_implicit_spans(state, end_time_ns, is_error, completed); + flush_remaining_explicit_spans(state, end_time_ns, is_error, completed); +} + +fn combined_trace_state(trace_states: &[String]) -> Option { + if trace_states.is_empty() { + None + } else { + Some(trace_states.join(",")) + } +} + +fn flush_implicit_spans( + state: &mut WorkerState, + end_time_ns: u128, + is_error: bool, + completed: &mut Vec, +) { + let error_msg = state.terminal_error.clone(); + let trace_id = state.trace_id.clone(); + let trace_state = combined_trace_state(&state.trace_states); + let spans = std::mem::take(&mut state.implicit_spans); + + for span in spans { + completed.push(build_otel_span( + &trace_id, + trace_state.as_deref(), + span, + end_time_ns, + is_error, + error_msg.as_deref(), + )); + } +} + +fn flush_remaining_explicit_spans( + state: &mut WorkerState, + end_time_ns: u128, + is_error: bool, + completed: &mut Vec, +) { + let error_msg = state.terminal_error.clone(); + let trace_id = state.trace_id.clone(); + let trace_state = combined_trace_state(&state.trace_states); + let spans: Vec = state.pending_spans.drain().map(|(_, v)| v).collect(); + + for span in spans { + completed.push(build_otel_span( + &trace_id, + trace_state.as_deref(), + span, + end_time_ns, + is_error, + error_msg.as_deref(), + )); + } +} + +fn handle_create_resource( + state: &mut WorkerState, + params: RawCreateResourceParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + + state.active_resources += 1; + + metrics.push(counter_metric( + "golem.resources.created", + "1", + "Resource instances created", + &time_ns, + Vec::new(), + )); + + metrics.push(OtlpMetric { + name: "golem.resources.active".to_string(), + unit: "1".to_string(), + description: "Active resource instances".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: false, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some(state.active_resources.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); +} + +fn handle_drop_resource( + state: &mut WorkerState, + params: RawDropResourceParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + + state.active_resources = (state.active_resources - 1).max(0); + + metrics.push(counter_metric( + "golem.resources.dropped", + "1", + "Resource instances dropped", + &time_ns, + Vec::new(), + )); + + metrics.push(OtlpMetric { + name: "golem.resources.active".to_string(), + unit: "1".to_string(), + description: "Active resource instances".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: false, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some(state.active_resources.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); +} + +fn handle_successful_update(params: RawSuccessfulUpdateParameters, metrics: &mut Vec) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + + metrics.push(counter_metric( + "golem.update.success_count", + "1", + "Successful component updates", + &time_ns, + Vec::new(), + )); + + metrics.push(gauge_metric( + "golem.component.size_bytes", + "By", + "Component size", + &time_ns, + params.new_component_size, + )); +} + +fn handle_failed_update(params: FailedUpdateParameters, metrics: &mut Vec) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + metrics.push(counter_metric( + "golem.update.failure_count", + "1", + "Failed component updates", + &time_ns, + Vec::new(), + )); +} + +fn handle_committed_transaction( + params: RemoteTransactionParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + metrics.push(counter_metric( + "golem.transaction.committed", + "1", + "Committed remote transactions", + &time_ns, + Vec::new(), + )); +} + +fn handle_rolled_back_transaction( + params: RemoteTransactionParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + metrics.push(counter_metric( + "golem.transaction.rolled_back", + "1", + "Rolled back remote transactions", + &time_ns, + Vec::new(), + )); +} + +fn handle_snapshot(params: RawSnapshotParameters, metrics: &mut Vec) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + if let Some(size) = oplog_payload_size(¶ms.data) { + metrics.push(OtlpMetric { + name: "golem.snapshot.size_bytes".to_string(), + unit: "By".to_string(), + description: "Snapshot size".to_string(), + sum: Some(OtlpSum { + aggregation_temporality: 1, + is_monotonic: true, + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some(size.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + gauge: None, + }); + } +} + +fn handle_oplog_processor_checkpoint( + params: RawOplogProcessorCheckpointParameters, + metrics: &mut Vec, +) { + let time_ns = datetime_to_nanos(¶ms.timestamp).to_string(); + let lag = params.sending_up_to.saturating_sub(params.confirmed_up_to); + metrics.push(OtlpMetric { + name: "golem.oplog_processor.lag".to_string(), + unit: "1".to_string(), + description: "Oplog processor delivery lag (entries)".to_string(), + sum: None, + gauge: Some(OtlpGauge { + data_points: vec![OtlpNumberDataPoint { + start_time_unix_nano: time_ns.clone(), + time_unix_nano: time_ns, + as_int: Some(lag.to_string()), + as_double: None, + attributes: Vec::new(), + }], + }), + }); +} diff --git a/plugins/otlp-exporter/components-rust/otlp-exporter/src/state.rs b/plugins/otlp-exporter/components-rust/otlp-exporter/src/state.rs new file mode 100644 index 0000000000..56581c7576 --- /dev/null +++ b/plugins/otlp-exporter/components-rust/otlp-exporter/src/state.rs @@ -0,0 +1,43 @@ +use std::cell::RefCell; +use std::collections::HashMap; + +#[derive(Clone)] +pub(crate) struct WorkerState { + pub(crate) trace_id: String, + pub(crate) trace_states: Vec, + pub(crate) pending_spans: HashMap, + pub(crate) implicit_spans: Vec, + pub(crate) terminal_error: Option, + /// Maps inherited span_id → resolved parent span_id (the nearest ancestor + /// that was NOT inherited, i.e. exported by the originating worker). `None` + /// means the inherited chain ends at a root / external span with no further parent. + pub(crate) inherited_span_parents: HashMap>, + /// Timestamp (nanos) when the current invocation started, for duration metrics. + pub(crate) invocation_start_ns: Option, + /// Running total of linear memory in bytes (initial + sum of grow deltas). + pub(crate) total_memory_bytes: u64, + /// Running count of active resources (created - dropped). + pub(crate) active_resources: i64, +} + +impl WorkerState { + pub(crate) fn is_empty(&self) -> bool { + self.pending_spans.is_empty() + && self.implicit_spans.is_empty() + && self.terminal_error.is_none() + && self.inherited_span_parents.is_empty() + } +} + +#[derive(Clone)] +pub(crate) struct PendingSpan { + pub(crate) span_id: String, + pub(crate) parent_span_id: Option, + pub(crate) start_time_ns: u128, + pub(crate) attributes: HashMap, +} + +thread_local! { + pub(crate) static WORKER_STATES: RefCell> = + RefCell::new(HashMap::new()); +} diff --git a/plugins/otlp-exporter/golem.yaml b/plugins/otlp-exporter/golem.yaml new file mode 100644 index 0000000000..71d3f41c25 --- /dev/null +++ b/plugins/otlp-exporter/golem.yaml @@ -0,0 +1,15 @@ +# Schema for IDEA: +# $schema: https://schema.golem.cloud/app/golem/1.5.0-dev.1/golem.schema.json + +app: otlp-exporter + +includes: + - components-*/*/golem.yaml + +environments: + local: + server: local + componentPresets: debug + cloud: + server: cloud + componentPresets: release diff --git a/test-components/agent-invocation-context/components-rust/golem-it-agent-invocation-context/src/lib.rs b/test-components/agent-invocation-context/components-rust/golem-it-agent-invocation-context/src/lib.rs index 44bea8cb25..35ece5193f 100644 --- a/test-components/agent-invocation-context/components-rust/golem-it-agent-invocation-context/src/lib.rs +++ b/test-components/agent-invocation-context/components-rust/golem-it-agent-invocation-context/src/lib.rs @@ -95,12 +95,17 @@ fn broadcast_current_invocation_context(from: &str) { }); println!("Sending context {body} through HTTP"); - let port = std::env::var("PORT").unwrap_or("9999".to_string()); + let Ok(port) = std::env::var("PORT") else { + return; + }; let client = Client::builder().build().unwrap(); - client + match client .post(&format!("http://localhost:{port}/invocation-context")) .json(&body) .send() - .expect("Request failed"); + { + Ok(_) => println!("Context broadcast succeeded"), + Err(e) => println!("Context broadcast failed (non-fatal): {e}"), + } } diff --git a/test-components/benchmark_agent_rust_release.wasm b/test-components/benchmark_agent_rust_release.wasm index 03472fb6d7..1e01ad206f 100644 Binary files a/test-components/benchmark_agent_rust_release.wasm and b/test-components/benchmark_agent_rust_release.wasm differ diff --git a/test-components/benchmark_agent_ts.wasm b/test-components/benchmark_agent_ts.wasm index 50b780f9a7..074704eac8 100644 Binary files a/test-components/benchmark_agent_ts.wasm and b/test-components/benchmark_agent_ts.wasm differ diff --git a/test-components/build-components.sh b/test-components/build-components.sh index 8e73e3184a..38bcfc22dc 100755 --- a/test-components/build-components.sh +++ b/test-components/build-components.sh @@ -2,7 +2,7 @@ set -euo pipefail IFS=$'\n\t' -rust_test_apps=("host-api-tests" "http-tests" "initial-file-system" "agent-counters" "agent-updates-v1" "agent-updates-v2" "agent-updates-v3" "agent-updates-v4" "scalability" "agent-sdk-rust" "agent-invocation-context" "agent-rpc" "agent-mcp" "oplog-processor") +rust_test_apps=("oplog-processor" "host-api-tests" "http-tests" "initial-file-system" "agent-counters" "agent-updates-v1" "agent-updates-v2" "agent-updates-v3" "agent-updates-v4" "scalability" "agent-sdk-rust" "agent-invocation-context" "agent-rpc" "agent-mcp" "oplog-processor") ts_test_apps=("agent-constructor-parameter-echo" "agent-promise" "agent-sdk-ts") benchmark_apps=("benchmarks") diff --git a/test-components/golem_it_agent_invocation_context.wasm b/test-components/golem_it_agent_invocation_context.wasm index e241545b60..2b35cb4155 100644 Binary files a/test-components/golem_it_agent_invocation_context.wasm and b/test-components/golem_it_agent_invocation_context.wasm differ diff --git a/test-components/golem_it_agent_invocation_context_release.wasm b/test-components/golem_it_agent_invocation_context_release.wasm index 07a23cb731..df46d16d48 100644 Binary files a/test-components/golem_it_agent_invocation_context_release.wasm and b/test-components/golem_it_agent_invocation_context_release.wasm differ diff --git a/test-components/golem_it_agent_promise.wasm b/test-components/golem_it_agent_promise.wasm index d596ea1a08..0e65cc15b9 100644 Binary files a/test-components/golem_it_agent_promise.wasm and b/test-components/golem_it_agent_promise.wasm differ diff --git a/test-components/golem_it_agent_rpc.wasm b/test-components/golem_it_agent_rpc.wasm index 12c2aa1908..7b8349c682 100644 Binary files a/test-components/golem_it_agent_rpc.wasm and b/test-components/golem_it_agent_rpc.wasm differ diff --git a/test-components/golem_it_agent_rpc_rust_release.wasm b/test-components/golem_it_agent_rpc_rust_release.wasm index 51c9f0ccd7..53e91ed866 100644 Binary files a/test-components/golem_it_agent_rpc_rust_release.wasm and b/test-components/golem_it_agent_rpc_rust_release.wasm differ diff --git a/test-components/golem_it_agent_sdk_rust_release.wasm b/test-components/golem_it_agent_sdk_rust_release.wasm index 5b772495bd..1ae0ca7948 100644 Binary files a/test-components/golem_it_agent_sdk_rust_release.wasm and b/test-components/golem_it_agent_sdk_rust_release.wasm differ diff --git a/test-components/golem_it_agent_sdk_ts.wasm b/test-components/golem_it_agent_sdk_ts.wasm index 2a9d496a25..d523bfb83d 100644 Binary files a/test-components/golem_it_agent_sdk_ts.wasm and b/test-components/golem_it_agent_sdk_ts.wasm differ diff --git a/test-components/golem_it_constructor_parameter_echo.wasm b/test-components/golem_it_constructor_parameter_echo.wasm index f47a5fc869..722b96c1a7 100644 Binary files a/test-components/golem_it_constructor_parameter_echo.wasm and b/test-components/golem_it_constructor_parameter_echo.wasm differ diff --git a/test-components/golem_it_host_api_tests_release.wasm b/test-components/golem_it_host_api_tests_release.wasm index 5172e8707b..311928f330 100644 Binary files a/test-components/golem_it_host_api_tests_release.wasm and b/test-components/golem_it_host_api_tests_release.wasm differ diff --git a/test-components/golem_it_http_tests_release.wasm b/test-components/golem_it_http_tests_release.wasm index a7fb799015..c0698127b5 100644 Binary files a/test-components/golem_it_http_tests_release.wasm and b/test-components/golem_it_http_tests_release.wasm differ diff --git a/test-components/golem_it_mcp_release.wasm b/test-components/golem_it_mcp_release.wasm index 965d8e7bf4..efbf31734c 100644 Binary files a/test-components/golem_it_mcp_release.wasm and b/test-components/golem_it_mcp_release.wasm differ diff --git a/test-components/host-api-tests/components-rust/golem-it-host-api-tests/src/invocation_context.rs b/test-components/host-api-tests/components-rust/golem-it-host-api-tests/src/invocation_context.rs index 1fbe196e38..0434ce5283 100644 --- a/test-components/host-api-tests/components-rust/golem-it-host-api-tests/src/invocation_context.rs +++ b/test-components/host-api-tests/components-rust/golem-it-host-api-tests/src/invocation_context.rs @@ -48,6 +48,58 @@ impl InvocationContext for InvocationContextImpl { } } +#[agent_definition] +pub trait InvocationContextError { + fn new(name: String) -> Self; + fn trigger_error(&self); +} + +pub struct InvocationContextErrorImpl { + _name: String, +} + +#[agent_implementation] +impl InvocationContextError for InvocationContextErrorImpl { + fn new(name: String) -> Self { + Self { _name: name } + } + + fn trigger_error(&self) { + let span = start_span("error-span"); + span.set_attribute("error-test", &AttributeValue::String("true".to_string())); + broadcast_current_invocation_context("error-before-panic"); + panic!("intentional error for OTLP test"); + } +} + +#[agent_definition] +pub trait InvocationContextRestart { + fn new(name: String) -> Self; + fn long_running(&mut self) -> u32; +} + +pub struct InvocationContextRestartImpl { + _name: String, + count: u32, +} + +#[agent_implementation] +impl InvocationContextRestart for InvocationContextRestartImpl { + fn new(name: String) -> Self { + Self { _name: name, count: 0 } + } + + fn long_running(&mut self) -> u32 { + self.count += 1; + let span = start_span("restart-span"); + span.set_attribute("invocation-count", &AttributeValue::String(self.count.to_string())); + broadcast_current_invocation_context("restart-before-sleep"); + std::thread::sleep(std::time::Duration::from_secs(10)); + broadcast_current_invocation_context("restart-after-sleep"); + self.count + } +} + fn broadcast_current_invocation_context(from: &str) { let ctx = current_context(); diff --git a/test-components/it_agent_counters_release.wasm b/test-components/it_agent_counters_release.wasm index a2611edf70..790dfba090 100644 Binary files a/test-components/it_agent_counters_release.wasm and b/test-components/it_agent_counters_release.wasm differ diff --git a/test-components/it_agent_update_release.wasm b/test-components/it_agent_update_release.wasm index 9e204f5b88..99c24ebf18 100644 Binary files a/test-components/it_agent_update_release.wasm and b/test-components/it_agent_update_release.wasm differ diff --git a/test-components/it_agent_update_v1_release.wasm b/test-components/it_agent_update_v1_release.wasm index db223b1e8a..5db5d7751d 100644 Binary files a/test-components/it_agent_update_v1_release.wasm and b/test-components/it_agent_update_v1_release.wasm differ diff --git a/test-components/it_agent_update_v2_release.wasm b/test-components/it_agent_update_v2_release.wasm index f5f025b4cd..ce9935fcaa 100644 Binary files a/test-components/it_agent_update_v2_release.wasm and b/test-components/it_agent_update_v2_release.wasm differ diff --git a/test-components/it_agent_update_v3_release.wasm b/test-components/it_agent_update_v3_release.wasm index 00e754ac21..c16e598e65 100644 Binary files a/test-components/it_agent_update_v3_release.wasm and b/test-components/it_agent_update_v3_release.wasm differ diff --git a/test-components/it_agent_update_v4_release.wasm b/test-components/it_agent_update_v4_release.wasm index 8f1c0c1389..d8a8c1cb93 100644 Binary files a/test-components/it_agent_update_v4_release.wasm and b/test-components/it_agent_update_v4_release.wasm differ diff --git a/test-components/it_initial_file_system_release.wasm b/test-components/it_initial_file_system_release.wasm index d8e3628364..a71bb0784d 100644 Binary files a/test-components/it_initial_file_system_release.wasm and b/test-components/it_initial_file_system_release.wasm differ diff --git a/test-components/oplog-processor/components-rust/oplog-processor/src/lib.rs b/test-components/oplog-processor/components-rust/oplog-processor/src/lib.rs index ff62478413..7b6a9e4529 100644 --- a/test-components/oplog-processor/components-rust/oplog-processor/src/lib.rs +++ b/test-components/oplog-processor/components-rust/oplog-processor/src/lib.rs @@ -92,10 +92,10 @@ impl OplogProcessorGuest for OplogProcessorComponent { .insert(format!("{worker_id:?}"), params.clone()); }); } else if let PublicOplogEntry::AgentInvocationFinished(_params) = entry { - if let Some(invocation) = + let function_name = if let Some(invocation) = CURRENT_INVOCATIONS.with(|ci| ci.borrow().get(&format!("{worker_id:?}")).cloned()) { - let function_name = match &invocation.invocation { + match &invocation.invocation { AgentInvocation::AgentInitialization(_) => { "agent-initialization".to_string() } @@ -108,17 +108,22 @@ impl OplogProcessorGuest for OplogProcessorComponent { "process-oplog-entries".to_string() } AgentInvocation::ManualUpdate(_) => "manual-update".to_string(), - }; - - invocations.push(InvocationRecord { - oplog_index: *oplog_index, - fn_name: function_name, - }); + } } else { + // AgentInvocationStarted was in a previous batch sent to a + // different plugin worker (e.g. shard reassignment / locality + // recovery spawned a new instance). Still record the invocation + // so we don't silently lose callbacks. println!( "AgentInvocationFinished without corresponding AgentInvocationStarted" - ) - } + ); + "unknown".to_string() + }; + + invocations.push(InvocationRecord { + oplog_index: *oplog_index, + fn_name: function_name, + }); } } diff --git a/test-components/oplog-processor/src/bindings.rs b/test-components/oplog-processor/src/bindings.rs deleted file mode 100644 index 6e40f4bad9..0000000000 --- a/test-components/oplog-processor/src/bindings.rs +++ /dev/null @@ -1,65229 +0,0 @@ -// Generated by `wit-bindgen` 0.41.0. DO NOT EDIT! -// Options used: -// * runtime_path: "wit_bindgen_rt" -// * generate_unused_types -#[rustfmt::skip] -#[allow(dead_code, clippy::all)] -pub mod golem { - pub mod api { - /// The Golem host API provides low level access to Golem specific features such as promises and control over - /// the durability and transactional guarantees the executor provides. - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod host { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - pub type Duration = super::super::super::wasi::clocks::monotonic_clock::Duration; - pub type ComponentId = super::super::super::golem::core::types::ComponentId; - pub type Uuid = super::super::super::golem::core::types::Uuid; - pub type ValueAndType = super::super::super::golem::core::types::ValueAndType; - pub type AgentId = super::super::super::golem::core::types::AgentId; - pub type PromiseId = super::super::super::golem::core::types::PromiseId; - pub type OplogIndex = super::super::super::golem::core::types::OplogIndex; - pub type Pollable = super::super::super::wasi::io::poll::Pollable; - /// Represents a Golem component's version - pub type ComponentRevision = u64; - /// Represents a Golem environment - #[repr(C)] - #[derive(Clone, Copy)] - pub struct EnvironmentId { - pub uuid: Uuid, - } - impl ::core::fmt::Debug for EnvironmentId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("EnvironmentId").field("uuid", &self.uuid).finish() - } - } - /// Configures how the executor retries failures - #[repr(C)] - #[derive(Clone, Copy)] - pub struct RetryPolicy { - /// The maximum number of retries before the agent becomes permanently failed - pub max_attempts: u32, - /// The minimum delay between retries (applied to the first retry) - pub min_delay: Duration, - /// The maximum delay between retries - pub max_delay: Duration, - /// Multiplier applied to the delay on each retry to implement exponential backoff - pub multiplier: f64, - /// The maximum amount of jitter to add to the delay - pub max_jitter_factor: Option, - } - impl ::core::fmt::Debug for RetryPolicy { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RetryPolicy") - .field("max-attempts", &self.max_attempts) - .field("min-delay", &self.min_delay) - .field("max-delay", &self.max_delay) - .field("multiplier", &self.multiplier) - .field("max-jitter-factor", &self.max_jitter_factor) - .finish() - } - } - /// Configurable persistence level for agents - #[derive(Clone, Copy)] - pub enum PersistenceLevel { - PersistNothing, - PersistRemoteSideEffects, - Smart, - } - impl ::core::fmt::Debug for PersistenceLevel { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - PersistenceLevel::PersistNothing => { - f.debug_tuple("PersistenceLevel::PersistNothing").finish() - } - PersistenceLevel::PersistRemoteSideEffects => { - f.debug_tuple("PersistenceLevel::PersistRemoteSideEffects") - .finish() - } - PersistenceLevel::Smart => { - f.debug_tuple("PersistenceLevel::Smart").finish() - } - } - } - } - /// Describes how to update an agent to a different component version - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum UpdateMode { - /// Automatic update tries to recover the agent using the new component version - /// and may fail if there is a divergence. - Automatic, - /// Manual, snapshot-based update uses a user-defined implementation of the `save-snapshot` interface - /// to store the agent's state, and a user-defined implementation of the `load-snapshot` interface to - /// load it into the new version. - SnapshotBased, - } - impl ::core::fmt::Debug for UpdateMode { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - UpdateMode::Automatic => { - f.debug_tuple("UpdateMode::Automatic").finish() - } - UpdateMode::SnapshotBased => { - f.debug_tuple("UpdateMode::SnapshotBased").finish() - } - } - } - } - impl UpdateMode { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> UpdateMode { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => UpdateMode::Automatic, - 1 => UpdateMode::SnapshotBased, - _ => panic!("invalid enum discriminant"), - } - } - } - /// Operators used in filtering enumerated agents - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum FilterComparator { - Equal, - NotEqual, - GreaterEqual, - Greater, - LessEqual, - Less, - } - impl ::core::fmt::Debug for FilterComparator { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - FilterComparator::Equal => { - f.debug_tuple("FilterComparator::Equal").finish() - } - FilterComparator::NotEqual => { - f.debug_tuple("FilterComparator::NotEqual").finish() - } - FilterComparator::GreaterEqual => { - f.debug_tuple("FilterComparator::GreaterEqual").finish() - } - FilterComparator::Greater => { - f.debug_tuple("FilterComparator::Greater").finish() - } - FilterComparator::LessEqual => { - f.debug_tuple("FilterComparator::LessEqual").finish() - } - FilterComparator::Less => { - f.debug_tuple("FilterComparator::Less").finish() - } - } - } - } - impl FilterComparator { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> FilterComparator { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => FilterComparator::Equal, - 1 => FilterComparator::NotEqual, - 2 => FilterComparator::GreaterEqual, - 3 => FilterComparator::Greater, - 4 => FilterComparator::LessEqual, - 5 => FilterComparator::Less, - _ => panic!("invalid enum discriminant"), - } - } - } - /// Operators used on strings in filtering enumerated agents - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum StringFilterComparator { - Equal, - NotEqual, - Like, - NotLike, - StartsWith, - } - impl ::core::fmt::Debug for StringFilterComparator { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - StringFilterComparator::Equal => { - f.debug_tuple("StringFilterComparator::Equal").finish() - } - StringFilterComparator::NotEqual => { - f.debug_tuple("StringFilterComparator::NotEqual").finish() - } - StringFilterComparator::Like => { - f.debug_tuple("StringFilterComparator::Like").finish() - } - StringFilterComparator::NotLike => { - f.debug_tuple("StringFilterComparator::NotLike").finish() - } - StringFilterComparator::StartsWith => { - f.debug_tuple("StringFilterComparator::StartsWith").finish() - } - } - } - } - impl StringFilterComparator { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> StringFilterComparator { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => StringFilterComparator::Equal, - 1 => StringFilterComparator::NotEqual, - 2 => StringFilterComparator::Like, - 3 => StringFilterComparator::NotLike, - 4 => StringFilterComparator::StartsWith, - _ => panic!("invalid enum discriminant"), - } - } - } - /// The current status of an agent - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum AgentStatus { - /// The agent is running an invoked function - Running, - /// The agent is ready to run an invoked function - Idle, - /// An invocation is active but waiting for something (sleeping, waiting for a promise) - Suspended, - /// The last invocation was interrupted but will be resumed - Interrupted, - /// The last invocation failed and a retry was scheduled - Retrying, - /// The last invocation failed and the agent can no longer be used - Failed, - /// The agent exited after a successful invocation and can no longer be invoked - Exited, - } - impl ::core::fmt::Debug for AgentStatus { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - AgentStatus::Running => { - f.debug_tuple("AgentStatus::Running").finish() - } - AgentStatus::Idle => f.debug_tuple("AgentStatus::Idle").finish(), - AgentStatus::Suspended => { - f.debug_tuple("AgentStatus::Suspended").finish() - } - AgentStatus::Interrupted => { - f.debug_tuple("AgentStatus::Interrupted").finish() - } - AgentStatus::Retrying => { - f.debug_tuple("AgentStatus::Retrying").finish() - } - AgentStatus::Failed => { - f.debug_tuple("AgentStatus::Failed").finish() - } - AgentStatus::Exited => { - f.debug_tuple("AgentStatus::Exited").finish() - } - } - } - } - impl AgentStatus { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> AgentStatus { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => AgentStatus::Running, - 1 => AgentStatus::Idle, - 2 => AgentStatus::Suspended, - 3 => AgentStatus::Interrupted, - 4 => AgentStatus::Retrying, - 5 => AgentStatus::Failed, - 6 => AgentStatus::Exited, - _ => panic!("invalid enum discriminant"), - } - } - } - /// Describes a filter condition on agent IDs when enumerating agents - #[derive(Clone)] - pub struct AgentNameFilter { - pub comparator: StringFilterComparator, - pub value: _rt::String, - } - impl ::core::fmt::Debug for AgentNameFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentNameFilter") - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes a filter condition on the agent status when enumerating agents - #[repr(C)] - #[derive(Clone, Copy)] - pub struct AgentStatusFilter { - pub comparator: FilterComparator, - pub value: AgentStatus, - } - impl ::core::fmt::Debug for AgentStatusFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentStatusFilter") - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes a filter condition on the component version when enumerating agents - #[repr(C)] - #[derive(Clone, Copy)] - pub struct AgentVersionFilter { - pub comparator: FilterComparator, - pub value: u64, - } - impl ::core::fmt::Debug for AgentVersionFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentVersionFilter") - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes a filter condition on the agent's creation time when enumerating agents - #[repr(C)] - #[derive(Clone, Copy)] - pub struct AgentCreatedAtFilter { - pub comparator: FilterComparator, - pub value: u64, - } - impl ::core::fmt::Debug for AgentCreatedAtFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentCreatedAtFilter") - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes a filter condition on the agent's environment variables when enumerating agents - #[derive(Clone)] - pub struct AgentEnvFilter { - pub name: _rt::String, - pub comparator: StringFilterComparator, - pub value: _rt::String, - } - impl ::core::fmt::Debug for AgentEnvFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentEnvFilter") - .field("name", &self.name) - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes a filter condition on the agent's configuration variables when enumerating agents - #[derive(Clone)] - pub struct AgentConfigVarsFilter { - pub name: _rt::String, - pub comparator: StringFilterComparator, - pub value: _rt::String, - } - impl ::core::fmt::Debug for AgentConfigVarsFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentConfigVarsFilter") - .field("name", &self.name) - .field("comparator", &self.comparator) - .field("value", &self.value) - .finish() - } - } - /// Describes one filter condition for enumerating agents - #[derive(Clone)] - pub enum AgentPropertyFilter { - Name(AgentNameFilter), - Status(AgentStatusFilter), - Version(AgentVersionFilter), - CreatedAt(AgentCreatedAtFilter), - Env(AgentEnvFilter), - WasiConfigVars(AgentConfigVarsFilter), - } - impl ::core::fmt::Debug for AgentPropertyFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - AgentPropertyFilter::Name(e) => { - f.debug_tuple("AgentPropertyFilter::Name").field(e).finish() - } - AgentPropertyFilter::Status(e) => { - f.debug_tuple("AgentPropertyFilter::Status") - .field(e) - .finish() - } - AgentPropertyFilter::Version(e) => { - f.debug_tuple("AgentPropertyFilter::Version") - .field(e) - .finish() - } - AgentPropertyFilter::CreatedAt(e) => { - f.debug_tuple("AgentPropertyFilter::CreatedAt") - .field(e) - .finish() - } - AgentPropertyFilter::Env(e) => { - f.debug_tuple("AgentPropertyFilter::Env").field(e).finish() - } - AgentPropertyFilter::WasiConfigVars(e) => { - f.debug_tuple("AgentPropertyFilter::WasiConfigVars") - .field(e) - .finish() - } - } - } - } - /// Combines multiple filter conditions with an `AND` relationship for enumerating agents - #[derive(Clone)] - pub struct AgentAllFilter { - pub filters: _rt::Vec, - } - impl ::core::fmt::Debug for AgentAllFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentAllFilter") - .field("filters", &self.filters) - .finish() - } - } - /// Combines multiple groups of filter conditions with an `OR` relationship for enumerating agents - #[derive(Clone)] - pub struct AgentAnyFilter { - pub filters: _rt::Vec, - } - impl ::core::fmt::Debug for AgentAnyFilter { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentAnyFilter") - .field("filters", &self.filters) - .finish() - } - } - /// Metadata about an agent - #[derive(Clone)] - pub struct AgentMetadata { - /// The agent ID, consists of the component ID, agent type and agent parameters - pub agent_id: AgentId, - /// Command line arguments seen by the agent - pub args: _rt::Vec<_rt::String>, - /// Environment variables seen by the agent - pub env: _rt::Vec<(_rt::String, _rt::String)>, - /// Configuration variables seen by the agent - pub config_vars: _rt::Vec<(_rt::String, _rt::String)>, - /// The current agent status - pub status: AgentStatus, - /// The component version the agent is running with - pub component_revision: u64, - /// The agent's current retry count - pub retry_count: u64, - /// The environment the agent belongs to - pub environment_id: EnvironmentId, - } - impl ::core::fmt::Debug for AgentMetadata { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentMetadata") - .field("agent-id", &self.agent_id) - .field("args", &self.args) - .field("env", &self.env) - .field("config-vars", &self.config_vars) - .field("status", &self.status) - .field("component-revision", &self.component_revision) - .field("retry-count", &self.retry_count) - .field("environment-id", &self.environment_id) - .finish() - } - } - /// Creates an agent enumeration - #[derive(Debug)] - #[repr(transparent)] - pub struct GetAgents { - handle: _rt::Resource, - } - impl GetAgents { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for GetAgents { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]get-agents"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - /// Target parameter for the `revert-agent` operation - #[derive(Clone, Copy)] - pub enum RevertAgentTarget { - /// Revert to a specific oplog index. The given index will be the last one to be kept. - RevertToOplogIndex(OplogIndex), - /// Revert the last N invocations. - RevertLastInvocations(u64), - } - impl ::core::fmt::Debug for RevertAgentTarget { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - RevertAgentTarget::RevertToOplogIndex(e) => { - f.debug_tuple("RevertAgentTarget::RevertToOplogIndex") - .field(e) - .finish() - } - RevertAgentTarget::RevertLastInvocations(e) => { - f.debug_tuple("RevertAgentTarget::RevertLastInvocations") - .field(e) - .finish() - } - } - } - } - /// Details about the fork result - #[repr(C)] - #[derive(Clone, Copy)] - pub struct ForkDetails { - pub forked_phantom_id: Uuid, - } - impl ::core::fmt::Debug for ForkDetails { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ForkDetails") - .field("forked-phantom-id", &self.forked_phantom_id) - .finish() - } - } - /// Indicates which agent the code is running on after `fork`. - /// The parameter contains details about the fork result, such as the phantom-ID of the newly - /// created agent. - #[derive(Clone, Copy)] - pub enum ForkResult { - /// The original agent that called `fork` - Original(ForkDetails), - /// The new agent - Forked(ForkDetails), - } - impl ::core::fmt::Debug for ForkResult { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - ForkResult::Original(e) => { - f.debug_tuple("ForkResult::Original").field(e).finish() - } - ForkResult::Forked(e) => { - f.debug_tuple("ForkResult::Forked").field(e).finish() - } - } - } - } - #[derive(Debug)] - #[repr(transparent)] - pub struct GetPromiseResult { - handle: _rt::Resource, - } - impl GetPromiseResult { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for GetPromiseResult { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]get-promise-result"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - /// Snapshot payload - #[derive(Clone)] - pub struct Snapshot { - pub data: _rt::Vec, - pub mime_type: _rt::String, - } - impl ::core::fmt::Debug for Snapshot { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Snapshot") - .field("data", &self.data) - .field("mime-type", &self.mime_type) - .finish() - } - } - impl GetAgents { - #[allow(unused_unsafe, clippy::all)] - /// Creates an agent enumeration request. It is going to enumerate all agents of all the agent types - /// defined in `component-id`, filtered by the conditions given by `filter`. If `precise` is true, - /// the server will calculate the most recent state of all the returned agents, otherwise the returned - /// metadata will be not guaranteed to be up-to-date. - pub fn new( - component_id: ComponentId, - filter: Option<&AgentAnyFilter>, - precise: bool, - ) -> Self { - unsafe { - let mut cleanup_list = _rt::Vec::new(); - let super::super::super::golem::core::types::ComponentId { - uuid: uuid0, - } = component_id; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits1, - low_bits: low_bits1, - } = uuid0; - let (result17_0, result17_1, result17_2) = match filter { - Some(e) => { - let AgentAnyFilter { filters: filters2 } = e; - let vec16 = filters2; - let len16 = vec16.len(); - let layout16 = _rt::alloc::Layout::from_size_align_unchecked( - vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result16 = if layout16.size() != 0 { - let ptr = _rt::alloc::alloc(layout16).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout16); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec16.into_iter().enumerate() { - let base = result16 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let AgentAllFilter { filters: filters3 } = e; - let vec15 = filters3; - let len15 = vec15.len(); - let layout15 = _rt::alloc::Layout::from_size_align_unchecked( - vec15.len() - * (16 + 4 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result15 = if layout15.size() != 0 { - let ptr = _rt::alloc::alloc(layout15).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout15); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec15.into_iter().enumerate() { - let base = result15 - .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); - { - match e { - AgentPropertyFilter::Name(e) => { - *base.add(0).cast::() = (0i32) as u8; - let AgentNameFilter { - comparator: comparator4, - value: value4, - } = e; - *base.add(8).cast::() = (comparator4.clone() as i32) - as u8; - let vec5 = value4; - let ptr5 = vec5.as_ptr().cast::(); - let len5 = vec5.len(); - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len5; - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr5.cast_mut(); - } - AgentPropertyFilter::Status(e) => { - *base.add(0).cast::() = (1i32) as u8; - let AgentStatusFilter { - comparator: comparator6, - value: value6, - } = e; - *base.add(8).cast::() = (comparator6.clone() as i32) - as u8; - *base.add(9).cast::() = (value6.clone() as i32) as u8; - } - AgentPropertyFilter::Version(e) => { - *base.add(0).cast::() = (2i32) as u8; - let AgentVersionFilter { - comparator: comparator7, - value: value7, - } = e; - *base.add(8).cast::() = (comparator7.clone() as i32) - as u8; - *base.add(16).cast::() = _rt::as_i64(value7); - } - AgentPropertyFilter::CreatedAt(e) => { - *base.add(0).cast::() = (3i32) as u8; - let AgentCreatedAtFilter { - comparator: comparator8, - value: value8, - } = e; - *base.add(8).cast::() = (comparator8.clone() as i32) - as u8; - *base.add(16).cast::() = _rt::as_i64(value8); - } - AgentPropertyFilter::Env(e) => { - *base.add(0).cast::() = (4i32) as u8; - let AgentEnvFilter { - name: name9, - comparator: comparator9, - value: value9, - } = e; - let vec10 = name9; - let ptr10 = vec10.as_ptr().cast::(); - let len10 = vec10.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len10; - *base.add(8).cast::<*mut u8>() = ptr10.cast_mut(); - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (comparator9.clone() as i32) as u8; - let vec11 = value9; - let ptr11 = vec11.as_ptr().cast::(); - let len11 = vec11.len(); - *base - .add(8 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len11; - *base - .add(8 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr11.cast_mut(); - } - AgentPropertyFilter::WasiConfigVars(e) => { - *base.add(0).cast::() = (5i32) as u8; - let AgentConfigVarsFilter { - name: name12, - comparator: comparator12, - value: value12, - } = e; - let vec13 = name12; - let ptr13 = vec13.as_ptr().cast::(); - let len13 = vec13.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len13; - *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (comparator12.clone() as i32) as u8; - let vec14 = value12; - let ptr14 = vec14.as_ptr().cast::(); - let len14 = vec14.len(); - *base - .add(8 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len14; - *base - .add(8 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr14.cast_mut(); - } - } - } - } - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len15; - *base.add(0).cast::<*mut u8>() = result15; - cleanup_list.extend_from_slice(&[(result15, layout15)]); - } - } - cleanup_list.extend_from_slice(&[(result16, layout16)]); - (1i32, result16, len16) - } - None => (0i32, ::core::ptr::null_mut(), 0usize), - }; - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[constructor]get-agents"] - fn wit_import18( - _: i64, - _: i64, - _: i32, - _: *mut u8, - _: usize, - _: i32, - ) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import18( - _: i64, - _: i64, - _: i32, - _: *mut u8, - _: usize, - _: i32, - ) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import18( - _rt::as_i64(high_bits1), - _rt::as_i64(low_bits1), - result17_0, - result17_1, - result17_2, - match &precise { - true => 1, - false => 0, - }, - ) - }; - for (ptr, layout) in cleanup_list { - if layout.size() != 0 { - _rt::alloc::dealloc(ptr.cast(), layout); - } - } - unsafe { GetAgents::from_handle(ret as u32) } - } - } - } - impl GetAgents { - #[allow(unused_unsafe, clippy::all)] - /// Retrieves the next batch of agent metadata. - pub fn get_next(&self) -> Option<_rt::Vec> { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]get-agents.get-next"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let result40 = match l2 { - 0 => None, - 1 => { - let e = { - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l4 = *ptr0 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base39 = l3; - let len39 = l4; - let mut result39 = _rt::Vec::with_capacity(len39); - for i in 0..len39 { - let base = base39 - .add(i * (56 + 8 * ::core::mem::size_of::<*const u8>())); - let e39 = { - let l5 = *base.add(0).cast::(); - let l6 = *base.add(8).cast::(); - let l7 = *base.add(16).cast::<*mut u8>(); - let l8 = *base - .add(16 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len9 = l8; - let bytes9 = _rt::Vec::from_raw_parts( - l7.cast(), - len9, - len9, - ); - let l10 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l11 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base15 = l10; - let len15 = l11; - let mut result15 = _rt::Vec::with_capacity(len15); - for i in 0..len15 { - let base = base15 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e15 = { - let l12 = *base.add(0).cast::<*mut u8>(); - let l13 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len14 = l13; - let bytes14 = _rt::Vec::from_raw_parts( - l12.cast(), - len14, - len14, - ); - _rt::string_lift(bytes14) - }; - result15.push(e15); - } - _rt::cabi_dealloc( - base15, - len15 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l16 = *base - .add(16 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l17 = *base - .add(16 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base24 = l16; - let len24 = l17; - let mut result24 = _rt::Vec::with_capacity(len24); - for i in 0..len24 { - let base = base24 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e24 = { - let l18 = *base.add(0).cast::<*mut u8>(); - let l19 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len20 = l19; - let bytes20 = _rt::Vec::from_raw_parts( - l18.cast(), - len20, - len20, - ); - let l21 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l22 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len23 = l22; - let bytes23 = _rt::Vec::from_raw_parts( - l21.cast(), - len23, - len23, - ); - (_rt::string_lift(bytes20), _rt::string_lift(bytes23)) - }; - result24.push(e24); - } - _rt::cabi_dealloc( - base24, - len24 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l25 = *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l26 = *base - .add(16 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base33 = l25; - let len33 = l26; - let mut result33 = _rt::Vec::with_capacity(len33); - for i in 0..len33 { - let base = base33 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e33 = { - let l27 = *base.add(0).cast::<*mut u8>(); - let l28 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len29 = l28; - let bytes29 = _rt::Vec::from_raw_parts( - l27.cast(), - len29, - len29, - ); - let l30 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l31 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len32 = l31; - let bytes32 = _rt::Vec::from_raw_parts( - l30.cast(), - len32, - len32, - ); - (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) - }; - result33.push(e33); - } - _rt::cabi_dealloc( - base33, - len33 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l34 = i32::from( - *base - .add(16 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l35 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l36 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l37 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l38 = *base - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - AgentMetadata { - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l5 as u64, - low_bits: l6 as u64, - }, - }, - agent_id: _rt::string_lift(bytes9), - }, - args: result15, - env: result24, - config_vars: result33, - status: AgentStatus::_lift(l34 as u8), - component_revision: l35 as u64, - retry_count: l36 as u64, - environment_id: EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l37 as u64, - low_bits: l38 as u64, - }, - }, - } - }; - result39.push(e39); - } - _rt::cabi_dealloc( - base39, - len39 * (56 + 8 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result39 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result40 - } - } - } - impl GetPromiseResult { - #[allow(unused_unsafe, clippy::all)] - /// Returns a pollable that can be used to wait for the promise to become ready.j - pub fn subscribe(&self) -> Pollable { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]get-promise-result.subscribe"] - fn wit_import0(_: i32) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0((self).handle() as i32) }; - unsafe { - super::super::super::wasi::io::poll::Pollable::from_handle( - ret as u32, - ) - } - } - } - } - impl GetPromiseResult { - #[allow(unused_unsafe, clippy::all)] - /// Poll the result of the promise, returning none if it is not yet ready. - pub fn get(&self) -> Option<_rt::Vec> { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]get-promise-result.get"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let result6 = match l2 { - 0 => None, - 1 => { - let e = { - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l4 = *ptr0 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len5 = l4; - _rt::Vec::from_raw_parts(l3.cast(), len5, len5) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result6 - } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Create a new promise - pub fn create_promise() -> PromiseId { - unsafe { - #[repr(align(8))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 24 + 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 24 - + 2 * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "create-promise"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let l4 = *ptr0.add(16).cast::<*mut u8>(); - let l5 = *ptr0 - .add(16 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); - let l7 = *ptr0 - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let result8 = super::super::super::golem::core::types::PromiseId { - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l2 as u64, - low_bits: l3 as u64, - }, - }, - agent_id: _rt::string_lift(bytes6), - }, - oplog_idx: l7 as u64, - }; - result8 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Gets a handle to the result of the promise. Can only be called in the same agent that orignally created the promise. - pub fn get_promise(promise_id: &PromiseId) -> GetPromiseResult { - unsafe { - let super::super::super::golem::core::types::PromiseId { - agent_id: agent_id0, - oplog_idx: oplog_idx0, - } = promise_id; - let super::super::super::golem::core::types::AgentId { - component_id: component_id1, - agent_id: agent_id1, - } = agent_id0; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid2, - } = component_id1; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits3, - low_bits: low_bits3, - } = uuid2; - let vec4 = agent_id1; - let ptr4 = vec4.as_ptr().cast::(); - let len4 = vec4.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-promise"] - fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import5( - _rt::as_i64(high_bits3), - _rt::as_i64(low_bits3), - ptr4.cast_mut(), - len4, - _rt::as_i64(oplog_idx0), - ) - }; - unsafe { GetPromiseResult::from_handle(ret as u32) } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Completes the given promise with the given payload. Returns true if the promise was completed, false - /// if the promise was already completed. The payload is passed to the agent that is awaiting the promise. - pub fn complete_promise(promise_id: &PromiseId, data: &[u8]) -> bool { - unsafe { - let super::super::super::golem::core::types::PromiseId { - agent_id: agent_id0, - oplog_idx: oplog_idx0, - } = promise_id; - let super::super::super::golem::core::types::AgentId { - component_id: component_id1, - agent_id: agent_id1, - } = agent_id0; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid2, - } = component_id1; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits3, - low_bits: low_bits3, - } = uuid2; - let vec4 = agent_id1; - let ptr4 = vec4.as_ptr().cast::(); - let len4 = vec4.len(); - let vec5 = data; - let ptr5 = vec5.as_ptr().cast::(); - let len5 = vec5.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "complete-promise"] - fn wit_import6( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: *mut u8, - _: usize, - ) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import6( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: *mut u8, - _: usize, - ) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import6( - _rt::as_i64(high_bits3), - _rt::as_i64(low_bits3), - ptr4.cast_mut(), - len4, - _rt::as_i64(oplog_idx0), - ptr5.cast_mut(), - len5, - ) - }; - _rt::bool_lift(ret as u8) - } - } - #[allow(unused_unsafe, clippy::all)] - /// Returns the current position in the persistent op log - pub fn get_oplog_index() -> OplogIndex { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-oplog-index"] - fn wit_import0() -> i64; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i64 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - ret as u64 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Makes the current agent travel back in time and continue execution from the given position in the persistent - /// op log. - pub fn set_oplog_index(oplog_idx: OplogIndex) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "set-oplog-index"] - fn wit_import0(_: i64); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i64) { - unreachable!() - } - unsafe { wit_import0(_rt::as_i64(oplog_idx)) }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Blocks the execution until the oplog has been written to at least the specified number of replicas, - /// or the maximum number of replicas if the requested number is higher. - pub fn oplog_commit(replicas: u8) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "oplog-commit"] - fn wit_import0(_: i32); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) { - unreachable!() - } - unsafe { wit_import0(_rt::as_i32(&replicas)) }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Marks the beginning of an atomic operation. - /// In case of a failure within the region selected by `mark-begin-operation` and `mark-end-operation` - /// the whole region will be reexecuted on retry. - /// The end of the region is when `mark-end-operation` is called with the returned oplog-index. - pub fn mark_begin_operation() -> OplogIndex { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "mark-begin-operation"] - fn wit_import0() -> i64; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i64 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - ret as u64 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Commits this atomic operation. After `mark-end-operation` is called for a given index, further calls - /// with the same parameter will do nothing. - pub fn mark_end_operation(begin: OplogIndex) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "mark-end-operation"] - fn wit_import0(_: i64); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i64) { - unreachable!() - } - unsafe { wit_import0(_rt::as_i64(begin)) }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Gets the current retry policy associated with the agent - pub fn get_retry_policy() -> RetryPolicy { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 48]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 48]); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-retry-policy"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let l4 = *ptr0.add(16).cast::(); - let l5 = *ptr0.add(24).cast::(); - let l6 = i32::from(*ptr0.add(32).cast::()); - let result8 = RetryPolicy { - max_attempts: l2 as u32, - min_delay: l3 as u64, - max_delay: l4 as u64, - multiplier: l5, - max_jitter_factor: match l6 { - 0 => None, - 1 => { - let e = { - let l7 = *ptr0.add(40).cast::(); - l7 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - }; - result8 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Overrides the current retry policy associated with the agent. Following this call, `get-retry-policy` will return the - /// new retry policy. - pub fn set_retry_policy(new_retry_policy: RetryPolicy) -> () { - unsafe { - let RetryPolicy { - max_attempts: max_attempts0, - min_delay: min_delay0, - max_delay: max_delay0, - multiplier: multiplier0, - max_jitter_factor: max_jitter_factor0, - } = new_retry_policy; - let (result1_0, result1_1) = match max_jitter_factor0 { - Some(e) => (1i32, _rt::as_f64(e)), - None => (0i32, 0.0f64), - }; - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "set-retry-policy"] - fn wit_import2(_: i32, _: i64, _: i64, _: f64, _: i32, _: f64); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2( - _: i32, - _: i64, - _: i64, - _: f64, - _: i32, - _: f64, - ) { - unreachable!() - } - unsafe { - wit_import2( - _rt::as_i32(max_attempts0), - _rt::as_i64(min_delay0), - _rt::as_i64(max_delay0), - _rt::as_f64(multiplier0), - result1_0, - result1_1, - ) - }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Gets the agent's current persistence level. - pub fn get_oplog_persistence_level() -> PersistenceLevel { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-oplog-persistence-level"] - fn wit_import0() -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - let v1 = match ret { - 0 => PersistenceLevel::PersistNothing, - 1 => PersistenceLevel::PersistRemoteSideEffects, - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - PersistenceLevel::Smart - } - }; - v1 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Sets the agent's current persistence level. This can increase the performance of execution in cases where durable - /// execution is not required. - pub fn set_oplog_persistence_level( - new_persistence_level: PersistenceLevel, - ) -> () { - unsafe { - let result0 = match new_persistence_level { - PersistenceLevel::PersistNothing => 0i32, - PersistenceLevel::PersistRemoteSideEffects => 1i32, - PersistenceLevel::Smart => 2i32, - }; - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "set-oplog-persistence-level"] - fn wit_import1(_: i32); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32) { - unreachable!() - } - unsafe { wit_import1(result0) }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Gets the current idempotence mode. See `set-idempotence-mode` for details. - pub fn get_idempotence_mode() -> bool { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-idempotence-mode"] - fn wit_import0() -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - _rt::bool_lift(ret as u8) - } - } - #[allow(unused_unsafe, clippy::all)] - /// Sets the current idempotence mode. The default is true. - /// True means side-effects are treated idempotent and Golem guarantees at-least-once semantics. - /// In case of false the executor provides at-most-once semantics, failing the agent in case it is - /// not known if the side effect was already executed. - pub fn set_idempotence_mode(idempotent: bool) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "set-idempotence-mode"] - fn wit_import0(_: i32); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) { - unreachable!() - } - unsafe { - wit_import0( - match &idempotent { - true => 1, - false => 0, - }, - ) - }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Generates an idempotency key. This operation will never be replayed — - /// i.e. not only is this key generated, but it is persisted and committed, such that the key can be used in third-party systems (e.g. payment processing) - /// to introduce idempotence. - pub fn generate_idempotency_key() -> Uuid { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 16]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 16]); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "generate-idempotency-key"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let result4 = super::super::super::golem::core::types::Uuid { - high_bits: l2 as u64, - low_bits: l3 as u64, - }; - result4 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Initiates an update attempt for the given agent. The function returns immediately once the request has been processed, - /// not waiting for the agent to get updated. - pub fn update_agent( - agent_id: &AgentId, - target_revision: ComponentRevision, - mode: UpdateMode, - ) -> () { - unsafe { - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "update-agent"] - fn wit_import4( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: i32, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import4( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: i32, - ) { - unreachable!() - } - unsafe { - wit_import4( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - _rt::as_i64(target_revision), - mode.clone() as i32, - ) - }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Get the current agent's metadata - pub fn get_self_metadata() -> AgentMetadata { - unsafe { - #[repr(align(8))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 56 + 8 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 56 - + 8 * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-self-metadata"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let l4 = *ptr0.add(16).cast::<*mut u8>(); - let l5 = *ptr0 - .add(16 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); - let l7 = *ptr0 - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l8 = *ptr0 - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base12 = l7; - let len12 = l8; - let mut result12 = _rt::Vec::with_capacity(len12); - for i in 0..len12 { - let base = base12 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e12 = { - let l9 = *base.add(0).cast::<*mut u8>(); - let l10 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len11 = l10; - let bytes11 = _rt::Vec::from_raw_parts( - l9.cast(), - len11, - len11, - ); - _rt::string_lift(bytes11) - }; - result12.push(e12); - } - _rt::cabi_dealloc( - base12, - len12 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l13 = *ptr0 - .add(16 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l14 = *ptr0 - .add(16 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base21 = l13; - let len21 = l14; - let mut result21 = _rt::Vec::with_capacity(len21); - for i in 0..len21 { - let base = base21 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e21 = { - let l15 = *base.add(0).cast::<*mut u8>(); - let l16 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len17 = l16; - let bytes17 = _rt::Vec::from_raw_parts( - l15.cast(), - len17, - len17, - ); - let l18 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l19 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len20 = l19; - let bytes20 = _rt::Vec::from_raw_parts( - l18.cast(), - len20, - len20, - ); - (_rt::string_lift(bytes17), _rt::string_lift(bytes20)) - }; - result21.push(e21); - } - _rt::cabi_dealloc( - base21, - len21 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l22 = *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l23 = *ptr0 - .add(16 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base30 = l22; - let len30 = l23; - let mut result30 = _rt::Vec::with_capacity(len30); - for i in 0..len30 { - let base = base30 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e30 = { - let l24 = *base.add(0).cast::<*mut u8>(); - let l25 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len26 = l25; - let bytes26 = _rt::Vec::from_raw_parts( - l24.cast(), - len26, - len26, - ); - let l27 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l28 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len29 = l28; - let bytes29 = _rt::Vec::from_raw_parts( - l27.cast(), - len29, - len29, - ); - (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) - }; - result30.push(e30); - } - _rt::cabi_dealloc( - base30, - len30 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l31 = i32::from( - *ptr0 - .add(16 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l32 = *ptr0 - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l33 = *ptr0 - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l34 = *ptr0 - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l35 = *ptr0 - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let result36 = AgentMetadata { - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l2 as u64, - low_bits: l3 as u64, - }, - }, - agent_id: _rt::string_lift(bytes6), - }, - args: result12, - env: result21, - config_vars: result30, - status: AgentStatus::_lift(l31 as u8), - component_revision: l32 as u64, - retry_count: l33 as u64, - environment_id: EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l34 as u64, - low_bits: l35 as u64, - }, - }, - }; - result36 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Get agent metadata - pub fn get_agent_metadata(agent_id: &AgentId) -> Option { - unsafe { - #[repr(align(8))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 64 + 8 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 64 - + 8 * ::core::mem::size_of::<*const u8>()], - ); - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - let ptr4 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "get-agent-metadata"] - fn wit_import5(_: i64, _: i64, _: *mut u8, _: usize, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import5( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - ptr4, - ) - }; - let l6 = i32::from(*ptr4.add(0).cast::()); - let result41 = match l6 { - 0 => None, - 1 => { - let e = { - let l7 = *ptr4.add(8).cast::(); - let l8 = *ptr4.add(16).cast::(); - let l9 = *ptr4.add(24).cast::<*mut u8>(); - let l10 = *ptr4 - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len11 = l10; - let bytes11 = _rt::Vec::from_raw_parts( - l9.cast(), - len11, - len11, - ); - let l12 = *ptr4 - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l13 = *ptr4 - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base17 = l12; - let len17 = l13; - let mut result17 = _rt::Vec::with_capacity(len17); - for i in 0..len17 { - let base = base17 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e17 = { - let l14 = *base.add(0).cast::<*mut u8>(); - let l15 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len16 = l15; - let bytes16 = _rt::Vec::from_raw_parts( - l14.cast(), - len16, - len16, - ); - _rt::string_lift(bytes16) - }; - result17.push(e17); - } - _rt::cabi_dealloc( - base17, - len17 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l18 = *ptr4 - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l19 = *ptr4 - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base26 = l18; - let len26 = l19; - let mut result26 = _rt::Vec::with_capacity(len26); - for i in 0..len26 { - let base = base26 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e26 = { - let l20 = *base.add(0).cast::<*mut u8>(); - let l21 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len22 = l21; - let bytes22 = _rt::Vec::from_raw_parts( - l20.cast(), - len22, - len22, - ); - let l23 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l24 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len25 = l24; - let bytes25 = _rt::Vec::from_raw_parts( - l23.cast(), - len25, - len25, - ); - (_rt::string_lift(bytes22), _rt::string_lift(bytes25)) - }; - result26.push(e26); - } - _rt::cabi_dealloc( - base26, - len26 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l27 = *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l28 = *ptr4 - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base35 = l27; - let len35 = l28; - let mut result35 = _rt::Vec::with_capacity(len35); - for i in 0..len35 { - let base = base35 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e35 = { - let l29 = *base.add(0).cast::<*mut u8>(); - let l30 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len31 = l30; - let bytes31 = _rt::Vec::from_raw_parts( - l29.cast(), - len31, - len31, - ); - let l32 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l33 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len34 = l33; - let bytes34 = _rt::Vec::from_raw_parts( - l32.cast(), - len34, - len34, - ); - (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) - }; - result35.push(e35); - } - _rt::cabi_dealloc( - base35, - len35 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l36 = i32::from( - *ptr4 - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l37 = *ptr4 - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l38 = *ptr4 - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l39 = *ptr4 - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l40 = *ptr4 - .add(56 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - AgentMetadata { - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l7 as u64, - low_bits: l8 as u64, - }, - }, - agent_id: _rt::string_lift(bytes11), - }, - args: result17, - env: result26, - config_vars: result35, - status: AgentStatus::_lift(l36 as u8), - component_revision: l37 as u64, - retry_count: l38 as u64, - environment_id: EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l39 as u64, - low_bits: l40 as u64, - }, - }, - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result41 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Fork an agent to another agent at a given oplog index - pub fn fork_agent( - source_agent_id: &AgentId, - target_agent_id: &AgentId, - oplog_idx_cut_off: OplogIndex, - ) -> () { - unsafe { - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = source_agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - let super::super::super::golem::core::types::AgentId { - component_id: component_id4, - agent_id: agent_id4, - } = target_agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid5, - } = component_id4; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits6, - low_bits: low_bits6, - } = uuid5; - let vec7 = agent_id4; - let ptr7 = vec7.as_ptr().cast::(); - let len7 = vec7.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "fork-agent"] - fn wit_import8( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import8( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ) { - unreachable!() - } - unsafe { - wit_import8( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - _rt::as_i64(high_bits6), - _rt::as_i64(low_bits6), - ptr7.cast_mut(), - len7, - _rt::as_i64(oplog_idx_cut_off), - ) - }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Revert an agent to a previous state - pub fn revert_agent( - agent_id: &AgentId, - revert_target: RevertAgentTarget, - ) -> () { - unsafe { - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - let (result4_0, result4_1) = match revert_target { - RevertAgentTarget::RevertToOplogIndex(e) => { - (0i32, _rt::as_i64(e)) - } - RevertAgentTarget::RevertLastInvocations(e) => { - (1i32, _rt::as_i64(e)) - } - }; - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "revert-agent"] - fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i32, - _: i64, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i32, - _: i64, - ) { - unreachable!() - } - unsafe { - wit_import5( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - result4_0, - result4_1, - ) - }; - } - } - #[allow(unused_unsafe, clippy::all)] - /// Get the component-id for a given component reference. - /// Returns none when no component with the specified reference exists. - /// The syntax of the component reference is implementation dependent. - /// - /// Golem OSS: "{component_name}" - /// Golem Cloud: - /// 1: "{component_name}" -> will resolve in current account and project - /// 2: "{project_name}/{component_name}" -> will resolve in current account - /// 3: "{account_id}/{project_name}/{component_name}" - pub fn resolve_component_id( - component_reference: &str, - ) -> Option { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 24]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); - let vec0 = component_reference; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "resolve-component-id"] - fn wit_import2(_: *mut u8, _: usize, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8) { - unreachable!() - } - unsafe { wit_import2(ptr0.cast_mut(), len0, ptr1) }; - let l3 = i32::from(*ptr1.add(0).cast::()); - let result6 = match l3 { - 0 => None, - 1 => { - let e = { - let l4 = *ptr1.add(8).cast::(); - let l5 = *ptr1.add(16).cast::(); - super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l4 as u64, - low_bits: l5 as u64, - }, - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result6 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Get the agent-id for a given component and agent name. - /// Returns none when no component for the specified reference exists. - pub fn resolve_agent_id( - component_reference: &str, - agent_name: &str, - ) -> Option { - unsafe { - #[repr(align(8))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 24 + 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 24 - + 2 * ::core::mem::size_of::<*const u8>()], - ); - let vec0 = component_reference; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let vec1 = agent_name; - let ptr1 = vec1.as_ptr().cast::(); - let len1 = vec1.len(); - let ptr2 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "resolve-agent-id"] - fn wit_import3( - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: *mut u8, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import3( - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import3(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2) - }; - let l4 = i32::from(*ptr2.add(0).cast::()); - let result10 = match l4 { - 0 => None, - 1 => { - let e = { - let l5 = *ptr2.add(8).cast::(); - let l6 = *ptr2.add(16).cast::(); - let l7 = *ptr2.add(24).cast::<*mut u8>(); - let l8 = *ptr2 - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len9 = l8; - let bytes9 = _rt::Vec::from_raw_parts( - l7.cast(), - len9, - len9, - ); - super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l5 as u64, - low_bits: l6 as u64, - }, - }, - agent_id: _rt::string_lift(bytes9), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result10 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Get the agent-id for a given component and agent-name. - /// Returns none when no component for the specified component-reference or no agent with the specified agent-name exists. - pub fn resolve_agent_id_strict( - component_reference: &str, - agent_name: &str, - ) -> Option { - unsafe { - #[repr(align(8))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 24 + 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 24 - + 2 * ::core::mem::size_of::<*const u8>()], - ); - let vec0 = component_reference; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let vec1 = agent_name; - let ptr1 = vec1.as_ptr().cast::(); - let len1 = vec1.len(); - let ptr2 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "resolve-agent-id-strict"] - fn wit_import3( - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: *mut u8, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import3( - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import3(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2) - }; - let l4 = i32::from(*ptr2.add(0).cast::()); - let result10 = match l4 { - 0 => None, - 1 => { - let e = { - let l5 = *ptr2.add(8).cast::(); - let l6 = *ptr2.add(16).cast::(); - let l7 = *ptr2.add(24).cast::<*mut u8>(); - let l8 = *ptr2 - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len9 = l8; - let bytes9 = _rt::Vec::from_raw_parts( - l7.cast(), - len9, - len9, - ); - super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l5 as u64, - low_bits: l6 as u64, - }, - }, - agent_id: _rt::string_lift(bytes9), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result10 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Forks the current agent at the current execution point. The new agent gets the same base agent ID but - /// with a new unique phantom ID. The phantom ID of the forked agent is returned in `fork-result` on - /// both sides. The newly created agent continues running from the same point, but the return value is - /// going to be different in this agent and the forked agent. - pub fn fork() -> ForkResult { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 24]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/host@1.5.0")] - unsafe extern "C" { - #[link_name = "fork"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let v7 = match l2 { - 0 => { - let e7 = { - let l3 = *ptr0.add(8).cast::(); - let l4 = *ptr0.add(16).cast::(); - ForkDetails { - forked_phantom_id: super::super::super::golem::core::types::Uuid { - high_bits: l3 as u64, - low_bits: l4 as u64, - }, - } - }; - ForkResult::Original(e7) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e7 = { - let l5 = *ptr0.add(8).cast::(); - let l6 = *ptr0.add(16).cast::(); - ForkDetails { - forked_phantom_id: super::super::super::golem::core::types::Uuid { - high_bits: l5 as u64, - low_bits: l6 as u64, - }, - } - }; - ForkResult::Forked(e7) - } - }; - let result8 = v7; - result8 - } - } - } - /// Invocation context support - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod context { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime; - /// Represents a unit of work or operation - #[derive(Debug)] - #[repr(transparent)] - pub struct Span { - handle: _rt::Resource, - } - impl Span { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for Span { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]span"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - /// Represents an invocation context wich allows querying the stack of attributes - /// created by automatic and user-defined spans. - #[derive(Debug)] - #[repr(transparent)] - pub struct InvocationContext { - handle: _rt::Resource, - } - impl InvocationContext { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for InvocationContext { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]invocation-context"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - /// Possible span attribute value types - #[derive(Clone)] - pub enum AttributeValue { - /// A string value - String(_rt::String), - } - impl ::core::fmt::Debug for AttributeValue { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - AttributeValue::String(e) => { - f.debug_tuple("AttributeValue::String").field(e).finish() - } - } - } - } - /// An attribute of a span - #[derive(Clone)] - pub struct Attribute { - pub key: _rt::String, - pub value: AttributeValue, - } - impl ::core::fmt::Debug for Attribute { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Attribute") - .field("key", &self.key) - .field("value", &self.value) - .finish() - } - } - /// A chain of attribute values, the first element representing the most recent value - #[derive(Clone)] - pub struct AttributeChain { - pub key: _rt::String, - pub values: _rt::Vec, - } - impl ::core::fmt::Debug for AttributeChain { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AttributeChain") - .field("key", &self.key) - .field("values", &self.values) - .finish() - } - } - /// The trace represented by a 16 bytes hexadecimal string - pub type TraceId = _rt::String; - /// The span represented by a 8 bytes hexadecimal string - pub type SpanId = _rt::String; - #[allow(unused_unsafe, clippy::all)] - /// Starts a new `span` with the given name, as a child of the current invocation context - pub fn start_span(name: &str) -> Span { - unsafe { - let vec0 = name; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "start-span"] - fn wit_import1(_: *mut u8, _: usize) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8, _: usize) -> i32 { - unreachable!() - } - let ret = unsafe { wit_import1(ptr0.cast_mut(), len0) }; - unsafe { Span::from_handle(ret as u32) } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Gets the current invocation context - /// - /// The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not - /// reflect that. - pub fn current_context() -> InvocationContext { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "current-context"] - fn wit_import0() -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - unsafe { InvocationContext::from_handle(ret as u32) } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Allows or disallows forwarding of trace context headers in outgoing HTTP requests - /// - /// Returns the previous value of the setting - pub fn allow_forwarding_trace_context_headers(allow: bool) -> bool { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "allow-forwarding-trace-context-headers"] - fn wit_import0(_: i32) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import0( - match &allow { - true => 1, - false => 0, - }, - ) - }; - _rt::bool_lift(ret as u8) - } - } - impl Span { - #[allow(unused_unsafe, clippy::all)] - /// Gets the starting time of the span - pub fn started_at(&self) -> Datetime { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 16]); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 16], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]span.started-at"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let result4 = super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2 as u64, - nanoseconds: l3 as u32, - }; - result4 - } - } - } - impl Span { - #[allow(unused_unsafe, clippy::all)] - /// Set an attribute on the span - pub fn set_attribute(&self, name: &str, value: &AttributeValue) -> () { - unsafe { - let vec0 = name; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let (result2_0, result2_1, result2_2) = match value { - AttributeValue::String(e) => { - let vec1 = e; - let ptr1 = vec1.as_ptr().cast::(); - let len1 = vec1.len(); - (0i32, ptr1.cast_mut(), len1) - } - }; - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]span.set-attribute"] - fn wit_import3( - _: i32, - _: *mut u8, - _: usize, - _: i32, - _: *mut u8, - _: usize, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import3( - _: i32, - _: *mut u8, - _: usize, - _: i32, - _: *mut u8, - _: usize, - ) { - unreachable!() - } - unsafe { - wit_import3( - (self).handle() as i32, - ptr0.cast_mut(), - len0, - result2_0, - result2_1, - result2_2, - ) - }; - } - } - } - impl Span { - #[allow(unused_unsafe, clippy::all)] - /// Set multiple attributes on the span - pub fn set_attributes(&self, attributes: &[Attribute]) -> () { - unsafe { - let vec3 = attributes; - let len3 = vec3.len(); - let layout3 = _rt::alloc::Layout::from_size_align_unchecked( - vec3.len() * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result3 = if layout3.size() != 0 { - let ptr = _rt::alloc::alloc(layout3).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout3); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec3.into_iter().enumerate() { - let base = result3 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - { - let Attribute { key: key0, value: value0 } = e; - let vec1 = key0; - let ptr1 = vec1.as_ptr().cast::(); - let len1 = vec1.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len1; - *base.add(0).cast::<*mut u8>() = ptr1.cast_mut(); - match value0 { - AttributeValue::String(e) => { - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec2 = e; - let ptr2 = vec2.as_ptr().cast::(); - let len2 = vec2.len(); - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len2; - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr2.cast_mut(); - } - } - } - } - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]span.set-attributes"] - fn wit_import4(_: i32, _: *mut u8, _: usize); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import4(_: i32, _: *mut u8, _: usize) { - unreachable!() - } - unsafe { wit_import4((self).handle() as i32, result3, len3) }; - if layout3.size() != 0 { - _rt::alloc::dealloc(result3.cast(), layout3); - } - } - } - } - impl Span { - #[allow(unused_unsafe, clippy::all)] - /// Early finishes the span; otherwise it will be finished when the resource is dropped - pub fn finish(&self) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]span.finish"] - fn wit_import0(_: i32); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) { - unreachable!() - } - unsafe { wit_import0((self).handle() as i32) }; - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the current trace id - pub fn trace_id(&self) -> TraceId { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.trace-id"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = *ptr0.add(0).cast::<*mut u8>(); - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len4 = l3; - let bytes4 = _rt::Vec::from_raw_parts(l2.cast(), len4, len4); - let result5 = _rt::string_lift(bytes4); - result5 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the current span id - pub fn span_id(&self) -> SpanId { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.span-id"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = *ptr0.add(0).cast::<*mut u8>(); - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len4 = l3; - let bytes4 = _rt::Vec::from_raw_parts(l2.cast(), len4, len4); - let result5 = _rt::string_lift(bytes4); - result5 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the parent context, if any; allows recursive processing of the invocation context. - /// - /// Alternatively, the attribute query methods can return inherited values without having to - /// traverse the stack manually. - pub fn parent(&self) -> Option { - unsafe { - #[repr(align(4))] - struct RetArea([::core::mem::MaybeUninit; 8]); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 8], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.parent"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let result4 = match l2 { - 0 => None, - 1 => { - let e = { - let l3 = *ptr0.add(4).cast::(); - unsafe { InvocationContext::from_handle(l3 as u32) } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result4 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the value of an attribute `key`. If `inherited` is true, the value is searched in the stack of spans, - /// otherwise only in the current span. - pub fn get_attribute( - &self, - key: &str, - inherited: bool, - ) -> Option { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 4 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 4 - * ::core::mem::size_of::<*const u8>()], - ); - let vec0 = key; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.get-attribute"] - fn wit_import2( - _: i32, - _: *mut u8, - _: usize, - _: i32, - _: *mut u8, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2( - _: i32, - _: *mut u8, - _: usize, - _: i32, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import2( - (self).handle() as i32, - ptr0.cast_mut(), - len0, - match &inherited { - true => 1, - false => 0, - }, - ptr1, - ) - }; - let l3 = i32::from(*ptr1.add(0).cast::()); - let result9 = match l3 { - 0 => None, - 1 => { - let e = { - let l4 = i32::from( - *ptr1.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - let v8 = match l4 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e8 = { - let l5 = *ptr1 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l6 = *ptr1 - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len7 = l6; - let bytes7 = _rt::Vec::from_raw_parts( - l5.cast(), - len7, - len7, - ); - _rt::string_lift(bytes7) - }; - AttributeValue::String(e8) - } - }; - v8 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result9 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets all attributes of the current invocation context. If `inherited` is true, it returns the merged set of attributes, each - /// key associated with the latest value found in the stack of spans. - pub fn get_attributes(&self, inherited: bool) -> _rt::Vec { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.get-attributes"] - fn wit_import1(_: i32, _: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8) { - unreachable!() - } - unsafe { - wit_import1( - (self).handle() as i32, - match &inherited { - true => 1, - false => 0, - }, - ptr0, - ) - }; - let l2 = *ptr0.add(0).cast::<*mut u8>(); - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base12 = l2; - let len12 = l3; - let mut result12 = _rt::Vec::with_capacity(len12); - for i in 0..len12 { - let base = base12 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e12 = { - let l4 = *base.add(0).cast::<*mut u8>(); - let l5 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts( - l4.cast(), - len6, - len6, - ); - let l7 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let v11 = match l7 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e11 = { - let l8 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l9 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len10 = l9; - let bytes10 = _rt::Vec::from_raw_parts( - l8.cast(), - len10, - len10, - ); - _rt::string_lift(bytes10) - }; - AttributeValue::String(e11) - } - }; - Attribute { - key: _rt::string_lift(bytes6), - value: v11, - } - }; - result12.push(e12); - } - _rt::cabi_dealloc( - base12, - len12 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result13 = result12; - result13 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the chain of attribute values associated with the given `key`. If the key does not exist in any of the - /// spans in the invocation context, the list is empty. The chain's first element contains the most recent (innermost) value. - pub fn get_attribute_chain( - &self, - key: &str, - ) -> _rt::Vec { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let vec0 = key; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.get-attribute-chain"] - fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2( - _: i32, - _: *mut u8, - _: usize, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import2( - (self).handle() as i32, - ptr0.cast_mut(), - len0, - ptr1, - ) - }; - let l3 = *ptr1.add(0).cast::<*mut u8>(); - let l4 = *ptr1 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base10 = l3; - let len10 = l4; - let mut result10 = _rt::Vec::with_capacity(len10); - for i in 0..len10 { - let base = base10 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e10 = { - let l5 = i32::from(*base.add(0).cast::()); - let v9 = match l5 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e9 = { - let l6 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l7 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len8 = l7; - let bytes8 = _rt::Vec::from_raw_parts( - l6.cast(), - len8, - len8, - ); - _rt::string_lift(bytes8) - }; - AttributeValue::String(e9) - } - }; - v9 - }; - result10.push(e10); - } - _rt::cabi_dealloc( - base10, - len10 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result11 = result10; - result11 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets all values of all attributes of the current invocation context. - pub fn get_attribute_chains(&self) -> _rt::Vec { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.get-attribute-chains"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = *ptr0.add(0).cast::<*mut u8>(); - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base15 = l2; - let len15 = l3; - let mut result15 = _rt::Vec::with_capacity(len15); - for i in 0..len15 { - let base = base15 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e15 = { - let l4 = *base.add(0).cast::<*mut u8>(); - let l5 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts( - l4.cast(), - len6, - len6, - ); - let l7 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l8 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base14 = l7; - let len14 = l8; - let mut result14 = _rt::Vec::with_capacity(len14); - for i in 0..len14 { - let base = base14 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e14 = { - let l9 = i32::from(*base.add(0).cast::()); - let v13 = match l9 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e13 = { - let l10 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l11 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len12 = l11; - let bytes12 = _rt::Vec::from_raw_parts( - l10.cast(), - len12, - len12, - ); - _rt::string_lift(bytes12) - }; - AttributeValue::String(e13) - } - }; - v13 - }; - result14.push(e14); - } - _rt::cabi_dealloc( - base14, - len14 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AttributeChain { - key: _rt::string_lift(bytes6), - values: result14, - } - }; - result15.push(e15); - } - _rt::cabi_dealloc( - base15, - len15 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result16 = result15; - result16 - } - } - } - impl InvocationContext { - #[allow(unused_unsafe, clippy::all)] - /// Gets the W3C Trace Context headers associated with the current invocation context - pub fn trace_context_headers( - &self, - ) -> _rt::Vec<(_rt::String, _rt::String)> { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/context@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]invocation-context.trace-context-headers"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = *ptr0.add(0).cast::<*mut u8>(); - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base10 = l2; - let len10 = l3; - let mut result10 = _rt::Vec::with_capacity(len10); - for i in 0..len10 { - let base = base10 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e10 = { - let l4 = *base.add(0).cast::<*mut u8>(); - let l5 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts( - l4.cast(), - len6, - len6, - ); - let l7 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l8 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len9 = l8; - let bytes9 = _rt::Vec::from_raw_parts( - l7.cast(), - len9, - len9, - ); - (_rt::string_lift(bytes6), _rt::string_lift(bytes9)) - }; - result10.push(e10); - } - _rt::cabi_dealloc( - base10, - len10 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result11 = result10; - result11 - } - } - } - } - /// Host interface for enumerating and searching for agent oplogs - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod oplog { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime; - pub type ValueAndType = super::super::super::golem::core::types::ValueAndType; - pub type AccountId = super::super::super::golem::core::types::AccountId; - pub type DataValue = super::super::super::golem::core::types::DataValue; - pub type DataSchema = super::super::super::golem::core::types::DataSchema; - pub type WitValue = super::super::super::golem::core::types::WitValue; - pub type ComponentRevision = super::super::super::golem::api::host::ComponentRevision; - pub type OplogIndex = super::super::super::golem::api::host::OplogIndex; - pub type PersistenceLevel = super::super::super::golem::api::host::PersistenceLevel; - pub type EnvironmentId = super::super::super::golem::api::host::EnvironmentId; - pub type RetryPolicy = super::super::super::golem::api::host::RetryPolicy; - pub type Uuid = super::super::super::golem::api::host::Uuid; - pub type AgentId = super::super::super::golem::api::host::AgentId; - pub type Snapshot = super::super::super::golem::api::host::Snapshot; - pub type Attribute = super::super::super::golem::api::context::Attribute; - pub type AttributeValue = super::super::super::golem::api::context::AttributeValue; - pub type SpanId = super::super::super::golem::api::context::SpanId; - pub type TraceId = super::super::super::golem::api::context::TraceId; - #[derive(Clone, Copy)] - pub enum WrappedFunctionType { - /// The side-effect reads from the agent's local state (for example local file system, - /// random generator, etc.) - ReadLocal, - /// The side-effect writes to the agent's local state (for example local file system) - WriteLocal, - /// The side-effect reads from external state (for example a key-value store) - ReadRemote, - /// The side-effect manipulates external state (for example an RPC call) - WriteRemote, - /// The side-effect manipulates external state through multiple invoked functions (for example - /// a HTTP request where reading the response involves multiple host function calls) - /// - /// On the first invocation of the batch, the parameter should be `None` - this triggers - /// writing a `BeginRemoteWrite` entry in the oplog. Followup invocations should contain - /// this entry's index as the parameter. In batched remote writes it is the caller's responsibility - /// to manually write an `EndRemoteWrite` entry (using `end_function`) when the operation is completed. - WriteRemoteBatched(Option), - WriteRemoteTransaction(Option), - } - impl ::core::fmt::Debug for WrappedFunctionType { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - WrappedFunctionType::ReadLocal => { - f.debug_tuple("WrappedFunctionType::ReadLocal").finish() - } - WrappedFunctionType::WriteLocal => { - f.debug_tuple("WrappedFunctionType::WriteLocal").finish() - } - WrappedFunctionType::ReadRemote => { - f.debug_tuple("WrappedFunctionType::ReadRemote").finish() - } - WrappedFunctionType::WriteRemote => { - f.debug_tuple("WrappedFunctionType::WriteRemote").finish() - } - WrappedFunctionType::WriteRemoteBatched(e) => { - f.debug_tuple("WrappedFunctionType::WriteRemoteBatched") - .field(e) - .finish() - } - WrappedFunctionType::WriteRemoteTransaction(e) => { - f.debug_tuple("WrappedFunctionType::WriteRemoteTransaction") - .field(e) - .finish() - } - } - } - } - #[derive(Clone)] - pub struct PluginInstallationDescription { - pub name: _rt::String, - pub version: _rt::String, - pub parameters: _rt::Vec<(_rt::String, _rt::String)>, - } - impl ::core::fmt::Debug for PluginInstallationDescription { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("PluginInstallationDescription") - .field("name", &self.name) - .field("version", &self.version) - .field("parameters", &self.parameters) - .finish() - } - } - #[derive(Clone)] - pub struct RawLocalAgentConfigEntry { - pub path: _rt::Vec<_rt::String>, - pub value: WitValue, - } - impl ::core::fmt::Debug for RawLocalAgentConfigEntry { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawLocalAgentConfigEntry") - .field("path", &self.path) - .field("value", &self.value) - .finish() - } - } - #[derive(Clone)] - pub struct LocalAgentConfigEntry { - pub path: _rt::Vec<_rt::String>, - pub value: ValueAndType, - } - impl ::core::fmt::Debug for LocalAgentConfigEntry { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("LocalAgentConfigEntry") - .field("path", &self.path) - .field("value", &self.value) - .finish() - } - } - #[derive(Clone)] - pub struct CreateParameters { - pub timestamp: Datetime, - pub agent_id: AgentId, - pub component_revision: ComponentRevision, - pub args: _rt::Vec<_rt::String>, - pub env: _rt::Vec<(_rt::String, _rt::String)>, - pub created_by: AccountId, - pub environment_id: EnvironmentId, - pub parent: Option, - pub component_size: u64, - pub initial_total_linear_memory_size: u64, - pub initial_active_plugins: _rt::Vec, - pub config_vars: _rt::Vec<(_rt::String, _rt::String)>, - pub local_agent_config: _rt::Vec, - } - impl ::core::fmt::Debug for CreateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("CreateParameters") - .field("timestamp", &self.timestamp) - .field("agent-id", &self.agent_id) - .field("component-revision", &self.component_revision) - .field("args", &self.args) - .field("env", &self.env) - .field("created-by", &self.created_by) - .field("environment-id", &self.environment_id) - .field("parent", &self.parent) - .field("component-size", &self.component_size) - .field( - "initial-total-linear-memory-size", - &self.initial_total_linear_memory_size, - ) - .field("initial-active-plugins", &self.initial_active_plugins) - .field("config-vars", &self.config_vars) - .field("local-agent-config", &self.local_agent_config) - .finish() - } - } - #[derive(Clone)] - pub struct HostCallParameters { - pub timestamp: Datetime, - pub function_name: _rt::String, - pub request: ValueAndType, - pub response: ValueAndType, - pub wrapped_function_type: WrappedFunctionType, - } - impl ::core::fmt::Debug for HostCallParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("HostCallParameters") - .field("timestamp", &self.timestamp) - .field("function-name", &self.function_name) - .field("request", &self.request) - .field("response", &self.response) - .field("wrapped-function-type", &self.wrapped_function_type) - .finish() - } - } - #[derive(Clone)] - pub struct LocalSpanData { - pub span_id: SpanId, - pub start: Datetime, - pub parent: Option, - /// Optionally an index of the invocation-context field within agent-invocation - pub linked_context: Option, - pub attributes: _rt::Vec, - pub inherited: bool, - } - impl ::core::fmt::Debug for LocalSpanData { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("LocalSpanData") - .field("span-id", &self.span_id) - .field("start", &self.start) - .field("parent", &self.parent) - .field("linked-context", &self.linked_context) - .field("attributes", &self.attributes) - .field("inherited", &self.inherited) - .finish() - } - } - #[derive(Clone)] - pub struct ExternalSpanData { - pub span_id: SpanId, - } - impl ::core::fmt::Debug for ExternalSpanData { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ExternalSpanData") - .field("span-id", &self.span_id) - .finish() - } - } - #[derive(Clone)] - pub enum SpanData { - LocalSpan(LocalSpanData), - ExternalSpan(ExternalSpanData), - } - impl ::core::fmt::Debug for SpanData { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - SpanData::LocalSpan(e) => { - f.debug_tuple("SpanData::LocalSpan").field(e).finish() - } - SpanData::ExternalSpan(e) => { - f.debug_tuple("SpanData::ExternalSpan").field(e).finish() - } - } - } - } - #[derive(Clone)] - pub struct ErrorParameters { - pub timestamp: Datetime, - pub error: _rt::String, - pub retry_from: OplogIndex, - } - impl ::core::fmt::Debug for ErrorParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ErrorParameters") - .field("timestamp", &self.timestamp) - .field("error", &self.error) - .field("retry-from", &self.retry_from) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct OplogRegion { - pub start: OplogIndex, - pub end: OplogIndex, - } - impl ::core::fmt::Debug for OplogRegion { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("OplogRegion") - .field("start", &self.start) - .field("end", &self.end) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct JumpParameters { - pub timestamp: Datetime, - pub jump: OplogRegion, - } - impl ::core::fmt::Debug for JumpParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("JumpParameters") - .field("timestamp", &self.timestamp) - .field("jump", &self.jump) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct ChangeRetryPolicyParameters { - pub timestamp: Datetime, - pub new_policy: RetryPolicy, - } - impl ::core::fmt::Debug for ChangeRetryPolicyParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ChangeRetryPolicyParameters") - .field("timestamp", &self.timestamp) - .field("new-policy", &self.new_policy) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct EndAtomicRegionParameters { - pub timestamp: Datetime, - pub begin_index: OplogIndex, - } - impl ::core::fmt::Debug for EndAtomicRegionParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("EndAtomicRegionParameters") - .field("timestamp", &self.timestamp) - .field("begin-index", &self.begin_index) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct EndRemoteWriteParameters { - pub timestamp: Datetime, - pub begin_index: OplogIndex, - } - impl ::core::fmt::Debug for EndRemoteWriteParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("EndRemoteWriteParameters") - .field("timestamp", &self.timestamp) - .field("begin-index", &self.begin_index) - .finish() - } - } - #[derive(Clone)] - pub struct TypedDataValue { - pub value: DataValue, - pub schema: DataSchema, - } - impl ::core::fmt::Debug for TypedDataValue { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("TypedDataValue") - .field("value", &self.value) - .field("schema", &self.schema) - .finish() - } - } - #[derive(Clone)] - pub struct AgentInitializationParameters { - pub idempotency_key: _rt::String, - pub constructor_parameters: TypedDataValue, - pub trace_id: _rt::String, - pub trace_states: _rt::Vec<_rt::String>, - pub invocation_context: _rt::Vec<_rt::Vec>, - } - impl ::core::fmt::Debug for AgentInitializationParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentInitializationParameters") - .field("idempotency-key", &self.idempotency_key) - .field("constructor-parameters", &self.constructor_parameters) - .field("trace-id", &self.trace_id) - .field("trace-states", &self.trace_states) - .field("invocation-context", &self.invocation_context) - .finish() - } - } - #[derive(Clone)] - pub struct AgentMethodInvocationParameters { - pub idempotency_key: _rt::String, - pub method_name: _rt::String, - pub function_input: TypedDataValue, - pub trace_id: _rt::String, - pub trace_states: _rt::Vec<_rt::String>, - pub invocation_context: _rt::Vec<_rt::Vec>, - } - impl ::core::fmt::Debug for AgentMethodInvocationParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentMethodInvocationParameters") - .field("idempotency-key", &self.idempotency_key) - .field("method-name", &self.method_name) - .field("function-input", &self.function_input) - .field("trace-id", &self.trace_id) - .field("trace-states", &self.trace_states) - .field("invocation-context", &self.invocation_context) - .finish() - } - } - #[derive(Clone)] - pub struct LoadSnapshotParameters { - pub snapshot: Snapshot, - } - impl ::core::fmt::Debug for LoadSnapshotParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("LoadSnapshotParameters") - .field("snapshot", &self.snapshot) - .finish() - } - } - #[derive(Clone)] - pub struct ProcessOplogEntriesParameters { - pub idempotency_key: _rt::String, - } - impl ::core::fmt::Debug for ProcessOplogEntriesParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ProcessOplogEntriesParameters") - .field("idempotency-key", &self.idempotency_key) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct ManualUpdateParameters { - pub target_revision: ComponentRevision, - } - impl ::core::fmt::Debug for ManualUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ManualUpdateParameters") - .field("target-revision", &self.target_revision) - .finish() - } - } - #[derive(Clone)] - pub enum AgentInvocation { - AgentInitialization(AgentInitializationParameters), - AgentMethodInvocation(AgentMethodInvocationParameters), - SaveSnapshot, - LoadSnapshot(LoadSnapshotParameters), - ProcessOplogEntries(ProcessOplogEntriesParameters), - ManualUpdate(ManualUpdateParameters), - } - impl ::core::fmt::Debug for AgentInvocation { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - AgentInvocation::AgentInitialization(e) => { - f.debug_tuple("AgentInvocation::AgentInitialization") - .field(e) - .finish() - } - AgentInvocation::AgentMethodInvocation(e) => { - f.debug_tuple("AgentInvocation::AgentMethodInvocation") - .field(e) - .finish() - } - AgentInvocation::SaveSnapshot => { - f.debug_tuple("AgentInvocation::SaveSnapshot").finish() - } - AgentInvocation::LoadSnapshot(e) => { - f.debug_tuple("AgentInvocation::LoadSnapshot") - .field(e) - .finish() - } - AgentInvocation::ProcessOplogEntries(e) => { - f.debug_tuple("AgentInvocation::ProcessOplogEntries") - .field(e) - .finish() - } - AgentInvocation::ManualUpdate(e) => { - f.debug_tuple("AgentInvocation::ManualUpdate") - .field(e) - .finish() - } - } - } - } - #[derive(Clone)] - pub struct AgentInvocationStartedParameters { - pub timestamp: Datetime, - pub invocation: AgentInvocation, - } - impl ::core::fmt::Debug for AgentInvocationStartedParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentInvocationStartedParameters") - .field("timestamp", &self.timestamp) - .field("invocation", &self.invocation) - .finish() - } - } - #[derive(Clone)] - pub struct AgentInvocationOutputParameters { - pub output: TypedDataValue, - } - impl ::core::fmt::Debug for AgentInvocationOutputParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentInvocationOutputParameters") - .field("output", &self.output) - .finish() - } - } - #[derive(Clone)] - pub struct FallibleResultParameters { - pub error: Option<_rt::String>, - } - impl ::core::fmt::Debug for FallibleResultParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("FallibleResultParameters") - .field("error", &self.error) - .finish() - } - } - #[derive(Clone)] - pub struct SaveSnapshotResultParameters { - pub snapshot: Snapshot, - } - impl ::core::fmt::Debug for SaveSnapshotResultParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("SaveSnapshotResultParameters") - .field("snapshot", &self.snapshot) - .finish() - } - } - #[derive(Clone)] - pub enum AgentInvocationResult { - AgentInitialization(AgentInvocationOutputParameters), - AgentMethod(AgentInvocationOutputParameters), - ManualUpdate, - LoadSnapshot(FallibleResultParameters), - SaveSnapshot(SaveSnapshotResultParameters), - ProcessOplogEntries(FallibleResultParameters), - } - impl ::core::fmt::Debug for AgentInvocationResult { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - AgentInvocationResult::AgentInitialization(e) => { - f.debug_tuple("AgentInvocationResult::AgentInitialization") - .field(e) - .finish() - } - AgentInvocationResult::AgentMethod(e) => { - f.debug_tuple("AgentInvocationResult::AgentMethod") - .field(e) - .finish() - } - AgentInvocationResult::ManualUpdate => { - f.debug_tuple("AgentInvocationResult::ManualUpdate").finish() - } - AgentInvocationResult::LoadSnapshot(e) => { - f.debug_tuple("AgentInvocationResult::LoadSnapshot") - .field(e) - .finish() - } - AgentInvocationResult::SaveSnapshot(e) => { - f.debug_tuple("AgentInvocationResult::SaveSnapshot") - .field(e) - .finish() - } - AgentInvocationResult::ProcessOplogEntries(e) => { - f.debug_tuple("AgentInvocationResult::ProcessOplogEntries") - .field(e) - .finish() - } - } - } - } - #[derive(Clone)] - pub struct AgentInvocationFinishedParameters { - pub timestamp: Datetime, - pub invocation_result: AgentInvocationResult, - pub consumed_fuel: i64, - pub component_revision: u64, - } - impl ::core::fmt::Debug for AgentInvocationFinishedParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentInvocationFinishedParameters") - .field("timestamp", &self.timestamp) - .field("invocation-result", &self.invocation_result) - .field("consumed-fuel", &self.consumed_fuel) - .field("component-revision", &self.component_revision) - .finish() - } - } - #[derive(Clone)] - pub struct PendingAgentInvocationParameters { - pub timestamp: Datetime, - pub invocation: AgentInvocation, - } - impl ::core::fmt::Debug for PendingAgentInvocationParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("PendingAgentInvocationParameters") - .field("timestamp", &self.timestamp) - .field("invocation", &self.invocation) - .finish() - } - } - #[derive(Clone)] - pub enum UpdateDescription { - /// Automatic update by replaying the oplog on the new version - AutoUpdate, - /// Custom update by loading a given snapshot on the new version - SnapshotBased(Snapshot), - } - impl ::core::fmt::Debug for UpdateDescription { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - UpdateDescription::AutoUpdate => { - f.debug_tuple("UpdateDescription::AutoUpdate").finish() - } - UpdateDescription::SnapshotBased(e) => { - f.debug_tuple("UpdateDescription::SnapshotBased") - .field(e) - .finish() - } - } - } - } - #[derive(Clone)] - pub struct PendingUpdateParameters { - pub timestamp: Datetime, - pub target_revision: ComponentRevision, - pub update_description: UpdateDescription, - } - impl ::core::fmt::Debug for PendingUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("PendingUpdateParameters") - .field("timestamp", &self.timestamp) - .field("target-revision", &self.target_revision) - .field("update-description", &self.update_description) - .finish() - } - } - #[derive(Clone)] - pub struct SuccessfulUpdateParameters { - pub timestamp: Datetime, - pub target_revision: ComponentRevision, - pub new_component_size: u64, - pub new_active_plugins: _rt::Vec, - } - impl ::core::fmt::Debug for SuccessfulUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("SuccessfulUpdateParameters") - .field("timestamp", &self.timestamp) - .field("target-revision", &self.target_revision) - .field("new-component-size", &self.new_component_size) - .field("new-active-plugins", &self.new_active_plugins) - .finish() - } - } - #[derive(Clone)] - pub struct FailedUpdateParameters { - pub timestamp: Datetime, - pub target_revision: ComponentRevision, - pub details: Option<_rt::String>, - } - impl ::core::fmt::Debug for FailedUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("FailedUpdateParameters") - .field("timestamp", &self.timestamp) - .field("target-revision", &self.target_revision) - .field("details", &self.details) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct GrowMemoryParameters { - pub timestamp: Datetime, - pub delta: u64, - } - impl ::core::fmt::Debug for GrowMemoryParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("GrowMemoryParameters") - .field("timestamp", &self.timestamp) - .field("delta", &self.delta) - .finish() - } - } - pub type AgentResourceId = u64; - #[derive(Clone)] - pub struct CreateResourceParameters { - pub timestamp: Datetime, - pub resource_id: AgentResourceId, - pub name: _rt::String, - pub owner: _rt::String, - } - impl ::core::fmt::Debug for CreateResourceParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("CreateResourceParameters") - .field("timestamp", &self.timestamp) - .field("resource-id", &self.resource_id) - .field("name", &self.name) - .field("owner", &self.owner) - .finish() - } - } - #[derive(Clone)] - pub struct DropResourceParameters { - pub timestamp: Datetime, - pub resource_id: AgentResourceId, - pub name: _rt::String, - pub owner: _rt::String, - } - impl ::core::fmt::Debug for DropResourceParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("DropResourceParameters") - .field("timestamp", &self.timestamp) - .field("resource-id", &self.resource_id) - .field("name", &self.name) - .field("owner", &self.owner) - .finish() - } - } - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum LogLevel { - Stdout, - Stderr, - Trace, - Debug, - Info, - Warn, - Error, - Critical, - } - impl ::core::fmt::Debug for LogLevel { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - LogLevel::Stdout => f.debug_tuple("LogLevel::Stdout").finish(), - LogLevel::Stderr => f.debug_tuple("LogLevel::Stderr").finish(), - LogLevel::Trace => f.debug_tuple("LogLevel::Trace").finish(), - LogLevel::Debug => f.debug_tuple("LogLevel::Debug").finish(), - LogLevel::Info => f.debug_tuple("LogLevel::Info").finish(), - LogLevel::Warn => f.debug_tuple("LogLevel::Warn").finish(), - LogLevel::Error => f.debug_tuple("LogLevel::Error").finish(), - LogLevel::Critical => { - f.debug_tuple("LogLevel::Critical").finish() - } - } - } - } - impl LogLevel { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> LogLevel { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => LogLevel::Stdout, - 1 => LogLevel::Stderr, - 2 => LogLevel::Trace, - 3 => LogLevel::Debug, - 4 => LogLevel::Info, - 5 => LogLevel::Warn, - 6 => LogLevel::Error, - 7 => LogLevel::Critical, - _ => panic!("invalid enum discriminant"), - } - } - } - #[derive(Clone)] - pub struct LogParameters { - pub timestamp: Datetime, - pub level: LogLevel, - pub context: _rt::String, - pub message: _rt::String, - } - impl ::core::fmt::Debug for LogParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("LogParameters") - .field("timestamp", &self.timestamp) - .field("level", &self.level) - .field("context", &self.context) - .field("message", &self.message) - .finish() - } - } - #[derive(Clone)] - pub struct ActivatePluginParameters { - pub timestamp: Datetime, - pub plugin: PluginInstallationDescription, - } - impl ::core::fmt::Debug for ActivatePluginParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ActivatePluginParameters") - .field("timestamp", &self.timestamp) - .field("plugin", &self.plugin) - .finish() - } - } - #[derive(Clone)] - pub struct DeactivatePluginParameters { - pub timestamp: Datetime, - pub plugin: PluginInstallationDescription, - } - impl ::core::fmt::Debug for DeactivatePluginParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("DeactivatePluginParameters") - .field("timestamp", &self.timestamp) - .field("plugin", &self.plugin) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct RevertParameters { - pub timestamp: Datetime, - pub dropped_region: OplogRegion, - } - impl ::core::fmt::Debug for RevertParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RevertParameters") - .field("timestamp", &self.timestamp) - .field("dropped-region", &self.dropped_region) - .finish() - } - } - #[derive(Clone)] - pub struct CancelPendingInvocationParameters { - pub timestamp: Datetime, - pub idempotency_key: _rt::String, - } - impl ::core::fmt::Debug for CancelPendingInvocationParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("CancelPendingInvocationParameters") - .field("timestamp", &self.timestamp) - .field("idempotency-key", &self.idempotency_key) - .finish() - } - } - #[derive(Clone)] - pub struct StartSpanParameters { - pub timestamp: Datetime, - pub span_id: SpanId, - pub parent: Option, - pub linked_context_id: Option, - pub attributes: _rt::Vec, - } - impl ::core::fmt::Debug for StartSpanParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("StartSpanParameters") - .field("timestamp", &self.timestamp) - .field("span-id", &self.span_id) - .field("parent", &self.parent) - .field("linked-context-id", &self.linked_context_id) - .field("attributes", &self.attributes) - .finish() - } - } - #[derive(Clone)] - pub struct FinishSpanParameters { - pub timestamp: Datetime, - pub span_id: SpanId, - } - impl ::core::fmt::Debug for FinishSpanParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("FinishSpanParameters") - .field("timestamp", &self.timestamp) - .field("span-id", &self.span_id) - .finish() - } - } - #[derive(Clone)] - pub struct SetSpanAttributeParameters { - pub timestamp: Datetime, - pub span_id: SpanId, - pub key: _rt::String, - pub value: AttributeValue, - } - impl ::core::fmt::Debug for SetSpanAttributeParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("SetSpanAttributeParameters") - .field("timestamp", &self.timestamp) - .field("span-id", &self.span_id) - .field("key", &self.key) - .field("value", &self.value) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct ChangePersistenceLevelParameters { - pub timestamp: Datetime, - pub persistence_level: PersistenceLevel, - } - impl ::core::fmt::Debug for ChangePersistenceLevelParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ChangePersistenceLevelParameters") - .field("timestamp", &self.timestamp) - .field("persistence-level", &self.persistence_level) - .finish() - } - } - #[derive(Clone)] - pub struct BeginRemoteTransactionParameters { - pub timestamp: Datetime, - pub transaction_id: _rt::String, - } - impl ::core::fmt::Debug for BeginRemoteTransactionParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("BeginRemoteTransactionParameters") - .field("timestamp", &self.timestamp) - .field("transaction-id", &self.transaction_id) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct RemoteTransactionParameters { - pub timestamp: Datetime, - pub begin_index: OplogIndex, - } - impl ::core::fmt::Debug for RemoteTransactionParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RemoteTransactionParameters") - .field("timestamp", &self.timestamp) - .field("begin-index", &self.begin_index) - .finish() - } - } - #[derive(Clone)] - pub struct SnapshotParameters { - pub timestamp: Datetime, - pub data: _rt::Vec, - pub mime_type: _rt::String, - } - impl ::core::fmt::Debug for SnapshotParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("SnapshotParameters") - .field("timestamp", &self.timestamp) - .field("data", &self.data) - .field("mime-type", &self.mime_type) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct Timestamp { - pub timestamp: Datetime, - } - impl ::core::fmt::Debug for Timestamp { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Timestamp") - .field("timestamp", &self.timestamp) - .finish() - } - } - #[derive(Clone)] - pub struct OplogExternalPayload { - pub payload_id: Uuid, - pub md5_hash: _rt::Vec, - } - impl ::core::fmt::Debug for OplogExternalPayload { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("OplogExternalPayload") - .field("payload-id", &self.payload_id) - .field("md5-hash", &self.md5_hash) - .finish() - } - } - /// Opaque oplog payload, which can either be serialized inline or stored externally - #[derive(Clone)] - pub enum OplogPayload { - Inline(_rt::Vec), - External(OplogExternalPayload), - } - impl ::core::fmt::Debug for OplogPayload { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - OplogPayload::Inline(e) => { - f.debug_tuple("OplogPayload::Inline").field(e).finish() - } - OplogPayload::External(e) => { - f.debug_tuple("OplogPayload::External").field(e).finish() - } - } - } - } - /// Describes the error that occurred in the agent - #[derive(Clone)] - pub enum WorkerError { - Unknown(_rt::String), - InvalidRequest(_rt::String), - StackOverflow, - OutOfMemory, - ExceededMemoryLimit, - InternalError(_rt::String), - ExceededTableLimit, - } - impl ::core::fmt::Debug for WorkerError { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - WorkerError::Unknown(e) => { - f.debug_tuple("WorkerError::Unknown").field(e).finish() - } - WorkerError::InvalidRequest(e) => { - f.debug_tuple("WorkerError::InvalidRequest") - .field(e) - .finish() - } - WorkerError::StackOverflow => { - f.debug_tuple("WorkerError::StackOverflow").finish() - } - WorkerError::OutOfMemory => { - f.debug_tuple("WorkerError::OutOfMemory").finish() - } - WorkerError::ExceededMemoryLimit => { - f.debug_tuple("WorkerError::ExceededMemoryLimit").finish() - } - WorkerError::InternalError(e) => { - f.debug_tuple("WorkerError::InternalError").field(e).finish() - } - WorkerError::ExceededTableLimit => { - f.debug_tuple("WorkerError::ExceededTableLimit").finish() - } - } - } - } - #[derive(Clone)] - pub struct RawCreateParameters { - pub timestamp: Datetime, - pub agent_id: AgentId, - pub component_revision: ComponentRevision, - pub env: _rt::Vec<(_rt::String, _rt::String)>, - pub environment_id: EnvironmentId, - pub created_by: AccountId, - pub parent: Option, - pub component_size: u64, - pub initial_total_linear_memory_size: u64, - pub initial_active_plugins: _rt::Vec, - pub config_vars: _rt::Vec<(_rt::String, _rt::String)>, - pub local_agent_config: _rt::Vec, - pub original_phantom_id: Option, - } - impl ::core::fmt::Debug for RawCreateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawCreateParameters") - .field("timestamp", &self.timestamp) - .field("agent-id", &self.agent_id) - .field("component-revision", &self.component_revision) - .field("env", &self.env) - .field("environment-id", &self.environment_id) - .field("created-by", &self.created_by) - .field("parent", &self.parent) - .field("component-size", &self.component_size) - .field( - "initial-total-linear-memory-size", - &self.initial_total_linear_memory_size, - ) - .field("initial-active-plugins", &self.initial_active_plugins) - .field("config-vars", &self.config_vars) - .field("local-agent-config", &self.local_agent_config) - .field("original-phantom-id", &self.original_phantom_id) - .finish() - } - } - #[derive(Clone)] - pub struct RawHostCallParameters { - pub timestamp: Datetime, - pub function_name: _rt::String, - pub request: OplogPayload, - pub response: OplogPayload, - pub durable_function_type: WrappedFunctionType, - } - impl ::core::fmt::Debug for RawHostCallParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawHostCallParameters") - .field("timestamp", &self.timestamp) - .field("function-name", &self.function_name) - .field("request", &self.request) - .field("response", &self.response) - .field("durable-function-type", &self.durable_function_type) - .finish() - } - } - #[derive(Clone)] - pub struct RawAgentInvocationStartedParameters { - pub timestamp: Datetime, - pub idempotency_key: _rt::String, - pub payload: OplogPayload, - pub trace_id: _rt::String, - pub trace_states: _rt::Vec<_rt::String>, - pub invocation_context: _rt::Vec, - } - impl ::core::fmt::Debug for RawAgentInvocationStartedParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawAgentInvocationStartedParameters") - .field("timestamp", &self.timestamp) - .field("idempotency-key", &self.idempotency_key) - .field("payload", &self.payload) - .field("trace-id", &self.trace_id) - .field("trace-states", &self.trace_states) - .field("invocation-context", &self.invocation_context) - .finish() - } - } - #[derive(Clone)] - pub struct RawAgentInvocationFinishedParameters { - pub timestamp: Datetime, - pub result: OplogPayload, - pub consumed_fuel: i64, - pub component_revision: u64, - } - impl ::core::fmt::Debug for RawAgentInvocationFinishedParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawAgentInvocationFinishedParameters") - .field("timestamp", &self.timestamp) - .field("result", &self.result) - .field("consumed-fuel", &self.consumed_fuel) - .field("component-revision", &self.component_revision) - .finish() - } - } - #[derive(Clone)] - pub struct RawErrorParameters { - pub timestamp: Datetime, - pub error: WorkerError, - pub retry_from: OplogIndex, - } - impl ::core::fmt::Debug for RawErrorParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawErrorParameters") - .field("timestamp", &self.timestamp) - .field("error", &self.error) - .field("retry-from", &self.retry_from) - .finish() - } - } - #[derive(Clone)] - pub struct RawPendingAgentInvocationParameters { - pub timestamp: Datetime, - pub idempotency_key: _rt::String, - pub payload: OplogPayload, - pub trace_id: _rt::String, - pub trace_states: _rt::Vec<_rt::String>, - pub invocation_context: _rt::Vec, - } - impl ::core::fmt::Debug for RawPendingAgentInvocationParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawPendingAgentInvocationParameters") - .field("timestamp", &self.timestamp) - .field("idempotency-key", &self.idempotency_key) - .field("payload", &self.payload) - .field("trace-id", &self.trace_id) - .field("trace-states", &self.trace_states) - .field("invocation-context", &self.invocation_context) - .finish() - } - } - #[derive(Clone)] - pub struct RawSnapshotBasedUpdate { - pub target_revision: ComponentRevision, - pub payload: OplogPayload, - pub mime_type: _rt::String, - } - impl ::core::fmt::Debug for RawSnapshotBasedUpdate { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawSnapshotBasedUpdate") - .field("target-revision", &self.target_revision) - .field("payload", &self.payload) - .field("mime-type", &self.mime_type) - .finish() - } - } - /// Raw update description used in oplog entries - #[derive(Clone)] - pub enum RawUpdateDescription { - /// Automatic update by replaying the oplog on the new version - Automatic(ComponentRevision), - /// Custom update by loading a given snapshot on the new version - SnapshotBased(RawSnapshotBasedUpdate), - } - impl ::core::fmt::Debug for RawUpdateDescription { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - RawUpdateDescription::Automatic(e) => { - f.debug_tuple("RawUpdateDescription::Automatic") - .field(e) - .finish() - } - RawUpdateDescription::SnapshotBased(e) => { - f.debug_tuple("RawUpdateDescription::SnapshotBased") - .field(e) - .finish() - } - } - } - } - #[derive(Clone)] - pub struct RawPendingUpdateParameters { - pub timestamp: Datetime, - pub description: RawUpdateDescription, - } - impl ::core::fmt::Debug for RawPendingUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawPendingUpdateParameters") - .field("timestamp", &self.timestamp) - .field("description", &self.description) - .finish() - } - } - #[derive(Clone)] - pub struct RawSuccessfulUpdateParameters { - pub timestamp: Datetime, - pub target_revision: ComponentRevision, - pub new_component_size: u64, - pub new_active_plugins: _rt::Vec, - } - impl ::core::fmt::Debug for RawSuccessfulUpdateParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawSuccessfulUpdateParameters") - .field("timestamp", &self.timestamp) - .field("target-revision", &self.target_revision) - .field("new-component-size", &self.new_component_size) - .field("new-active-plugins", &self.new_active_plugins) - .finish() - } - } - #[derive(Clone)] - pub struct ResourceTypeId { - pub name: _rt::String, - pub owner: _rt::String, - } - impl ::core::fmt::Debug for ResourceTypeId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ResourceTypeId") - .field("name", &self.name) - .field("owner", &self.owner) - .finish() - } - } - #[derive(Clone)] - pub struct RawCreateResourceParameters { - pub timestamp: Datetime, - pub id: AgentResourceId, - pub resource_type_id: ResourceTypeId, - } - impl ::core::fmt::Debug for RawCreateResourceParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawCreateResourceParameters") - .field("timestamp", &self.timestamp) - .field("id", &self.id) - .field("resource-type-id", &self.resource_type_id) - .finish() - } - } - #[derive(Clone)] - pub struct RawDropResourceParameters { - pub timestamp: Datetime, - pub id: AgentResourceId, - pub resource_type_id: ResourceTypeId, - } - impl ::core::fmt::Debug for RawDropResourceParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawDropResourceParameters") - .field("timestamp", &self.timestamp) - .field("id", &self.id) - .field("resource-type-id", &self.resource_type_id) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct RawActivatePluginParameters { - pub timestamp: Datetime, - pub plugin_priority: i32, - } - impl ::core::fmt::Debug for RawActivatePluginParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawActivatePluginParameters") - .field("timestamp", &self.timestamp) - .field("plugin-priority", &self.plugin_priority) - .finish() - } - } - #[repr(C)] - #[derive(Clone, Copy)] - pub struct RawDeactivatePluginParameters { - pub timestamp: Datetime, - pub plugin_priority: i32, - } - impl ::core::fmt::Debug for RawDeactivatePluginParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawDeactivatePluginParameters") - .field("timestamp", &self.timestamp) - .field("plugin-priority", &self.plugin_priority) - .finish() - } - } - #[derive(Clone)] - pub struct RawBeginRemoteTransactionParameters { - pub timestamp: Datetime, - pub transaction_id: _rt::String, - pub original_begin_index: Option, - } - impl ::core::fmt::Debug for RawBeginRemoteTransactionParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawBeginRemoteTransactionParameters") - .field("timestamp", &self.timestamp) - .field("transaction-id", &self.transaction_id) - .field("original-begin-index", &self.original_begin_index) - .finish() - } - } - #[derive(Clone)] - pub struct RawSnapshotParameters { - pub timestamp: Datetime, - pub data: OplogPayload, - pub mime_type: _rt::String, - } - impl ::core::fmt::Debug for RawSnapshotParameters { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("RawSnapshotParameters") - .field("timestamp", &self.timestamp) - .field("data", &self.data) - .field("mime-type", &self.mime_type) - .finish() - } - } - #[derive(Clone)] - pub enum OplogEntry { - /// The initial agent oplog entry - Create(RawCreateParameters), - /// The agent invoked a host function - HostCall(RawHostCallParameters), - /// The agent has been invoked - AgentInvocationStarted(RawAgentInvocationStartedParameters), - /// The agent has completed an invocation - AgentInvocationFinished(RawAgentInvocationFinishedParameters), - /// Agent suspended - Suspend(Timestamp), - /// Agent failed - Error(RawErrorParameters), - /// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior - /// more predictable. - NoOp(Timestamp), - /// The agent needs to recover up to the given target oplog index and continue running from - /// the source oplog index from there - /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and - /// ignore all recorded operations in between. - Jump(JumpParameters), - /// Indicates that the agent has been interrupted at this point. - /// Only used to recompute the agent's (cached) status, has no effect on execution. - Interrupted(Timestamp), - /// Indicates that the agent has been exited using WASI's exit function. - Exited(Timestamp), - /// Overrides the agent's retry policy - ChangeRetryPolicy(ChangeRetryPolicyParameters), - /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during - /// recovery except if there is a corresponding `EndAtomicRegion` entry. - BeginAtomicRegion(Timestamp), - /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this - /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog - /// compaction. - EndAtomicRegion(EndAtomicRegionParameters), - /// Begins a remote write operation. Only used when idempotence mode is off. In this case each - /// remote write must be surrounded by a `BeginRemoteWrite` and `EndRemoteWrite` log pair and - /// unfinished remote writes cannot be recovered. - BeginRemoteWrite(Timestamp), - /// Marks the end of a remote write operation. Only used when idempotence mode is off. - EndRemoteWrite(EndRemoteWriteParameters), - /// An invocation request arrived while the agent was busy - PendingAgentInvocation(RawPendingAgentInvocationParameters), - /// An update request arrived and will be applied as soon the agent restarts - PendingUpdate(RawPendingUpdateParameters), - /// An update was successfully applied - SuccessfulUpdate(RawSuccessfulUpdateParameters), - /// An update failed to be applied - FailedUpdate(FailedUpdateParameters), - /// Increased total linear memory size - GrowMemory(GrowMemoryParameters), - /// Created a resource instance - CreateResource(RawCreateResourceParameters), - /// Dropped a resource instance - DropResource(RawDropResourceParameters), - /// The agent emitted a log message - Log(LogParameters), - /// The agent has been restarted, forgetting all its history - Restart(Timestamp), - /// Activates a plugin - ActivatePlugin(RawActivatePluginParameters), - /// Deactivates a plugin - DeactivatePlugin(RawDeactivatePluginParameters), - /// Revert an agent to a previous state - Revert(RevertParameters), - /// Cancel a pending invocation - CancelPendingInvocation(CancelPendingInvocationParameters), - /// Start a new span in the invocation context - StartSpan(StartSpanParameters), - /// Finish an open span in the invocation context - FinishSpan(FinishSpanParameters), - /// Set an attribute on an open span in the invocation context - SetSpanAttribute(SetSpanAttributeParameters), - /// Change the current persistence level - ChangePersistenceLevel(ChangePersistenceLevelParameters), - /// Begins a transaction operation - BeginRemoteTransaction(RawBeginRemoteTransactionParameters), - /// Pre-Commit of the transaction, indicating that the transaction will be committed - PreCommitRemoteTransaction(RemoteTransactionParameters), - /// Pre-Rollback of the transaction, indicating that the transaction will be rolled back - PreRollbackRemoteTransaction(RemoteTransactionParameters), - /// Committed transaction operation, indicating that the transaction was committed - CommittedRemoteTransaction(RemoteTransactionParameters), - /// Rolled back transaction operation, indicating that the transaction was rolled back - RolledBackRemoteTransaction(RemoteTransactionParameters), - /// A snapshot of the agent's state - Snapshot(RawSnapshotParameters), - } - impl ::core::fmt::Debug for OplogEntry { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - OplogEntry::Create(e) => { - f.debug_tuple("OplogEntry::Create").field(e).finish() - } - OplogEntry::HostCall(e) => { - f.debug_tuple("OplogEntry::HostCall").field(e).finish() - } - OplogEntry::AgentInvocationStarted(e) => { - f.debug_tuple("OplogEntry::AgentInvocationStarted") - .field(e) - .finish() - } - OplogEntry::AgentInvocationFinished(e) => { - f.debug_tuple("OplogEntry::AgentInvocationFinished") - .field(e) - .finish() - } - OplogEntry::Suspend(e) => { - f.debug_tuple("OplogEntry::Suspend").field(e).finish() - } - OplogEntry::Error(e) => { - f.debug_tuple("OplogEntry::Error").field(e).finish() - } - OplogEntry::NoOp(e) => { - f.debug_tuple("OplogEntry::NoOp").field(e).finish() - } - OplogEntry::Jump(e) => { - f.debug_tuple("OplogEntry::Jump").field(e).finish() - } - OplogEntry::Interrupted(e) => { - f.debug_tuple("OplogEntry::Interrupted").field(e).finish() - } - OplogEntry::Exited(e) => { - f.debug_tuple("OplogEntry::Exited").field(e).finish() - } - OplogEntry::ChangeRetryPolicy(e) => { - f.debug_tuple("OplogEntry::ChangeRetryPolicy") - .field(e) - .finish() - } - OplogEntry::BeginAtomicRegion(e) => { - f.debug_tuple("OplogEntry::BeginAtomicRegion") - .field(e) - .finish() - } - OplogEntry::EndAtomicRegion(e) => { - f.debug_tuple("OplogEntry::EndAtomicRegion") - .field(e) - .finish() - } - OplogEntry::BeginRemoteWrite(e) => { - f.debug_tuple("OplogEntry::BeginRemoteWrite") - .field(e) - .finish() - } - OplogEntry::EndRemoteWrite(e) => { - f.debug_tuple("OplogEntry::EndRemoteWrite").field(e).finish() - } - OplogEntry::PendingAgentInvocation(e) => { - f.debug_tuple("OplogEntry::PendingAgentInvocation") - .field(e) - .finish() - } - OplogEntry::PendingUpdate(e) => { - f.debug_tuple("OplogEntry::PendingUpdate").field(e).finish() - } - OplogEntry::SuccessfulUpdate(e) => { - f.debug_tuple("OplogEntry::SuccessfulUpdate") - .field(e) - .finish() - } - OplogEntry::FailedUpdate(e) => { - f.debug_tuple("OplogEntry::FailedUpdate").field(e).finish() - } - OplogEntry::GrowMemory(e) => { - f.debug_tuple("OplogEntry::GrowMemory").field(e).finish() - } - OplogEntry::CreateResource(e) => { - f.debug_tuple("OplogEntry::CreateResource").field(e).finish() - } - OplogEntry::DropResource(e) => { - f.debug_tuple("OplogEntry::DropResource").field(e).finish() - } - OplogEntry::Log(e) => { - f.debug_tuple("OplogEntry::Log").field(e).finish() - } - OplogEntry::Restart(e) => { - f.debug_tuple("OplogEntry::Restart").field(e).finish() - } - OplogEntry::ActivatePlugin(e) => { - f.debug_tuple("OplogEntry::ActivatePlugin").field(e).finish() - } - OplogEntry::DeactivatePlugin(e) => { - f.debug_tuple("OplogEntry::DeactivatePlugin") - .field(e) - .finish() - } - OplogEntry::Revert(e) => { - f.debug_tuple("OplogEntry::Revert").field(e).finish() - } - OplogEntry::CancelPendingInvocation(e) => { - f.debug_tuple("OplogEntry::CancelPendingInvocation") - .field(e) - .finish() - } - OplogEntry::StartSpan(e) => { - f.debug_tuple("OplogEntry::StartSpan").field(e).finish() - } - OplogEntry::FinishSpan(e) => { - f.debug_tuple("OplogEntry::FinishSpan").field(e).finish() - } - OplogEntry::SetSpanAttribute(e) => { - f.debug_tuple("OplogEntry::SetSpanAttribute") - .field(e) - .finish() - } - OplogEntry::ChangePersistenceLevel(e) => { - f.debug_tuple("OplogEntry::ChangePersistenceLevel") - .field(e) - .finish() - } - OplogEntry::BeginRemoteTransaction(e) => { - f.debug_tuple("OplogEntry::BeginRemoteTransaction") - .field(e) - .finish() - } - OplogEntry::PreCommitRemoteTransaction(e) => { - f.debug_tuple("OplogEntry::PreCommitRemoteTransaction") - .field(e) - .finish() - } - OplogEntry::PreRollbackRemoteTransaction(e) => { - f.debug_tuple("OplogEntry::PreRollbackRemoteTransaction") - .field(e) - .finish() - } - OplogEntry::CommittedRemoteTransaction(e) => { - f.debug_tuple("OplogEntry::CommittedRemoteTransaction") - .field(e) - .finish() - } - OplogEntry::RolledBackRemoteTransaction(e) => { - f.debug_tuple("OplogEntry::RolledBackRemoteTransaction") - .field(e) - .finish() - } - OplogEntry::Snapshot(e) => { - f.debug_tuple("OplogEntry::Snapshot").field(e).finish() - } - } - } - } - #[derive(Clone)] - pub enum PublicOplogEntry { - /// The initial agent oplog entry - Create(CreateParameters), - /// The agent invoked a host function - HostCall(HostCallParameters), - /// The agent has been invoked - AgentInvocationStarted(AgentInvocationStartedParameters), - /// The agent has completed an invocation - AgentInvocationFinished(AgentInvocationFinishedParameters), - /// Agent suspended - Suspend(Timestamp), - /// Agent failed - Error(ErrorParameters), - /// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior - /// more predictable. - NoOp(Timestamp), - /// The agent needs to recover up to the given target oplog index and continue running from - /// the source oplog index from there - /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and - /// ignore all recorded operations in between. - Jump(JumpParameters), - /// Indicates that the agent has been interrupted at this point. - /// Only used to recompute the agent's (cached) status, has no effect on execution. - Interrupted(Timestamp), - /// Indicates that the agent has been exited using WASI's exit function. - Exited(Timestamp), - /// Overrides the agent's retry policy - ChangeRetryPolicy(ChangeRetryPolicyParameters), - /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during - /// recovery except if there is a corresponding `EndAtomicRegion` entry. - BeginAtomicRegion(Timestamp), - /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this - /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog - /// compaction. - EndAtomicRegion(EndAtomicRegionParameters), - /// Begins a remote write operation. Only used when idempotence mode is off. In this case each - /// remote write must be surrounded by a `BeginRemoteWrite` and `EndRemoteWrite` log pair and - /// unfinished remote writes cannot be recovered. - BeginRemoteWrite(Timestamp), - /// Marks the end of a remote write operation. Only used when idempotence mode is off. - EndRemoteWrite(EndRemoteWriteParameters), - /// An invocation request arrived while the agent was busy - PendingAgentInvocation(PendingAgentInvocationParameters), - /// An update request arrived and will be applied as soon the agent restarts - PendingUpdate(PendingUpdateParameters), - /// An update was successfully applied - SuccessfulUpdate(SuccessfulUpdateParameters), - /// An update failed to be applied - FailedUpdate(FailedUpdateParameters), - /// Increased total linear memory size - GrowMemory(GrowMemoryParameters), - /// Created a resource instance - CreateResource(CreateResourceParameters), - /// Dropped a resource instance - DropResource(DropResourceParameters), - /// The agent emitted a log message - Log(LogParameters), - /// The agent's has been restarted, forgetting all its history - Restart(Timestamp), - /// Activates a plugin - ActivatePlugin(ActivatePluginParameters), - /// Deactivates a plugin - DeactivatePlugin(DeactivatePluginParameters), - /// Revert an agent to a previous state - Revert(RevertParameters), - /// Cancel a pending invocation - CancelPendingInvocation(CancelPendingInvocationParameters), - /// Start a new span in the invocation context - StartSpan(StartSpanParameters), - /// Finish an open span in the invocation context - FinishSpan(FinishSpanParameters), - /// Set an attribute on an open span in the invocation context - SetSpanAttribute(SetSpanAttributeParameters), - /// Change the current persistence level - ChangePersistenceLevel(ChangePersistenceLevelParameters), - /// Begins a transaction operation - BeginRemoteTransaction(BeginRemoteTransactionParameters), - /// Pre-Commit of the transaction, indicating that the transaction will be committed - PreCommitRemoteTransaction(RemoteTransactionParameters), - /// Pre-Rollback of the transaction, indicating that the transaction will be rolled back - PreRollbackRemoteTransaction(RemoteTransactionParameters), - /// Committed transaction operation, indicating that the transaction was committed - CommittedRemoteTransaction(RemoteTransactionParameters), - /// Rolled back transaction operation, indicating that the transaction was rolled back - RolledBackRemoteTransaction(RemoteTransactionParameters), - /// A snapshot of the worker's state - Snapshot(SnapshotParameters), - } - impl ::core::fmt::Debug for PublicOplogEntry { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - PublicOplogEntry::Create(e) => { - f.debug_tuple("PublicOplogEntry::Create").field(e).finish() - } - PublicOplogEntry::HostCall(e) => { - f.debug_tuple("PublicOplogEntry::HostCall").field(e).finish() - } - PublicOplogEntry::AgentInvocationStarted(e) => { - f.debug_tuple("PublicOplogEntry::AgentInvocationStarted") - .field(e) - .finish() - } - PublicOplogEntry::AgentInvocationFinished(e) => { - f.debug_tuple("PublicOplogEntry::AgentInvocationFinished") - .field(e) - .finish() - } - PublicOplogEntry::Suspend(e) => { - f.debug_tuple("PublicOplogEntry::Suspend").field(e).finish() - } - PublicOplogEntry::Error(e) => { - f.debug_tuple("PublicOplogEntry::Error").field(e).finish() - } - PublicOplogEntry::NoOp(e) => { - f.debug_tuple("PublicOplogEntry::NoOp").field(e).finish() - } - PublicOplogEntry::Jump(e) => { - f.debug_tuple("PublicOplogEntry::Jump").field(e).finish() - } - PublicOplogEntry::Interrupted(e) => { - f.debug_tuple("PublicOplogEntry::Interrupted") - .field(e) - .finish() - } - PublicOplogEntry::Exited(e) => { - f.debug_tuple("PublicOplogEntry::Exited").field(e).finish() - } - PublicOplogEntry::ChangeRetryPolicy(e) => { - f.debug_tuple("PublicOplogEntry::ChangeRetryPolicy") - .field(e) - .finish() - } - PublicOplogEntry::BeginAtomicRegion(e) => { - f.debug_tuple("PublicOplogEntry::BeginAtomicRegion") - .field(e) - .finish() - } - PublicOplogEntry::EndAtomicRegion(e) => { - f.debug_tuple("PublicOplogEntry::EndAtomicRegion") - .field(e) - .finish() - } - PublicOplogEntry::BeginRemoteWrite(e) => { - f.debug_tuple("PublicOplogEntry::BeginRemoteWrite") - .field(e) - .finish() - } - PublicOplogEntry::EndRemoteWrite(e) => { - f.debug_tuple("PublicOplogEntry::EndRemoteWrite") - .field(e) - .finish() - } - PublicOplogEntry::PendingAgentInvocation(e) => { - f.debug_tuple("PublicOplogEntry::PendingAgentInvocation") - .field(e) - .finish() - } - PublicOplogEntry::PendingUpdate(e) => { - f.debug_tuple("PublicOplogEntry::PendingUpdate") - .field(e) - .finish() - } - PublicOplogEntry::SuccessfulUpdate(e) => { - f.debug_tuple("PublicOplogEntry::SuccessfulUpdate") - .field(e) - .finish() - } - PublicOplogEntry::FailedUpdate(e) => { - f.debug_tuple("PublicOplogEntry::FailedUpdate") - .field(e) - .finish() - } - PublicOplogEntry::GrowMemory(e) => { - f.debug_tuple("PublicOplogEntry::GrowMemory") - .field(e) - .finish() - } - PublicOplogEntry::CreateResource(e) => { - f.debug_tuple("PublicOplogEntry::CreateResource") - .field(e) - .finish() - } - PublicOplogEntry::DropResource(e) => { - f.debug_tuple("PublicOplogEntry::DropResource") - .field(e) - .finish() - } - PublicOplogEntry::Log(e) => { - f.debug_tuple("PublicOplogEntry::Log").field(e).finish() - } - PublicOplogEntry::Restart(e) => { - f.debug_tuple("PublicOplogEntry::Restart").field(e).finish() - } - PublicOplogEntry::ActivatePlugin(e) => { - f.debug_tuple("PublicOplogEntry::ActivatePlugin") - .field(e) - .finish() - } - PublicOplogEntry::DeactivatePlugin(e) => { - f.debug_tuple("PublicOplogEntry::DeactivatePlugin") - .field(e) - .finish() - } - PublicOplogEntry::Revert(e) => { - f.debug_tuple("PublicOplogEntry::Revert").field(e).finish() - } - PublicOplogEntry::CancelPendingInvocation(e) => { - f.debug_tuple("PublicOplogEntry::CancelPendingInvocation") - .field(e) - .finish() - } - PublicOplogEntry::StartSpan(e) => { - f.debug_tuple("PublicOplogEntry::StartSpan") - .field(e) - .finish() - } - PublicOplogEntry::FinishSpan(e) => { - f.debug_tuple("PublicOplogEntry::FinishSpan") - .field(e) - .finish() - } - PublicOplogEntry::SetSpanAttribute(e) => { - f.debug_tuple("PublicOplogEntry::SetSpanAttribute") - .field(e) - .finish() - } - PublicOplogEntry::ChangePersistenceLevel(e) => { - f.debug_tuple("PublicOplogEntry::ChangePersistenceLevel") - .field(e) - .finish() - } - PublicOplogEntry::BeginRemoteTransaction(e) => { - f.debug_tuple("PublicOplogEntry::BeginRemoteTransaction") - .field(e) - .finish() - } - PublicOplogEntry::PreCommitRemoteTransaction(e) => { - f.debug_tuple("PublicOplogEntry::PreCommitRemoteTransaction") - .field(e) - .finish() - } - PublicOplogEntry::PreRollbackRemoteTransaction(e) => { - f.debug_tuple( - "PublicOplogEntry::PreRollbackRemoteTransaction", - ) - .field(e) - .finish() - } - PublicOplogEntry::CommittedRemoteTransaction(e) => { - f.debug_tuple("PublicOplogEntry::CommittedRemoteTransaction") - .field(e) - .finish() - } - PublicOplogEntry::RolledBackRemoteTransaction(e) => { - f.debug_tuple( - "PublicOplogEntry::RolledBackRemoteTransaction", - ) - .field(e) - .finish() - } - PublicOplogEntry::Snapshot(e) => { - f.debug_tuple("PublicOplogEntry::Snapshot").field(e).finish() - } - } - } - } - #[derive(Debug)] - #[repr(transparent)] - pub struct GetOplog { - handle: _rt::Resource, - } - impl GetOplog { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for GetOplog { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]get-oplog"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - #[derive(Debug)] - #[repr(transparent)] - pub struct SearchOplog { - handle: _rt::Resource, - } - impl SearchOplog { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for SearchOplog { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[resource-drop]search-oplog"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Enriches raw oplog entries into public oplog entries by resolving oplog payloads - /// and augmenting entries with component metadata. - pub fn enrich_oplog_entries( - environment_id: EnvironmentId, - agent_id: &AgentId, - entries: &[(OplogIndex, OplogEntry)], - component_revision: ComponentRevision, - ) -> Result<_rt::Vec, _rt::String> { - unsafe { - let mut cleanup_list = _rt::Vec::new(); - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - let super::super::super::golem::api::host::EnvironmentId { - uuid: uuid0, - } = environment_id; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits1, - low_bits: low_bits1, - } = uuid0; - let super::super::super::golem::core::types::AgentId { - component_id: component_id2, - agent_id: agent_id2, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid3, - } = component_id2; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits4, - low_bits: low_bits4, - } = uuid3; - let vec5 = agent_id2; - let ptr5 = vec5.as_ptr().cast::(); - let len5 = vec5.len(); - let vec217 = entries; - let len217 = vec217.len(); - let layout217 = _rt::alloc::Layout::from_size_align_unchecked( - vec217.len() * (152 + 12 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result217 = if layout217.size() != 0 { - let ptr = _rt::alloc::alloc(layout217).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout217); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec217.into_iter().enumerate() { - let base = result217 - .add(i * (152 + 12 * ::core::mem::size_of::<*const u8>())); - { - let (t6_0, t6_1) = e; - *base.add(0).cast::() = _rt::as_i64(t6_0); - match t6_1 { - OplogEntry::Create(e) => { - *base.add(8).cast::() = (0i32) as u8; - let RawCreateParameters { - timestamp: timestamp7, - agent_id: agent_id7, - component_revision: component_revision7, - env: env7, - environment_id: environment_id7, - created_by: created_by7, - parent: parent7, - component_size: component_size7, - initial_total_linear_memory_size: initial_total_linear_memory_size7, - initial_active_plugins: initial_active_plugins7, - config_vars: config_vars7, - local_agent_config: local_agent_config7, - original_phantom_id: original_phantom_id7, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds8, - nanoseconds: nanoseconds8, - } = timestamp7; - *base.add(16).cast::() = _rt::as_i64(seconds8); - *base.add(24).cast::() = _rt::as_i32(nanoseconds8); - let super::super::super::golem::core::types::AgentId { - component_id: component_id9, - agent_id: agent_id9, - } = agent_id7; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid10, - } = component_id9; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits11, - low_bits: low_bits11, - } = uuid10; - *base.add(32).cast::() = _rt::as_i64(high_bits11); - *base.add(40).cast::() = _rt::as_i64(low_bits11); - let vec12 = agent_id9; - let ptr12 = vec12.as_ptr().cast::(); - let len12 = vec12.len(); - *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(48).cast::<*mut u8>() = ptr12.cast_mut(); - *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(component_revision7); - let vec16 = env7; - let len16 = vec16.len(); - let layout16 = _rt::alloc::Layout::from_size_align_unchecked( - vec16.len() * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result16 = if layout16.size() != 0 { - let ptr = _rt::alloc::alloc(layout16).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout16); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec16.into_iter().enumerate() { - let base = result16 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - { - let (t13_0, t13_1) = e; - let vec14 = t13_0; - let ptr14 = vec14.as_ptr().cast::(); - let len14 = vec14.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len14; - *base.add(0).cast::<*mut u8>() = ptr14.cast_mut(); - let vec15 = t13_1; - let ptr15 = vec15.as_ptr().cast::(); - let len15 = vec15.len(); - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len15; - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr15.cast_mut(); - } - } - *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result16; - let super::super::super::golem::api::host::EnvironmentId { - uuid: uuid17, - } = environment_id7; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits18, - low_bits: low_bits18, - } = uuid17; - *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits18); - *base - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits18); - let super::super::super::golem::core::types::AccountId { - uuid: uuid19, - } = created_by7; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits20, - low_bits: low_bits20, - } = uuid19; - *base - .add(72 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits20); - *base - .add(80 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits20); - match parent7 { - Some(e) => { - *base - .add(88 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let super::super::super::golem::core::types::AgentId { - component_id: component_id21, - agent_id: agent_id21, - } = e; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid22, - } = component_id21; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits23, - low_bits: low_bits23, - } = uuid22; - *base - .add(96 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits23); - *base - .add(104 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits23); - let vec24 = agent_id21; - let ptr24 = vec24.as_ptr().cast::(); - let len24 = vec24.len(); - *base - .add(112 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; - *base - .add(112 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr24.cast_mut(); - } - None => { - *base - .add(88 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - *base - .add(112 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(component_size7); - *base - .add(120 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64( - initial_total_linear_memory_size7, - ); - let vec25 = initial_active_plugins7; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); - *base - .add(128 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; - *base - .add(128 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); - let vec29 = config_vars7; - let len29 = vec29.len(); - let layout29 = _rt::alloc::Layout::from_size_align_unchecked( - vec29.len() * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result29 = if layout29.size() != 0 { - let ptr = _rt::alloc::alloc(layout29).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout29); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec29.into_iter().enumerate() { - let base = result29 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - { - let (t26_0, t26_1) = e; - let vec27 = t26_0; - let ptr27 = vec27.as_ptr().cast::(); - let len27 = vec27.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len27; - *base.add(0).cast::<*mut u8>() = ptr27.cast_mut(); - let vec28 = t26_1; - let ptr28 = vec28.as_ptr().cast::(); - let len28 = vec28.len(); - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len28; - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr28.cast_mut(); - } - } - *base - .add(128 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::() = len29; - *base - .add(128 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result29; - let vec45 = local_agent_config7; - let len45 = vec45.len(); - let layout45 = _rt::alloc::Layout::from_size_align_unchecked( - vec45.len() * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result45 = if layout45.size() != 0 { - let ptr = _rt::alloc::alloc(layout45).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout45); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec45.into_iter().enumerate() { - let base = result45 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - { - let RawLocalAgentConfigEntry { - path: path30, - value: value30, - } = e; - let vec32 = path30; - let len32 = vec32.len(); - let layout32 = _rt::alloc::Layout::from_size_align_unchecked( - vec32.len() * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result32 = if layout32.size() != 0 { - let ptr = _rt::alloc::alloc(layout32).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout32); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec32.into_iter().enumerate() { - let base = result32 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let vec31 = e; - let ptr31 = vec31.as_ptr().cast::(); - let len31 = vec31.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len31; - *base.add(0).cast::<*mut u8>() = ptr31.cast_mut(); - } - } - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len32; - *base.add(0).cast::<*mut u8>() = result32; - let super::super::super::golem::core::types::WitValue { - nodes: nodes33, - } = value30; - let vec44 = nodes33; - let len44 = vec44.len(); - let layout44 = _rt::alloc::Layout::from_size_align_unchecked( - vec44.len() - * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result44 = if layout44.size() != 0 { - let ptr = _rt::alloc::alloc(layout44).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout44); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec44.into_iter().enumerate() { - let base = result44 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - { - use super::super::super::golem::core::types::WitNode as V43; - match e { - V43::RecordValue(e) => { - *base.add(0).cast::() = (0i32) as u8; - let vec34 = e; - let ptr34 = vec34.as_ptr().cast::(); - let len34 = vec34.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len34; - *base.add(8).cast::<*mut u8>() = ptr34.cast_mut(); - } - V43::VariantValue(e) => { - *base.add(0).cast::() = (1i32) as u8; - let (t35_0, t35_1) = e; - *base.add(8).cast::() = _rt::as_i32(t35_0); - match t35_1 { - Some(e) => { - *base.add(12).cast::() = (1i32) as u8; - *base.add(16).cast::() = _rt::as_i32(e); - } - None => { - *base.add(12).cast::() = (0i32) as u8; - } - }; - } - V43::EnumValue(e) => { - *base.add(0).cast::() = (2i32) as u8; - *base.add(8).cast::() = _rt::as_i32(e); - } - V43::FlagsValue(e) => { - *base.add(0).cast::() = (3i32) as u8; - let vec36 = e; - let len36 = vec36.len(); - let layout36 = _rt::alloc::Layout::from_size_align_unchecked( - vec36.len() * 1, - 1, - ); - let result36 = if layout36.size() != 0 { - let ptr = _rt::alloc::alloc(layout36).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout36); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec36.into_iter().enumerate() { - let base = result36.add(i * 1); - { - *base.add(0).cast::() = (match e { - true => 1, - false => 0, - }) as u8; - } - } - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len36; - *base.add(8).cast::<*mut u8>() = result36; - cleanup_list.extend_from_slice(&[(result36, layout36)]); - } - V43::TupleValue(e) => { - *base.add(0).cast::() = (4i32) as u8; - let vec37 = e; - let ptr37 = vec37.as_ptr().cast::(); - let len37 = vec37.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len37; - *base.add(8).cast::<*mut u8>() = ptr37.cast_mut(); - } - V43::ListValue(e) => { - *base.add(0).cast::() = (5i32) as u8; - let vec38 = e; - let ptr38 = vec38.as_ptr().cast::(); - let len38 = vec38.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len38; - *base.add(8).cast::<*mut u8>() = ptr38.cast_mut(); - } - V43::OptionValue(e) => { - *base.add(0).cast::() = (6i32) as u8; - match e { - Some(e) => { - *base.add(8).cast::() = (1i32) as u8; - *base.add(12).cast::() = _rt::as_i32(e); - } - None => { - *base.add(8).cast::() = (0i32) as u8; - } - }; - } - V43::ResultValue(e) => { - *base.add(0).cast::() = (7i32) as u8; - match e { - Ok(e) => { - *base.add(8).cast::() = (0i32) as u8; - match e { - Some(e) => { - *base.add(12).cast::() = (1i32) as u8; - *base.add(16).cast::() = _rt::as_i32(e); - } - None => { - *base.add(12).cast::() = (0i32) as u8; - } - }; - } - Err(e) => { - *base.add(8).cast::() = (1i32) as u8; - match e { - Some(e) => { - *base.add(12).cast::() = (1i32) as u8; - *base.add(16).cast::() = _rt::as_i32(e); - } - None => { - *base.add(12).cast::() = (0i32) as u8; - } - }; - } - }; - } - V43::PrimU8(e) => { - *base.add(0).cast::() = (8i32) as u8; - *base.add(8).cast::() = (_rt::as_i32(e)) as u8; - } - V43::PrimU16(e) => { - *base.add(0).cast::() = (9i32) as u8; - *base.add(8).cast::() = (_rt::as_i32(e)) as u16; - } - V43::PrimU32(e) => { - *base.add(0).cast::() = (10i32) as u8; - *base.add(8).cast::() = _rt::as_i32(e); - } - V43::PrimU64(e) => { - *base.add(0).cast::() = (11i32) as u8; - *base.add(8).cast::() = _rt::as_i64(e); - } - V43::PrimS8(e) => { - *base.add(0).cast::() = (12i32) as u8; - *base.add(8).cast::() = (_rt::as_i32(e)) as u8; - } - V43::PrimS16(e) => { - *base.add(0).cast::() = (13i32) as u8; - *base.add(8).cast::() = (_rt::as_i32(e)) as u16; - } - V43::PrimS32(e) => { - *base.add(0).cast::() = (14i32) as u8; - *base.add(8).cast::() = _rt::as_i32(e); - } - V43::PrimS64(e) => { - *base.add(0).cast::() = (15i32) as u8; - *base.add(8).cast::() = _rt::as_i64(e); - } - V43::PrimFloat32(e) => { - *base.add(0).cast::() = (16i32) as u8; - *base.add(8).cast::() = _rt::as_f32(e); - } - V43::PrimFloat64(e) => { - *base.add(0).cast::() = (17i32) as u8; - *base.add(8).cast::() = _rt::as_f64(e); - } - V43::PrimChar(e) => { - *base.add(0).cast::() = (18i32) as u8; - *base.add(8).cast::() = _rt::as_i32(e); - } - V43::PrimBool(e) => { - *base.add(0).cast::() = (19i32) as u8; - *base.add(8).cast::() = (match e { - true => 1, - false => 0, - }) as u8; - } - V43::PrimString(e) => { - *base.add(0).cast::() = (20i32) as u8; - let vec39 = e; - let ptr39 = vec39.as_ptr().cast::(); - let len39 = vec39.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len39; - *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); - } - V43::Handle(e) => { - *base.add(0).cast::() = (21i32) as u8; - let (t40_0, t40_1) = e; - let super::super::super::golem::core::types::Uri { - value: value41, - } = t40_0; - let vec42 = value41; - let ptr42 = vec42.as_ptr().cast::(); - let len42 = vec42.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len42; - *base.add(8).cast::<*mut u8>() = ptr42.cast_mut(); - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t40_1); - } - } - } - } - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len44; - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result44; - cleanup_list - .extend_from_slice( - &[(result32, layout32), (result44, layout44)], - ); - } - } - *base - .add(128 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::() = len45; - *base - .add(128 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result45; - match original_phantom_id7 { - Some(e) => { - *base - .add(128 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits46, - low_bits: low_bits46, - } = e; - *base - .add(136 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits46); - *base - .add(144 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits46); - } - None => { - *base - .add(128 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - cleanup_list - .extend_from_slice( - &[ - (result16, layout16), - (result29, layout29), - (result45, layout45), - ], - ); - } - OplogEntry::HostCall(e) => { - *base.add(8).cast::() = (1i32) as u8; - let RawHostCallParameters { - timestamp: timestamp47, - function_name: function_name47, - request: request47, - response: response47, - durable_function_type: durable_function_type47, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds48, - nanoseconds: nanoseconds48, - } = timestamp47; - *base.add(16).cast::() = _rt::as_i64(seconds48); - *base.add(24).cast::() = _rt::as_i32(nanoseconds48); - let vec49 = function_name47; - let ptr49 = vec49.as_ptr().cast::(); - let len49 = vec49.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len49; - *base.add(32).cast::<*mut u8>() = ptr49.cast_mut(); - match request47 { - OplogPayload::Inline(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec50 = e; - let ptr50 = vec50.as_ptr().cast::(); - let len50 = vec50.len(); - *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len50; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr50.cast_mut(); - } - OplogPayload::External(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id51, - md5_hash: md5_hash51, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits52, - low_bits: low_bits52, - } = payload_id51; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits52); - *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits52); - let vec53 = md5_hash51; - let ptr53 = vec53.as_ptr().cast::(); - let len53 = vec53.len(); - *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len53; - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr53.cast_mut(); - } - } - match response47 { - OplogPayload::Inline(e) => { - *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec54 = e; - let ptr54 = vec54.as_ptr().cast::(); - let len54 = vec54.len(); - *base - .add(64 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len54; - *base - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr54.cast_mut(); - } - OplogPayload::External(e) => { - *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id55, - md5_hash: md5_hash55, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits56, - low_bits: low_bits56, - } = payload_id55; - *base - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits56); - *base - .add(72 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits56); - let vec57 = md5_hash55; - let ptr57 = vec57.as_ptr().cast::(); - let len57 = vec57.len(); - *base - .add(80 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len57; - *base - .add(80 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr57.cast_mut(); - } - } - match durable_function_type47 { - WrappedFunctionType::ReadLocal => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - WrappedFunctionType::WriteLocal => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - } - WrappedFunctionType::ReadRemote => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (2i32) as u8; - } - WrappedFunctionType::WriteRemote => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (3i32) as u8; - } - WrappedFunctionType::WriteRemoteBatched(e) => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (4i32) as u8; - match e { - Some(e) => { - *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - *base - .add(96 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(e); - } - None => { - *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - } - WrappedFunctionType::WriteRemoteTransaction(e) => { - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (5i32) as u8; - match e { - Some(e) => { - *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - *base - .add(96 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(e); - } - None => { - *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - } - } - } - OplogEntry::AgentInvocationStarted(e) => { - *base.add(8).cast::() = (2i32) as u8; - let RawAgentInvocationStartedParameters { - timestamp: timestamp58, - idempotency_key: idempotency_key58, - payload: payload58, - trace_id: trace_id58, - trace_states: trace_states58, - invocation_context: invocation_context58, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds59, - nanoseconds: nanoseconds59, - } = timestamp58; - *base.add(16).cast::() = _rt::as_i64(seconds59); - *base.add(24).cast::() = _rt::as_i32(nanoseconds59); - let vec60 = idempotency_key58; - let ptr60 = vec60.as_ptr().cast::(); - let len60 = vec60.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len60; - *base.add(32).cast::<*mut u8>() = ptr60.cast_mut(); - match payload58 { - OplogPayload::Inline(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec61 = e; - let ptr61 = vec61.as_ptr().cast::(); - let len61 = vec61.len(); - *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len61; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr61.cast_mut(); - } - OplogPayload::External(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id62, - md5_hash: md5_hash62, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits63, - low_bits: low_bits63, - } = payload_id62; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits63); - *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits63); - let vec64 = md5_hash62; - let ptr64 = vec64.as_ptr().cast::(); - let len64 = vec64.len(); - *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len64; - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr64.cast_mut(); - } - } - let vec65 = trace_id58; - let ptr65 = vec65.as_ptr().cast::(); - let len65 = vec65.len(); - *base - .add(56 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len65; - *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr65.cast_mut(); - let vec67 = trace_states58; - let len67 = vec67.len(); - let layout67 = _rt::alloc::Layout::from_size_align_unchecked( - vec67.len() * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result67 = if layout67.size() != 0 { - let ptr = _rt::alloc::alloc(layout67).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout67); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec67.into_iter().enumerate() { - let base = result67 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let vec66 = e; - let ptr66 = vec66.as_ptr().cast::(); - let len66 = vec66.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len66; - *base.add(0).cast::<*mut u8>() = ptr66.cast_mut(); - } - } - *base - .add(56 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::() = len67; - *base - .add(56 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result67; - let vec79 = invocation_context58; - let len79 = vec79.len(); - let layout79 = _rt::alloc::Layout::from_size_align_unchecked( - vec79.len() - * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result79 = if layout79.size() != 0 { - let ptr = _rt::alloc::alloc(layout79).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout79); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec79.into_iter().enumerate() { - let base = result79 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - { - match e { - SpanData::LocalSpan(e) => { - *base.add(0).cast::() = (0i32) as u8; - let LocalSpanData { - span_id: span_id68, - start: start68, - parent: parent68, - linked_context: linked_context68, - attributes: attributes68, - inherited: inherited68, - } = e; - let vec69 = span_id68; - let ptr69 = vec69.as_ptr().cast::(); - let len69 = vec69.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len69; - *base.add(8).cast::<*mut u8>() = ptr69.cast_mut(); - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds70, - nanoseconds: nanoseconds70, - } = start68; - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(seconds70); - *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(nanoseconds70); - match parent68 { - Some(e) => { - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let vec71 = e; - let ptr71 = vec71.as_ptr().cast::(); - let len71 = vec71.len(); - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len71; - *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr71.cast_mut(); - } - None => { - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - match linked_context68 { - Some(e) => { - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(e); - } - None => { - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - let vec76 = attributes68; - let len76 = vec76.len(); - let layout76 = _rt::alloc::Layout::from_size_align_unchecked( - vec76.len() * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result76 = if layout76.size() != 0 { - let ptr = _rt::alloc::alloc(layout76).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout76); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec76.into_iter().enumerate() { - let base = result76 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - { - let super::super::super::golem::api::context::Attribute { - key: key72, - value: value72, - } = e; - let vec73 = key72; - let ptr73 = vec73.as_ptr().cast::(); - let len73 = vec73.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len73; - *base.add(0).cast::<*mut u8>() = ptr73.cast_mut(); - use super::super::super::golem::api::context::AttributeValue as V75; - match value72 { - V75::String(e) => { - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec74 = e; - let ptr74 = vec74.as_ptr().cast::(); - let len74 = vec74.len(); - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len74; - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr74.cast_mut(); - } - } - } - } - *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len76; - *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result76; - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (match inherited68 { - true => 1, - false => 0, - }) as u8; - cleanup_list.extend_from_slice(&[(result76, layout76)]); - } - SpanData::ExternalSpan(e) => { - *base.add(0).cast::() = (1i32) as u8; - let ExternalSpanData { span_id: span_id77 } = e; - let vec78 = span_id77; - let ptr78 = vec78.as_ptr().cast::(); - let len78 = vec78.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len78; - *base.add(8).cast::<*mut u8>() = ptr78.cast_mut(); - } - } - } - } - *base - .add(56 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::() = len79; - *base - .add(56 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result79; - cleanup_list - .extend_from_slice( - &[(result67, layout67), (result79, layout79)], - ); - } - OplogEntry::AgentInvocationFinished(e) => { - *base.add(8).cast::() = (3i32) as u8; - let RawAgentInvocationFinishedParameters { - timestamp: timestamp80, - result: result80, - consumed_fuel: consumed_fuel80, - component_revision: component_revision80, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds81, - nanoseconds: nanoseconds81, - } = timestamp80; - *base.add(16).cast::() = _rt::as_i64(seconds81); - *base.add(24).cast::() = _rt::as_i32(nanoseconds81); - match result80 { - OplogPayload::Inline(e) => { - *base.add(32).cast::() = (0i32) as u8; - let vec82 = e; - let ptr82 = vec82.as_ptr().cast::(); - let len82 = vec82.len(); - *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len82; - *base.add(40).cast::<*mut u8>() = ptr82.cast_mut(); - } - OplogPayload::External(e) => { - *base.add(32).cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id83, - md5_hash: md5_hash83, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits84, - low_bits: low_bits84, - } = payload_id83; - *base.add(40).cast::() = _rt::as_i64(high_bits84); - *base.add(48).cast::() = _rt::as_i64(low_bits84); - let vec85 = md5_hash83; - let ptr85 = vec85.as_ptr().cast::(); - let len85 = vec85.len(); - *base - .add(56 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len85; - *base.add(56).cast::<*mut u8>() = ptr85.cast_mut(); - } - } - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(consumed_fuel80); - *base - .add(64 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(component_revision80); - } - OplogEntry::Suspend(e) => { - *base.add(8).cast::() = (4i32) as u8; - let Timestamp { timestamp: timestamp86 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds87, - nanoseconds: nanoseconds87, - } = timestamp86; - *base.add(16).cast::() = _rt::as_i64(seconds87); - *base.add(24).cast::() = _rt::as_i32(nanoseconds87); - } - OplogEntry::Error(e) => { - *base.add(8).cast::() = (5i32) as u8; - let RawErrorParameters { - timestamp: timestamp88, - error: error88, - retry_from: retry_from88, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds89, - nanoseconds: nanoseconds89, - } = timestamp88; - *base.add(16).cast::() = _rt::as_i64(seconds89); - *base.add(24).cast::() = _rt::as_i32(nanoseconds89); - match error88 { - WorkerError::Unknown(e) => { - *base.add(32).cast::() = (0i32) as u8; - let vec90 = e; - let ptr90 = vec90.as_ptr().cast::(); - let len90 = vec90.len(); - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len90; - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr90.cast_mut(); - } - WorkerError::InvalidRequest(e) => { - *base.add(32).cast::() = (1i32) as u8; - let vec91 = e; - let ptr91 = vec91.as_ptr().cast::(); - let len91 = vec91.len(); - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len91; - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr91.cast_mut(); - } - WorkerError::StackOverflow => { - *base.add(32).cast::() = (2i32) as u8; - } - WorkerError::OutOfMemory => { - *base.add(32).cast::() = (3i32) as u8; - } - WorkerError::ExceededMemoryLimit => { - *base.add(32).cast::() = (4i32) as u8; - } - WorkerError::InternalError(e) => { - *base.add(32).cast::() = (5i32) as u8; - let vec92 = e; - let ptr92 = vec92.as_ptr().cast::(); - let len92 = vec92.len(); - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len92; - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr92.cast_mut(); - } - WorkerError::ExceededTableLimit => { - *base.add(32).cast::() = (6i32) as u8; - } - } - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(retry_from88); - } - OplogEntry::NoOp(e) => { - *base.add(8).cast::() = (6i32) as u8; - let Timestamp { timestamp: timestamp93 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds94, - nanoseconds: nanoseconds94, - } = timestamp93; - *base.add(16).cast::() = _rt::as_i64(seconds94); - *base.add(24).cast::() = _rt::as_i32(nanoseconds94); - } - OplogEntry::Jump(e) => { - *base.add(8).cast::() = (7i32) as u8; - let JumpParameters { - timestamp: timestamp95, - jump: jump95, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds96, - nanoseconds: nanoseconds96, - } = timestamp95; - *base.add(16).cast::() = _rt::as_i64(seconds96); - *base.add(24).cast::() = _rt::as_i32(nanoseconds96); - let OplogRegion { start: start97, end: end97 } = jump95; - *base.add(32).cast::() = _rt::as_i64(start97); - *base.add(40).cast::() = _rt::as_i64(end97); - } - OplogEntry::Interrupted(e) => { - *base.add(8).cast::() = (8i32) as u8; - let Timestamp { timestamp: timestamp98 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds99, - nanoseconds: nanoseconds99, - } = timestamp98; - *base.add(16).cast::() = _rt::as_i64(seconds99); - *base.add(24).cast::() = _rt::as_i32(nanoseconds99); - } - OplogEntry::Exited(e) => { - *base.add(8).cast::() = (9i32) as u8; - let Timestamp { timestamp: timestamp100 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds101, - nanoseconds: nanoseconds101, - } = timestamp100; - *base.add(16).cast::() = _rt::as_i64(seconds101); - *base.add(24).cast::() = _rt::as_i32(nanoseconds101); - } - OplogEntry::ChangeRetryPolicy(e) => { - *base.add(8).cast::() = (10i32) as u8; - let ChangeRetryPolicyParameters { - timestamp: timestamp102, - new_policy: new_policy102, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds103, - nanoseconds: nanoseconds103, - } = timestamp102; - *base.add(16).cast::() = _rt::as_i64(seconds103); - *base.add(24).cast::() = _rt::as_i32(nanoseconds103); - let super::super::super::golem::api::host::RetryPolicy { - max_attempts: max_attempts104, - min_delay: min_delay104, - max_delay: max_delay104, - multiplier: multiplier104, - max_jitter_factor: max_jitter_factor104, - } = new_policy102; - *base.add(32).cast::() = _rt::as_i32(max_attempts104); - *base.add(40).cast::() = _rt::as_i64(min_delay104); - *base.add(48).cast::() = _rt::as_i64(max_delay104); - *base.add(56).cast::() = _rt::as_f64(multiplier104); - match max_jitter_factor104 { - Some(e) => { - *base.add(64).cast::() = (1i32) as u8; - *base.add(72).cast::() = _rt::as_f64(e); - } - None => { - *base.add(64).cast::() = (0i32) as u8; - } - }; - } - OplogEntry::BeginAtomicRegion(e) => { - *base.add(8).cast::() = (11i32) as u8; - let Timestamp { timestamp: timestamp105 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds106, - nanoseconds: nanoseconds106, - } = timestamp105; - *base.add(16).cast::() = _rt::as_i64(seconds106); - *base.add(24).cast::() = _rt::as_i32(nanoseconds106); - } - OplogEntry::EndAtomicRegion(e) => { - *base.add(8).cast::() = (12i32) as u8; - let EndAtomicRegionParameters { - timestamp: timestamp107, - begin_index: begin_index107, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds108, - nanoseconds: nanoseconds108, - } = timestamp107; - *base.add(16).cast::() = _rt::as_i64(seconds108); - *base.add(24).cast::() = _rt::as_i32(nanoseconds108); - *base.add(32).cast::() = _rt::as_i64(begin_index107); - } - OplogEntry::BeginRemoteWrite(e) => { - *base.add(8).cast::() = (13i32) as u8; - let Timestamp { timestamp: timestamp109 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds110, - nanoseconds: nanoseconds110, - } = timestamp109; - *base.add(16).cast::() = _rt::as_i64(seconds110); - *base.add(24).cast::() = _rt::as_i32(nanoseconds110); - } - OplogEntry::EndRemoteWrite(e) => { - *base.add(8).cast::() = (14i32) as u8; - let EndRemoteWriteParameters { - timestamp: timestamp111, - begin_index: begin_index111, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds112, - nanoseconds: nanoseconds112, - } = timestamp111; - *base.add(16).cast::() = _rt::as_i64(seconds112); - *base.add(24).cast::() = _rt::as_i32(nanoseconds112); - *base.add(32).cast::() = _rt::as_i64(begin_index111); - } - OplogEntry::PendingAgentInvocation(e) => { - *base.add(8).cast::() = (15i32) as u8; - let RawPendingAgentInvocationParameters { - timestamp: timestamp113, - idempotency_key: idempotency_key113, - payload: payload113, - trace_id: trace_id113, - trace_states: trace_states113, - invocation_context: invocation_context113, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds114, - nanoseconds: nanoseconds114, - } = timestamp113; - *base.add(16).cast::() = _rt::as_i64(seconds114); - *base.add(24).cast::() = _rt::as_i32(nanoseconds114); - let vec115 = idempotency_key113; - let ptr115 = vec115.as_ptr().cast::(); - let len115 = vec115.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len115; - *base.add(32).cast::<*mut u8>() = ptr115.cast_mut(); - match payload113 { - OplogPayload::Inline(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec116 = e; - let ptr116 = vec116.as_ptr().cast::(); - let len116 = vec116.len(); - *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len116; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr116.cast_mut(); - } - OplogPayload::External(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id117, - md5_hash: md5_hash117, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits118, - low_bits: low_bits118, - } = payload_id117; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(high_bits118); - *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(low_bits118); - let vec119 = md5_hash117; - let ptr119 = vec119.as_ptr().cast::(); - let len119 = vec119.len(); - *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len119; - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr119.cast_mut(); - } - } - let vec120 = trace_id113; - let ptr120 = vec120.as_ptr().cast::(); - let len120 = vec120.len(); - *base - .add(56 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len120; - *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr120.cast_mut(); - let vec122 = trace_states113; - let len122 = vec122.len(); - let layout122 = _rt::alloc::Layout::from_size_align_unchecked( - vec122.len() * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result122 = if layout122.size() != 0 { - let ptr = _rt::alloc::alloc(layout122).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout122); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec122.into_iter().enumerate() { - let base = result122 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let vec121 = e; - let ptr121 = vec121.as_ptr().cast::(); - let len121 = vec121.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len121; - *base.add(0).cast::<*mut u8>() = ptr121.cast_mut(); - } - } - *base - .add(56 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::() = len122; - *base - .add(56 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result122; - let vec134 = invocation_context113; - let len134 = vec134.len(); - let layout134 = _rt::alloc::Layout::from_size_align_unchecked( - vec134.len() - * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result134 = if layout134.size() != 0 { - let ptr = _rt::alloc::alloc(layout134).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout134); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec134.into_iter().enumerate() { - let base = result134 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - { - match e { - SpanData::LocalSpan(e) => { - *base.add(0).cast::() = (0i32) as u8; - let LocalSpanData { - span_id: span_id123, - start: start123, - parent: parent123, - linked_context: linked_context123, - attributes: attributes123, - inherited: inherited123, - } = e; - let vec124 = span_id123; - let ptr124 = vec124.as_ptr().cast::(); - let len124 = vec124.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len124; - *base.add(8).cast::<*mut u8>() = ptr124.cast_mut(); - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds125, - nanoseconds: nanoseconds125, - } = start123; - *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(seconds125); - *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(nanoseconds125); - match parent123 { - Some(e) => { - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let vec126 = e; - let ptr126 = vec126.as_ptr().cast::(); - let len126 = vec126.len(); - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len126; - *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr126.cast_mut(); - } - None => { - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - match linked_context123 { - Some(e) => { - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(e); - } - None => { - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - let vec131 = attributes123; - let len131 = vec131.len(); - let layout131 = _rt::alloc::Layout::from_size_align_unchecked( - vec131.len() * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result131 = if layout131.size() != 0 { - let ptr = _rt::alloc::alloc(layout131).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout131); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec131.into_iter().enumerate() { - let base = result131 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - { - let super::super::super::golem::api::context::Attribute { - key: key127, - value: value127, - } = e; - let vec128 = key127; - let ptr128 = vec128.as_ptr().cast::(); - let len128 = vec128.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len128; - *base.add(0).cast::<*mut u8>() = ptr128.cast_mut(); - use super::super::super::golem::api::context::AttributeValue as V130; - match value127 { - V130::String(e) => { - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec129 = e; - let ptr129 = vec129.as_ptr().cast::(); - let len129 = vec129.len(); - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len129; - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr129.cast_mut(); - } - } - } - } - *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len131; - *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result131; - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (match inherited123 { - true => 1, - false => 0, - }) as u8; - cleanup_list.extend_from_slice(&[(result131, layout131)]); - } - SpanData::ExternalSpan(e) => { - *base.add(0).cast::() = (1i32) as u8; - let ExternalSpanData { span_id: span_id132 } = e; - let vec133 = span_id132; - let ptr133 = vec133.as_ptr().cast::(); - let len133 = vec133.len(); - *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len133; - *base.add(8).cast::<*mut u8>() = ptr133.cast_mut(); - } - } - } - } - *base - .add(56 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::() = len134; - *base - .add(56 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result134; - cleanup_list - .extend_from_slice( - &[(result122, layout122), (result134, layout134)], - ); - } - OplogEntry::PendingUpdate(e) => { - *base.add(8).cast::() = (16i32) as u8; - let RawPendingUpdateParameters { - timestamp: timestamp135, - description: description135, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds136, - nanoseconds: nanoseconds136, - } = timestamp135; - *base.add(16).cast::() = _rt::as_i64(seconds136); - *base.add(24).cast::() = _rt::as_i32(nanoseconds136); - match description135 { - RawUpdateDescription::Automatic(e) => { - *base.add(32).cast::() = (0i32) as u8; - *base.add(40).cast::() = _rt::as_i64(e); - } - RawUpdateDescription::SnapshotBased(e) => { - *base.add(32).cast::() = (1i32) as u8; - let RawSnapshotBasedUpdate { - target_revision: target_revision137, - payload: payload137, - mime_type: mime_type137, - } = e; - *base.add(40).cast::() = _rt::as_i64( - target_revision137, - ); - match payload137 { - OplogPayload::Inline(e) => { - *base.add(48).cast::() = (0i32) as u8; - let vec138 = e; - let ptr138 = vec138.as_ptr().cast::(); - let len138 = vec138.len(); - *base - .add(56 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len138; - *base.add(56).cast::<*mut u8>() = ptr138.cast_mut(); - } - OplogPayload::External(e) => { - *base.add(48).cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id139, - md5_hash: md5_hash139, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits140, - low_bits: low_bits140, - } = payload_id139; - *base.add(56).cast::() = _rt::as_i64(high_bits140); - *base.add(64).cast::() = _rt::as_i64(low_bits140); - let vec141 = md5_hash139; - let ptr141 = vec141.as_ptr().cast::(); - let len141 = vec141.len(); - *base - .add(72 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len141; - *base.add(72).cast::<*mut u8>() = ptr141.cast_mut(); - } - } - let vec142 = mime_type137; - let ptr142 = vec142.as_ptr().cast::(); - let len142 = vec142.len(); - *base - .add(72 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len142; - *base - .add(72 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr142.cast_mut(); - } - } - } - OplogEntry::SuccessfulUpdate(e) => { - *base.add(8).cast::() = (17i32) as u8; - let RawSuccessfulUpdateParameters { - timestamp: timestamp143, - target_revision: target_revision143, - new_component_size: new_component_size143, - new_active_plugins: new_active_plugins143, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds144, - nanoseconds: nanoseconds144, - } = timestamp143; - *base.add(16).cast::() = _rt::as_i64(seconds144); - *base.add(24).cast::() = _rt::as_i32(nanoseconds144); - *base.add(32).cast::() = _rt::as_i64( - target_revision143, - ); - *base.add(40).cast::() = _rt::as_i64( - new_component_size143, - ); - let vec145 = new_active_plugins143; - let ptr145 = vec145.as_ptr().cast::(); - let len145 = vec145.len(); - *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len145; - *base.add(48).cast::<*mut u8>() = ptr145.cast_mut(); - } - OplogEntry::FailedUpdate(e) => { - *base.add(8).cast::() = (18i32) as u8; - let FailedUpdateParameters { - timestamp: timestamp146, - target_revision: target_revision146, - details: details146, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds147, - nanoseconds: nanoseconds147, - } = timestamp146; - *base.add(16).cast::() = _rt::as_i64(seconds147); - *base.add(24).cast::() = _rt::as_i32(nanoseconds147); - *base.add(32).cast::() = _rt::as_i64( - target_revision146, - ); - match details146 { - Some(e) => { - *base.add(40).cast::() = (1i32) as u8; - let vec148 = e; - let ptr148 = vec148.as_ptr().cast::(); - let len148 = vec148.len(); - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len148; - *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr148.cast_mut(); - } - None => { - *base.add(40).cast::() = (0i32) as u8; - } - }; - } - OplogEntry::GrowMemory(e) => { - *base.add(8).cast::() = (19i32) as u8; - let GrowMemoryParameters { - timestamp: timestamp149, - delta: delta149, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds150, - nanoseconds: nanoseconds150, - } = timestamp149; - *base.add(16).cast::() = _rt::as_i64(seconds150); - *base.add(24).cast::() = _rt::as_i32(nanoseconds150); - *base.add(32).cast::() = _rt::as_i64(delta149); - } - OplogEntry::CreateResource(e) => { - *base.add(8).cast::() = (20i32) as u8; - let RawCreateResourceParameters { - timestamp: timestamp151, - id: id151, - resource_type_id: resource_type_id151, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds152, - nanoseconds: nanoseconds152, - } = timestamp151; - *base.add(16).cast::() = _rt::as_i64(seconds152); - *base.add(24).cast::() = _rt::as_i32(nanoseconds152); - *base.add(32).cast::() = _rt::as_i64(id151); - let ResourceTypeId { name: name153, owner: owner153 } = resource_type_id151; - let vec154 = name153; - let ptr154 = vec154.as_ptr().cast::(); - let len154 = vec154.len(); - *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len154; - *base.add(40).cast::<*mut u8>() = ptr154.cast_mut(); - let vec155 = owner153; - let ptr155 = vec155.as_ptr().cast::(); - let len155 = vec155.len(); - *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len155; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr155.cast_mut(); - } - OplogEntry::DropResource(e) => { - *base.add(8).cast::() = (21i32) as u8; - let RawDropResourceParameters { - timestamp: timestamp156, - id: id156, - resource_type_id: resource_type_id156, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds157, - nanoseconds: nanoseconds157, - } = timestamp156; - *base.add(16).cast::() = _rt::as_i64(seconds157); - *base.add(24).cast::() = _rt::as_i32(nanoseconds157); - *base.add(32).cast::() = _rt::as_i64(id156); - let ResourceTypeId { name: name158, owner: owner158 } = resource_type_id156; - let vec159 = name158; - let ptr159 = vec159.as_ptr().cast::(); - let len159 = vec159.len(); - *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len159; - *base.add(40).cast::<*mut u8>() = ptr159.cast_mut(); - let vec160 = owner158; - let ptr160 = vec160.as_ptr().cast::(); - let len160 = vec160.len(); - *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len160; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr160.cast_mut(); - } - OplogEntry::Log(e) => { - *base.add(8).cast::() = (22i32) as u8; - let LogParameters { - timestamp: timestamp161, - level: level161, - context: context161, - message: message161, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds162, - nanoseconds: nanoseconds162, - } = timestamp161; - *base.add(16).cast::() = _rt::as_i64(seconds162); - *base.add(24).cast::() = _rt::as_i32(nanoseconds162); - *base.add(32).cast::() = (level161.clone() as i32) - as u8; - let vec163 = context161; - let ptr163 = vec163.as_ptr().cast::(); - let len163 = vec163.len(); - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len163; - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr163.cast_mut(); - let vec164 = message161; - let ptr164 = vec164.as_ptr().cast::(); - let len164 = vec164.len(); - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len164; - *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr164.cast_mut(); - } - OplogEntry::Restart(e) => { - *base.add(8).cast::() = (23i32) as u8; - let Timestamp { timestamp: timestamp165 } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds166, - nanoseconds: nanoseconds166, - } = timestamp165; - *base.add(16).cast::() = _rt::as_i64(seconds166); - *base.add(24).cast::() = _rt::as_i32(nanoseconds166); - } - OplogEntry::ActivatePlugin(e) => { - *base.add(8).cast::() = (24i32) as u8; - let RawActivatePluginParameters { - timestamp: timestamp167, - plugin_priority: plugin_priority167, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds168, - nanoseconds: nanoseconds168, - } = timestamp167; - *base.add(16).cast::() = _rt::as_i64(seconds168); - *base.add(24).cast::() = _rt::as_i32(nanoseconds168); - *base.add(32).cast::() = _rt::as_i32( - plugin_priority167, - ); - } - OplogEntry::DeactivatePlugin(e) => { - *base.add(8).cast::() = (25i32) as u8; - let RawDeactivatePluginParameters { - timestamp: timestamp169, - plugin_priority: plugin_priority169, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds170, - nanoseconds: nanoseconds170, - } = timestamp169; - *base.add(16).cast::() = _rt::as_i64(seconds170); - *base.add(24).cast::() = _rt::as_i32(nanoseconds170); - *base.add(32).cast::() = _rt::as_i32( - plugin_priority169, - ); - } - OplogEntry::Revert(e) => { - *base.add(8).cast::() = (26i32) as u8; - let RevertParameters { - timestamp: timestamp171, - dropped_region: dropped_region171, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds172, - nanoseconds: nanoseconds172, - } = timestamp171; - *base.add(16).cast::() = _rt::as_i64(seconds172); - *base.add(24).cast::() = _rt::as_i32(nanoseconds172); - let OplogRegion { start: start173, end: end173 } = dropped_region171; - *base.add(32).cast::() = _rt::as_i64(start173); - *base.add(40).cast::() = _rt::as_i64(end173); - } - OplogEntry::CancelPendingInvocation(e) => { - *base.add(8).cast::() = (27i32) as u8; - let CancelPendingInvocationParameters { - timestamp: timestamp174, - idempotency_key: idempotency_key174, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds175, - nanoseconds: nanoseconds175, - } = timestamp174; - *base.add(16).cast::() = _rt::as_i64(seconds175); - *base.add(24).cast::() = _rt::as_i32(nanoseconds175); - let vec176 = idempotency_key174; - let ptr176 = vec176.as_ptr().cast::(); - let len176 = vec176.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len176; - *base.add(32).cast::<*mut u8>() = ptr176.cast_mut(); - } - OplogEntry::StartSpan(e) => { - *base.add(8).cast::() = (28i32) as u8; - let StartSpanParameters { - timestamp: timestamp177, - span_id: span_id177, - parent: parent177, - linked_context_id: linked_context_id177, - attributes: attributes177, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds178, - nanoseconds: nanoseconds178, - } = timestamp177; - *base.add(16).cast::() = _rt::as_i64(seconds178); - *base.add(24).cast::() = _rt::as_i32(nanoseconds178); - let vec179 = span_id177; - let ptr179 = vec179.as_ptr().cast::(); - let len179 = vec179.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len179; - *base.add(32).cast::<*mut u8>() = ptr179.cast_mut(); - match parent177 { - Some(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let vec180 = e; - let ptr180 = vec180.as_ptr().cast::(); - let len180 = vec180.len(); - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len180; - *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr180.cast_mut(); - } - None => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - match linked_context_id177 { - Some(e) => { - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - let vec181 = e; - let ptr181 = vec181.as_ptr().cast::(); - let len181 = vec181.len(); - *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::() = len181; - *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr181.cast_mut(); - } - None => { - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - let vec186 = attributes177; - let len186 = vec186.len(); - let layout186 = _rt::alloc::Layout::from_size_align_unchecked( - vec186.len() * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result186 = if layout186.size() != 0 { - let ptr = _rt::alloc::alloc(layout186).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout186); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec186.into_iter().enumerate() { - let base = result186 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - { - let super::super::super::golem::api::context::Attribute { - key: key182, - value: value182, - } = e; - let vec183 = key182; - let ptr183 = vec183.as_ptr().cast::(); - let len183 = vec183.len(); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len183; - *base.add(0).cast::<*mut u8>() = ptr183.cast_mut(); - use super::super::super::golem::api::context::AttributeValue as V185; - match value182 { - V185::String(e) => { - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec184 = e; - let ptr184 = vec184.as_ptr().cast::(); - let len184 = vec184.len(); - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::() = len184; - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr184.cast_mut(); - } - } - } - } - *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::() = len186; - *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result186; - cleanup_list.extend_from_slice(&[(result186, layout186)]); - } - OplogEntry::FinishSpan(e) => { - *base.add(8).cast::() = (29i32) as u8; - let FinishSpanParameters { - timestamp: timestamp187, - span_id: span_id187, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds188, - nanoseconds: nanoseconds188, - } = timestamp187; - *base.add(16).cast::() = _rt::as_i64(seconds188); - *base.add(24).cast::() = _rt::as_i32(nanoseconds188); - let vec189 = span_id187; - let ptr189 = vec189.as_ptr().cast::(); - let len189 = vec189.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len189; - *base.add(32).cast::<*mut u8>() = ptr189.cast_mut(); - } - OplogEntry::SetSpanAttribute(e) => { - *base.add(8).cast::() = (30i32) as u8; - let SetSpanAttributeParameters { - timestamp: timestamp190, - span_id: span_id190, - key: key190, - value: value190, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds191, - nanoseconds: nanoseconds191, - } = timestamp190; - *base.add(16).cast::() = _rt::as_i64(seconds191); - *base.add(24).cast::() = _rt::as_i32(nanoseconds191); - let vec192 = span_id190; - let ptr192 = vec192.as_ptr().cast::(); - let len192 = vec192.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len192; - *base.add(32).cast::<*mut u8>() = ptr192.cast_mut(); - let vec193 = key190; - let ptr193 = vec193.as_ptr().cast::(); - let len193 = vec193.len(); - *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len193; - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr193.cast_mut(); - use super::super::super::golem::api::context::AttributeValue as V195; - match value190 { - V195::String(e) => { - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - let vec194 = e; - let ptr194 = vec194.as_ptr().cast::(); - let len194 = vec194.len(); - *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = len194; - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr194.cast_mut(); - } - } - } - OplogEntry::ChangePersistenceLevel(e) => { - *base.add(8).cast::() = (31i32) as u8; - let ChangePersistenceLevelParameters { - timestamp: timestamp196, - persistence_level: persistence_level196, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds197, - nanoseconds: nanoseconds197, - } = timestamp196; - *base.add(16).cast::() = _rt::as_i64(seconds197); - *base.add(24).cast::() = _rt::as_i32(nanoseconds197); - use super::super::super::golem::api::host::PersistenceLevel as V198; - match persistence_level196 { - V198::PersistNothing => { - *base.add(32).cast::() = (0i32) as u8; - } - V198::PersistRemoteSideEffects => { - *base.add(32).cast::() = (1i32) as u8; - } - V198::Smart => { - *base.add(32).cast::() = (2i32) as u8; - } - } - } - OplogEntry::BeginRemoteTransaction(e) => { - *base.add(8).cast::() = (32i32) as u8; - let RawBeginRemoteTransactionParameters { - timestamp: timestamp199, - transaction_id: transaction_id199, - original_begin_index: original_begin_index199, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds200, - nanoseconds: nanoseconds200, - } = timestamp199; - *base.add(16).cast::() = _rt::as_i64(seconds200); - *base.add(24).cast::() = _rt::as_i32(nanoseconds200); - let vec201 = transaction_id199; - let ptr201 = vec201.as_ptr().cast::(); - let len201 = vec201.len(); - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len201; - *base.add(32).cast::<*mut u8>() = ptr201.cast_mut(); - match original_begin_index199 { - Some(e) => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (1i32) as u8; - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(e); - } - None => { - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (0i32) as u8; - } - }; - } - OplogEntry::PreCommitRemoteTransaction(e) => { - *base.add(8).cast::() = (33i32) as u8; - let RemoteTransactionParameters { - timestamp: timestamp202, - begin_index: begin_index202, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds203, - nanoseconds: nanoseconds203, - } = timestamp202; - *base.add(16).cast::() = _rt::as_i64(seconds203); - *base.add(24).cast::() = _rt::as_i32(nanoseconds203); - *base.add(32).cast::() = _rt::as_i64(begin_index202); - } - OplogEntry::PreRollbackRemoteTransaction(e) => { - *base.add(8).cast::() = (34i32) as u8; - let RemoteTransactionParameters { - timestamp: timestamp204, - begin_index: begin_index204, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds205, - nanoseconds: nanoseconds205, - } = timestamp204; - *base.add(16).cast::() = _rt::as_i64(seconds205); - *base.add(24).cast::() = _rt::as_i32(nanoseconds205); - *base.add(32).cast::() = _rt::as_i64(begin_index204); - } - OplogEntry::CommittedRemoteTransaction(e) => { - *base.add(8).cast::() = (35i32) as u8; - let RemoteTransactionParameters { - timestamp: timestamp206, - begin_index: begin_index206, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds207, - nanoseconds: nanoseconds207, - } = timestamp206; - *base.add(16).cast::() = _rt::as_i64(seconds207); - *base.add(24).cast::() = _rt::as_i32(nanoseconds207); - *base.add(32).cast::() = _rt::as_i64(begin_index206); - } - OplogEntry::RolledBackRemoteTransaction(e) => { - *base.add(8).cast::() = (36i32) as u8; - let RemoteTransactionParameters { - timestamp: timestamp208, - begin_index: begin_index208, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds209, - nanoseconds: nanoseconds209, - } = timestamp208; - *base.add(16).cast::() = _rt::as_i64(seconds209); - *base.add(24).cast::() = _rt::as_i32(nanoseconds209); - *base.add(32).cast::() = _rt::as_i64(begin_index208); - } - OplogEntry::Snapshot(e) => { - *base.add(8).cast::() = (37i32) as u8; - let RawSnapshotParameters { - timestamp: timestamp210, - data: data210, - mime_type: mime_type210, - } = e; - let super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: seconds211, - nanoseconds: nanoseconds211, - } = timestamp210; - *base.add(16).cast::() = _rt::as_i64(seconds211); - *base.add(24).cast::() = _rt::as_i32(nanoseconds211); - match data210 { - OplogPayload::Inline(e) => { - *base.add(32).cast::() = (0i32) as u8; - let vec212 = e; - let ptr212 = vec212.as_ptr().cast::(); - let len212 = vec212.len(); - *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len212; - *base.add(40).cast::<*mut u8>() = ptr212.cast_mut(); - } - OplogPayload::External(e) => { - *base.add(32).cast::() = (1i32) as u8; - let OplogExternalPayload { - payload_id: payload_id213, - md5_hash: md5_hash213, - } = e; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits214, - low_bits: low_bits214, - } = payload_id213; - *base.add(40).cast::() = _rt::as_i64(high_bits214); - *base.add(48).cast::() = _rt::as_i64(low_bits214); - let vec215 = md5_hash213; - let ptr215 = vec215.as_ptr().cast::(); - let len215 = vec215.len(); - *base - .add(56 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len215; - *base.add(56).cast::<*mut u8>() = ptr215.cast_mut(); - } - } - let vec216 = mime_type210; - let ptr216 = vec216.as_ptr().cast::(); - let len216 = vec216.len(); - *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len216; - *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr216.cast_mut(); - } - } - } - } - let ptr218 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "enrich-oplog-entries"] - fn wit_import219( - _: i64, - _: i64, - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: i64, - _: *mut u8, - ); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import219( - _: i64, - _: i64, - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - _: i64, - _: *mut u8, - ) { - unreachable!() - } - unsafe { - wit_import219( - _rt::as_i64(high_bits1), - _rt::as_i64(low_bits1), - _rt::as_i64(high_bits4), - _rt::as_i64(low_bits4), - ptr5.cast_mut(), - len5, - result217, - len217, - _rt::as_i64(component_revision), - ptr218, - ) - }; - let l220 = i32::from(*ptr218.add(0).cast::()); - let result2898 = match l220 { - 0 => { - let e = { - let l221 = *ptr218 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l222 = *ptr218 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2894 = l221; - let len2894 = l222; - let mut result2894 = _rt::Vec::with_capacity(len2894); - for i in 0..len2894 { - let base = base2894 - .add(i * (120 + 14 * ::core::mem::size_of::<*const u8>())); - let e2894 = { - let l223 = i32::from(*base.add(0).cast::()); - let v2893 = match l223 { - 0 => { - let e2893 = { - let l224 = *base.add(8).cast::(); - let l225 = *base.add(16).cast::(); - let l226 = *base.add(24).cast::(); - let l227 = *base.add(32).cast::(); - let l228 = *base.add(40).cast::<*mut u8>(); - let l229 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len230 = l229; - let bytes230 = _rt::Vec::from_raw_parts( - l228.cast(), - len230, - len230, - ); - let l231 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l232 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l233 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base237 = l232; - let len237 = l233; - let mut result237 = _rt::Vec::with_capacity(len237); - for i in 0..len237 { - let base = base237 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e237 = { - let l234 = *base.add(0).cast::<*mut u8>(); - let l235 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len236 = l235; - let bytes236 = _rt::Vec::from_raw_parts( - l234.cast(), - len236, - len236, - ); - _rt::string_lift(bytes236) - }; - result237.push(e237); - } - _rt::cabi_dealloc( - base237, - len237 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l238 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l239 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base246 = l238; - let len246 = l239; - let mut result246 = _rt::Vec::with_capacity(len246); - for i in 0..len246 { - let base = base246 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e246 = { - let l240 = *base.add(0).cast::<*mut u8>(); - let l241 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len242 = l241; - let bytes242 = _rt::Vec::from_raw_parts( - l240.cast(), - len242, - len242, - ); - let l243 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l244 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len245 = l244; - let bytes245 = _rt::Vec::from_raw_parts( - l243.cast(), - len245, - len245, - ); - (_rt::string_lift(bytes242), _rt::string_lift(bytes245)) - }; - result246.push(e246); - } - _rt::cabi_dealloc( - base246, - len246 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l247 = *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l248 = *base - .add(56 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l249 = *base - .add(64 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l250 = *base - .add(72 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l251 = i32::from( - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l257 = *base - .add(104 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l258 = *base - .add(112 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l259 = *base - .add(120 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l260 = *base - .add(120 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base276 = l259; - let len276 = l260; - let mut result276 = _rt::Vec::with_capacity(len276); - for i in 0..len276 { - let base = base276 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e276 = { - let l261 = *base.add(0).cast::<*mut u8>(); - let l262 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len263 = l262; - let bytes263 = _rt::Vec::from_raw_parts( - l261.cast(), - len263, - len263, - ); - let l264 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l265 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len266 = l265; - let bytes266 = _rt::Vec::from_raw_parts( - l264.cast(), - len266, - len266, - ); - let l267 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l268 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base275 = l267; - let len275 = l268; - let mut result275 = _rt::Vec::with_capacity(len275); - for i in 0..len275 { - let base = base275 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e275 = { - let l269 = *base.add(0).cast::<*mut u8>(); - let l270 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len271 = l270; - let bytes271 = _rt::Vec::from_raw_parts( - l269.cast(), - len271, - len271, - ); - let l272 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l273 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len274 = l273; - let bytes274 = _rt::Vec::from_raw_parts( - l272.cast(), - len274, - len274, - ); - (_rt::string_lift(bytes271), _rt::string_lift(bytes274)) - }; - result275.push(e275); - } - _rt::cabi_dealloc( - base275, - len275 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes263), - version: _rt::string_lift(bytes266), - parameters: result275, - } - }; - result276.push(e276); - } - _rt::cabi_dealloc( - base276, - len276 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l277 = *base - .add(120 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l278 = *base - .add(120 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base285 = l277; - let len285 = l278; - let mut result285 = _rt::Vec::with_capacity(len285); - for i in 0..len285 { - let base = base285 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e285 = { - let l279 = *base.add(0).cast::<*mut u8>(); - let l280 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len281 = l280; - let bytes281 = _rt::Vec::from_raw_parts( - l279.cast(), - len281, - len281, - ); - let l282 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l283 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len284 = l283; - let bytes284 = _rt::Vec::from_raw_parts( - l282.cast(), - len284, - len284, - ); - (_rt::string_lift(bytes281), _rt::string_lift(bytes284)) - }; - result285.push(e285); - } - _rt::cabi_dealloc( - base285, - len285 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l286 = *base - .add(120 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l287 = *base - .add(120 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base393 = l286; - let len393 = l287; - let mut result393 = _rt::Vec::with_capacity(len393); - for i in 0..len393 { - let base = base393 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e393 = { - let l288 = *base.add(0).cast::<*mut u8>(); - let l289 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base293 = l288; - let len293 = l289; - let mut result293 = _rt::Vec::with_capacity(len293); - for i in 0..len293 { - let base = base293 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e293 = { - let l290 = *base.add(0).cast::<*mut u8>(); - let l291 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len292 = l291; - let bytes292 = _rt::Vec::from_raw_parts( - l290.cast(), - len292, - len292, - ); - _rt::string_lift(bytes292) - }; - result293.push(e293); - } - _rt::cabi_dealloc( - base293, - len293 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l294 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l295 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base341 = l294; - let len341 = l295; - let mut result341 = _rt::Vec::with_capacity(len341); - for i in 0..len341 { - let base = base341 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e341 = { - let l296 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V340; - let v340 = match l296 { - 0 => { - let e340 = { - let l297 = *base.add(8).cast::<*mut u8>(); - let l298 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len299 = l298; - _rt::Vec::from_raw_parts(l297.cast(), len299, len299) - }; - V340::RecordValue(e340) - } - 1 => { - let e340 = { - let l300 = *base.add(8).cast::(); - let l301 = i32::from(*base.add(12).cast::()); - ( - l300 as u32, - match l301 { - 0 => None, - 1 => { - let e = { - let l302 = *base.add(16).cast::(); - l302 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V340::VariantValue(e340) - } - 2 => { - let e340 = { - let l303 = *base.add(8).cast::(); - l303 as u32 - }; - V340::EnumValue(e340) - } - 3 => { - let e340 = { - let l304 = *base.add(8).cast::<*mut u8>(); - let l305 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base307 = l304; - let len307 = l305; - let mut result307 = _rt::Vec::with_capacity(len307); - for i in 0..len307 { - let base = base307.add(i * 1); - let e307 = { - let l306 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l306 as u8) - }; - result307.push(e307); - } - _rt::cabi_dealloc(base307, len307 * 1, 1); - result307 - }; - V340::FlagsValue(e340) - } - 4 => { - let e340 = { - let l308 = *base.add(8).cast::<*mut u8>(); - let l309 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len310 = l309; - _rt::Vec::from_raw_parts(l308.cast(), len310, len310) - }; - V340::TupleValue(e340) - } - 5 => { - let e340 = { - let l311 = *base.add(8).cast::<*mut u8>(); - let l312 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len313 = l312; - _rt::Vec::from_raw_parts(l311.cast(), len313, len313) - }; - V340::ListValue(e340) - } - 6 => { - let e340 = { - let l314 = i32::from(*base.add(8).cast::()); - match l314 { - 0 => None, - 1 => { - let e = { - let l315 = *base.add(12).cast::(); - l315 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V340::OptionValue(e340) - } - 7 => { - let e340 = { - let l316 = i32::from(*base.add(8).cast::()); - match l316 { - 0 => { - let e = { - let l317 = i32::from(*base.add(12).cast::()); - match l317 { - 0 => None, - 1 => { - let e = { - let l318 = *base.add(16).cast::(); - l318 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l319 = i32::from(*base.add(12).cast::()); - match l319 { - 0 => None, - 1 => { - let e = { - let l320 = *base.add(16).cast::(); - l320 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V340::ResultValue(e340) - } - 8 => { - let e340 = { - let l321 = i32::from(*base.add(8).cast::()); - l321 as u8 - }; - V340::PrimU8(e340) - } - 9 => { - let e340 = { - let l322 = i32::from(*base.add(8).cast::()); - l322 as u16 - }; - V340::PrimU16(e340) - } - 10 => { - let e340 = { - let l323 = *base.add(8).cast::(); - l323 as u32 - }; - V340::PrimU32(e340) - } - 11 => { - let e340 = { - let l324 = *base.add(8).cast::(); - l324 as u64 - }; - V340::PrimU64(e340) - } - 12 => { - let e340 = { - let l325 = i32::from(*base.add(8).cast::()); - l325 as i8 - }; - V340::PrimS8(e340) - } - 13 => { - let e340 = { - let l326 = i32::from(*base.add(8).cast::()); - l326 as i16 - }; - V340::PrimS16(e340) - } - 14 => { - let e340 = { - let l327 = *base.add(8).cast::(); - l327 - }; - V340::PrimS32(e340) - } - 15 => { - let e340 = { - let l328 = *base.add(8).cast::(); - l328 - }; - V340::PrimS64(e340) - } - 16 => { - let e340 = { - let l329 = *base.add(8).cast::(); - l329 - }; - V340::PrimFloat32(e340) - } - 17 => { - let e340 = { - let l330 = *base.add(8).cast::(); - l330 - }; - V340::PrimFloat64(e340) - } - 18 => { - let e340 = { - let l331 = *base.add(8).cast::(); - _rt::char_lift(l331 as u32) - }; - V340::PrimChar(e340) - } - 19 => { - let e340 = { - let l332 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l332 as u8) - }; - V340::PrimBool(e340) - } - 20 => { - let e340 = { - let l333 = *base.add(8).cast::<*mut u8>(); - let l334 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len335 = l334; - let bytes335 = _rt::Vec::from_raw_parts( - l333.cast(), - len335, - len335, - ); - _rt::string_lift(bytes335) - }; - V340::PrimString(e340) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e340 = { - let l336 = *base.add(8).cast::<*mut u8>(); - let l337 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len338 = l337; - let bytes338 = _rt::Vec::from_raw_parts( - l336.cast(), - len338, - len338, - ); - let l339 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes338), - }, - l339 as u64, - ) - }; - V340::Handle(e340) - } - }; - v340 - }; - result341.push(e341); - } - _rt::cabi_dealloc( - base341, - len341 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l342 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l343 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base392 = l342; - let len392 = l343; - let mut result392 = _rt::Vec::with_capacity(len392); - for i in 0..len392 { - let base = base392 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e392 = { - let l344 = i32::from(*base.add(0).cast::()); - let l348 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l352 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V391; - let v391 = match l352 { - 0 => { - let e391 = { - let l353 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l354 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base359 = l353; - let len359 = l354; - let mut result359 = _rt::Vec::with_capacity(len359); - for i in 0..len359 { - let base = base359 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e359 = { - let l355 = *base.add(0).cast::<*mut u8>(); - let l356 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len357 = l356; - let bytes357 = _rt::Vec::from_raw_parts( - l355.cast(), - len357, - len357, - ); - let l358 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes357), l358) - }; - result359.push(e359); - } - _rt::cabi_dealloc( - base359, - len359 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result359 - }; - V391::RecordType(e391) - } - 1 => { - let e391 = { - let l360 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l361 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base367 = l360; - let len367 = l361; - let mut result367 = _rt::Vec::with_capacity(len367); - for i in 0..len367 { - let base = base367 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e367 = { - let l362 = *base.add(0).cast::<*mut u8>(); - let l363 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len364 = l363; - let bytes364 = _rt::Vec::from_raw_parts( - l362.cast(), - len364, - len364, - ); - let l365 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes364), - match l365 { - 0 => None, - 1 => { - let e = { - let l366 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l366 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result367.push(e367); - } - _rt::cabi_dealloc( - base367, - len367 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result367 - }; - V391::VariantType(e391) - } - 2 => { - let e391 = { - let l368 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l369 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base373 = l368; - let len373 = l369; - let mut result373 = _rt::Vec::with_capacity(len373); - for i in 0..len373 { - let base = base373 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e373 = { - let l370 = *base.add(0).cast::<*mut u8>(); - let l371 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len372 = l371; - let bytes372 = _rt::Vec::from_raw_parts( - l370.cast(), - len372, - len372, - ); - _rt::string_lift(bytes372) - }; - result373.push(e373); - } - _rt::cabi_dealloc( - base373, - len373 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result373 - }; - V391::EnumType(e391) - } - 3 => { - let e391 = { - let l374 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l375 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base379 = l374; - let len379 = l375; - let mut result379 = _rt::Vec::with_capacity(len379); - for i in 0..len379 { - let base = base379 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e379 = { - let l376 = *base.add(0).cast::<*mut u8>(); - let l377 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len378 = l377; - let bytes378 = _rt::Vec::from_raw_parts( - l376.cast(), - len378, - len378, - ); - _rt::string_lift(bytes378) - }; - result379.push(e379); - } - _rt::cabi_dealloc( - base379, - len379 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result379 - }; - V391::FlagsType(e391) - } - 4 => { - let e391 = { - let l380 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l381 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len382 = l381; - _rt::Vec::from_raw_parts(l380.cast(), len382, len382) - }; - V391::TupleType(e391) - } - 5 => { - let e391 = { - let l383 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l383 - }; - V391::ListType(e391) - } - 6 => { - let e391 = { - let l384 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l384 - }; - V391::OptionType(e391) - } - 7 => { - let e391 = { - let l385 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l387 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l385 { - 0 => None, - 1 => { - let e = { - let l386 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l386 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l387 { - 0 => None, - 1 => { - let e = { - let l388 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l388 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V391::ResultType(e391) - } - 8 => V391::PrimU8Type, - 9 => V391::PrimU16Type, - 10 => V391::PrimU32Type, - 11 => V391::PrimU64Type, - 12 => V391::PrimS8Type, - 13 => V391::PrimS16Type, - 14 => V391::PrimS32Type, - 15 => V391::PrimS64Type, - 16 => V391::PrimF32Type, - 17 => V391::PrimF64Type, - 18 => V391::PrimCharType, - 19 => V391::PrimBoolType, - 20 => V391::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e391 = { - let l389 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l390 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l389 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l390 as u8, - ), - ) - }; - V391::HandleType(e391) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l344 { - 0 => None, - 1 => { - let e = { - let l345 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l346 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len347 = l346; - let bytes347 = _rt::Vec::from_raw_parts( - l345.cast(), - len347, - len347, - ); - _rt::string_lift(bytes347) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l348 { - 0 => None, - 1 => { - let e = { - let l349 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l350 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len351 = l350; - let bytes351 = _rt::Vec::from_raw_parts( - l349.cast(), - len351, - len351, - ); - _rt::string_lift(bytes351) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v391, - } - }; - result392.push(e392); - } - _rt::cabi_dealloc( - base392, - len392 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - LocalAgentConfigEntry { - path: result293, - value: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result341, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result392, - }, - }, - } - }; - result393.push(e393); - } - _rt::cabi_dealloc( - base393, - len393 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - CreateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l224 as u64, - nanoseconds: l225 as u32, - }, - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l226 as u64, - low_bits: l227 as u64, - }, - }, - agent_id: _rt::string_lift(bytes230), - }, - component_revision: l231 as u64, - args: result237, - env: result246, - created_by: super::super::super::golem::core::types::AccountId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l247 as u64, - low_bits: l248 as u64, - }, - }, - environment_id: super::super::super::golem::api::host::EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l249 as u64, - low_bits: l250 as u64, - }, - }, - parent: match l251 { - 0 => None, - 1 => { - let e = { - let l252 = *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l253 = *base - .add(96 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l254 = *base - .add(104 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l255 = *base - .add(104 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len256 = l255; - let bytes256 = _rt::Vec::from_raw_parts( - l254.cast(), - len256, - len256, - ); - super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l252 as u64, - low_bits: l253 as u64, - }, - }, - agent_id: _rt::string_lift(bytes256), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - component_size: l257 as u64, - initial_total_linear_memory_size: l258 as u64, - initial_active_plugins: result276, - config_vars: result285, - local_agent_config: result393, - } - }; - PublicOplogEntry::Create(e2893) - } - 1 => { - let e2893 = { - let l394 = *base.add(8).cast::(); - let l395 = *base.add(16).cast::(); - let l396 = *base.add(24).cast::<*mut u8>(); - let l397 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len398 = l397; - let bytes398 = _rt::Vec::from_raw_parts( - l396.cast(), - len398, - len398, - ); - let l399 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l400 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base446 = l399; - let len446 = l400; - let mut result446 = _rt::Vec::with_capacity(len446); - for i in 0..len446 { - let base = base446 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e446 = { - let l401 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V445; - let v445 = match l401 { - 0 => { - let e445 = { - let l402 = *base.add(8).cast::<*mut u8>(); - let l403 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len404 = l403; - _rt::Vec::from_raw_parts(l402.cast(), len404, len404) - }; - V445::RecordValue(e445) - } - 1 => { - let e445 = { - let l405 = *base.add(8).cast::(); - let l406 = i32::from(*base.add(12).cast::()); - ( - l405 as u32, - match l406 { - 0 => None, - 1 => { - let e = { - let l407 = *base.add(16).cast::(); - l407 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V445::VariantValue(e445) - } - 2 => { - let e445 = { - let l408 = *base.add(8).cast::(); - l408 as u32 - }; - V445::EnumValue(e445) - } - 3 => { - let e445 = { - let l409 = *base.add(8).cast::<*mut u8>(); - let l410 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base412 = l409; - let len412 = l410; - let mut result412 = _rt::Vec::with_capacity(len412); - for i in 0..len412 { - let base = base412.add(i * 1); - let e412 = { - let l411 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l411 as u8) - }; - result412.push(e412); - } - _rt::cabi_dealloc(base412, len412 * 1, 1); - result412 - }; - V445::FlagsValue(e445) - } - 4 => { - let e445 = { - let l413 = *base.add(8).cast::<*mut u8>(); - let l414 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len415 = l414; - _rt::Vec::from_raw_parts(l413.cast(), len415, len415) - }; - V445::TupleValue(e445) - } - 5 => { - let e445 = { - let l416 = *base.add(8).cast::<*mut u8>(); - let l417 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len418 = l417; - _rt::Vec::from_raw_parts(l416.cast(), len418, len418) - }; - V445::ListValue(e445) - } - 6 => { - let e445 = { - let l419 = i32::from(*base.add(8).cast::()); - match l419 { - 0 => None, - 1 => { - let e = { - let l420 = *base.add(12).cast::(); - l420 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V445::OptionValue(e445) - } - 7 => { - let e445 = { - let l421 = i32::from(*base.add(8).cast::()); - match l421 { - 0 => { - let e = { - let l422 = i32::from(*base.add(12).cast::()); - match l422 { - 0 => None, - 1 => { - let e = { - let l423 = *base.add(16).cast::(); - l423 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l424 = i32::from(*base.add(12).cast::()); - match l424 { - 0 => None, - 1 => { - let e = { - let l425 = *base.add(16).cast::(); - l425 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V445::ResultValue(e445) - } - 8 => { - let e445 = { - let l426 = i32::from(*base.add(8).cast::()); - l426 as u8 - }; - V445::PrimU8(e445) - } - 9 => { - let e445 = { - let l427 = i32::from(*base.add(8).cast::()); - l427 as u16 - }; - V445::PrimU16(e445) - } - 10 => { - let e445 = { - let l428 = *base.add(8).cast::(); - l428 as u32 - }; - V445::PrimU32(e445) - } - 11 => { - let e445 = { - let l429 = *base.add(8).cast::(); - l429 as u64 - }; - V445::PrimU64(e445) - } - 12 => { - let e445 = { - let l430 = i32::from(*base.add(8).cast::()); - l430 as i8 - }; - V445::PrimS8(e445) - } - 13 => { - let e445 = { - let l431 = i32::from(*base.add(8).cast::()); - l431 as i16 - }; - V445::PrimS16(e445) - } - 14 => { - let e445 = { - let l432 = *base.add(8).cast::(); - l432 - }; - V445::PrimS32(e445) - } - 15 => { - let e445 = { - let l433 = *base.add(8).cast::(); - l433 - }; - V445::PrimS64(e445) - } - 16 => { - let e445 = { - let l434 = *base.add(8).cast::(); - l434 - }; - V445::PrimFloat32(e445) - } - 17 => { - let e445 = { - let l435 = *base.add(8).cast::(); - l435 - }; - V445::PrimFloat64(e445) - } - 18 => { - let e445 = { - let l436 = *base.add(8).cast::(); - _rt::char_lift(l436 as u32) - }; - V445::PrimChar(e445) - } - 19 => { - let e445 = { - let l437 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l437 as u8) - }; - V445::PrimBool(e445) - } - 20 => { - let e445 = { - let l438 = *base.add(8).cast::<*mut u8>(); - let l439 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len440 = l439; - let bytes440 = _rt::Vec::from_raw_parts( - l438.cast(), - len440, - len440, - ); - _rt::string_lift(bytes440) - }; - V445::PrimString(e445) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e445 = { - let l441 = *base.add(8).cast::<*mut u8>(); - let l442 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len443 = l442; - let bytes443 = _rt::Vec::from_raw_parts( - l441.cast(), - len443, - len443, - ); - let l444 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes443), - }, - l444 as u64, - ) - }; - V445::Handle(e445) - } - }; - v445 - }; - result446.push(e446); - } - _rt::cabi_dealloc( - base446, - len446 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l447 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l448 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base497 = l447; - let len497 = l448; - let mut result497 = _rt::Vec::with_capacity(len497); - for i in 0..len497 { - let base = base497 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e497 = { - let l449 = i32::from(*base.add(0).cast::()); - let l453 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l457 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V496; - let v496 = match l457 { - 0 => { - let e496 = { - let l458 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l459 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base464 = l458; - let len464 = l459; - let mut result464 = _rt::Vec::with_capacity(len464); - for i in 0..len464 { - let base = base464 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e464 = { - let l460 = *base.add(0).cast::<*mut u8>(); - let l461 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len462 = l461; - let bytes462 = _rt::Vec::from_raw_parts( - l460.cast(), - len462, - len462, - ); - let l463 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes462), l463) - }; - result464.push(e464); - } - _rt::cabi_dealloc( - base464, - len464 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result464 - }; - V496::RecordType(e496) - } - 1 => { - let e496 = { - let l465 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l466 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base472 = l465; - let len472 = l466; - let mut result472 = _rt::Vec::with_capacity(len472); - for i in 0..len472 { - let base = base472 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e472 = { - let l467 = *base.add(0).cast::<*mut u8>(); - let l468 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len469 = l468; - let bytes469 = _rt::Vec::from_raw_parts( - l467.cast(), - len469, - len469, - ); - let l470 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes469), - match l470 { - 0 => None, - 1 => { - let e = { - let l471 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l471 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result472.push(e472); - } - _rt::cabi_dealloc( - base472, - len472 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result472 - }; - V496::VariantType(e496) - } - 2 => { - let e496 = { - let l473 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l474 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base478 = l473; - let len478 = l474; - let mut result478 = _rt::Vec::with_capacity(len478); - for i in 0..len478 { - let base = base478 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e478 = { - let l475 = *base.add(0).cast::<*mut u8>(); - let l476 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len477 = l476; - let bytes477 = _rt::Vec::from_raw_parts( - l475.cast(), - len477, - len477, - ); - _rt::string_lift(bytes477) - }; - result478.push(e478); - } - _rt::cabi_dealloc( - base478, - len478 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result478 - }; - V496::EnumType(e496) - } - 3 => { - let e496 = { - let l479 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l480 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base484 = l479; - let len484 = l480; - let mut result484 = _rt::Vec::with_capacity(len484); - for i in 0..len484 { - let base = base484 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e484 = { - let l481 = *base.add(0).cast::<*mut u8>(); - let l482 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len483 = l482; - let bytes483 = _rt::Vec::from_raw_parts( - l481.cast(), - len483, - len483, - ); - _rt::string_lift(bytes483) - }; - result484.push(e484); - } - _rt::cabi_dealloc( - base484, - len484 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result484 - }; - V496::FlagsType(e496) - } - 4 => { - let e496 = { - let l485 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l486 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len487 = l486; - _rt::Vec::from_raw_parts(l485.cast(), len487, len487) - }; - V496::TupleType(e496) - } - 5 => { - let e496 = { - let l488 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l488 - }; - V496::ListType(e496) - } - 6 => { - let e496 = { - let l489 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l489 - }; - V496::OptionType(e496) - } - 7 => { - let e496 = { - let l490 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l492 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l490 { - 0 => None, - 1 => { - let e = { - let l491 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l491 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l492 { - 0 => None, - 1 => { - let e = { - let l493 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l493 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V496::ResultType(e496) - } - 8 => V496::PrimU8Type, - 9 => V496::PrimU16Type, - 10 => V496::PrimU32Type, - 11 => V496::PrimU64Type, - 12 => V496::PrimS8Type, - 13 => V496::PrimS16Type, - 14 => V496::PrimS32Type, - 15 => V496::PrimS64Type, - 16 => V496::PrimF32Type, - 17 => V496::PrimF64Type, - 18 => V496::PrimCharType, - 19 => V496::PrimBoolType, - 20 => V496::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e496 = { - let l494 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l495 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l494 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l495 as u8, - ), - ) - }; - V496::HandleType(e496) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l449 { - 0 => None, - 1 => { - let e = { - let l450 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l451 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len452 = l451; - let bytes452 = _rt::Vec::from_raw_parts( - l450.cast(), - len452, - len452, - ); - _rt::string_lift(bytes452) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l453 { - 0 => None, - 1 => { - let e = { - let l454 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l455 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len456 = l455; - let bytes456 = _rt::Vec::from_raw_parts( - l454.cast(), - len456, - len456, - ); - _rt::string_lift(bytes456) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v496, - } - }; - result497.push(e497); - } - _rt::cabi_dealloc( - base497, - len497 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l498 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l499 = *base - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base545 = l498; - let len545 = l499; - let mut result545 = _rt::Vec::with_capacity(len545); - for i in 0..len545 { - let base = base545 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e545 = { - let l500 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V544; - let v544 = match l500 { - 0 => { - let e544 = { - let l501 = *base.add(8).cast::<*mut u8>(); - let l502 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len503 = l502; - _rt::Vec::from_raw_parts(l501.cast(), len503, len503) - }; - V544::RecordValue(e544) - } - 1 => { - let e544 = { - let l504 = *base.add(8).cast::(); - let l505 = i32::from(*base.add(12).cast::()); - ( - l504 as u32, - match l505 { - 0 => None, - 1 => { - let e = { - let l506 = *base.add(16).cast::(); - l506 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V544::VariantValue(e544) - } - 2 => { - let e544 = { - let l507 = *base.add(8).cast::(); - l507 as u32 - }; - V544::EnumValue(e544) - } - 3 => { - let e544 = { - let l508 = *base.add(8).cast::<*mut u8>(); - let l509 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base511 = l508; - let len511 = l509; - let mut result511 = _rt::Vec::with_capacity(len511); - for i in 0..len511 { - let base = base511.add(i * 1); - let e511 = { - let l510 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l510 as u8) - }; - result511.push(e511); - } - _rt::cabi_dealloc(base511, len511 * 1, 1); - result511 - }; - V544::FlagsValue(e544) - } - 4 => { - let e544 = { - let l512 = *base.add(8).cast::<*mut u8>(); - let l513 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len514 = l513; - _rt::Vec::from_raw_parts(l512.cast(), len514, len514) - }; - V544::TupleValue(e544) - } - 5 => { - let e544 = { - let l515 = *base.add(8).cast::<*mut u8>(); - let l516 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len517 = l516; - _rt::Vec::from_raw_parts(l515.cast(), len517, len517) - }; - V544::ListValue(e544) - } - 6 => { - let e544 = { - let l518 = i32::from(*base.add(8).cast::()); - match l518 { - 0 => None, - 1 => { - let e = { - let l519 = *base.add(12).cast::(); - l519 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V544::OptionValue(e544) - } - 7 => { - let e544 = { - let l520 = i32::from(*base.add(8).cast::()); - match l520 { - 0 => { - let e = { - let l521 = i32::from(*base.add(12).cast::()); - match l521 { - 0 => None, - 1 => { - let e = { - let l522 = *base.add(16).cast::(); - l522 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l523 = i32::from(*base.add(12).cast::()); - match l523 { - 0 => None, - 1 => { - let e = { - let l524 = *base.add(16).cast::(); - l524 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V544::ResultValue(e544) - } - 8 => { - let e544 = { - let l525 = i32::from(*base.add(8).cast::()); - l525 as u8 - }; - V544::PrimU8(e544) - } - 9 => { - let e544 = { - let l526 = i32::from(*base.add(8).cast::()); - l526 as u16 - }; - V544::PrimU16(e544) - } - 10 => { - let e544 = { - let l527 = *base.add(8).cast::(); - l527 as u32 - }; - V544::PrimU32(e544) - } - 11 => { - let e544 = { - let l528 = *base.add(8).cast::(); - l528 as u64 - }; - V544::PrimU64(e544) - } - 12 => { - let e544 = { - let l529 = i32::from(*base.add(8).cast::()); - l529 as i8 - }; - V544::PrimS8(e544) - } - 13 => { - let e544 = { - let l530 = i32::from(*base.add(8).cast::()); - l530 as i16 - }; - V544::PrimS16(e544) - } - 14 => { - let e544 = { - let l531 = *base.add(8).cast::(); - l531 - }; - V544::PrimS32(e544) - } - 15 => { - let e544 = { - let l532 = *base.add(8).cast::(); - l532 - }; - V544::PrimS64(e544) - } - 16 => { - let e544 = { - let l533 = *base.add(8).cast::(); - l533 - }; - V544::PrimFloat32(e544) - } - 17 => { - let e544 = { - let l534 = *base.add(8).cast::(); - l534 - }; - V544::PrimFloat64(e544) - } - 18 => { - let e544 = { - let l535 = *base.add(8).cast::(); - _rt::char_lift(l535 as u32) - }; - V544::PrimChar(e544) - } - 19 => { - let e544 = { - let l536 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l536 as u8) - }; - V544::PrimBool(e544) - } - 20 => { - let e544 = { - let l537 = *base.add(8).cast::<*mut u8>(); - let l538 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len539 = l538; - let bytes539 = _rt::Vec::from_raw_parts( - l537.cast(), - len539, - len539, - ); - _rt::string_lift(bytes539) - }; - V544::PrimString(e544) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e544 = { - let l540 = *base.add(8).cast::<*mut u8>(); - let l541 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len542 = l541; - let bytes542 = _rt::Vec::from_raw_parts( - l540.cast(), - len542, - len542, - ); - let l543 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes542), - }, - l543 as u64, - ) - }; - V544::Handle(e544) - } - }; - v544 - }; - result545.push(e545); - } - _rt::cabi_dealloc( - base545, - len545 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l546 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l547 = *base - .add(24 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base596 = l546; - let len596 = l547; - let mut result596 = _rt::Vec::with_capacity(len596); - for i in 0..len596 { - let base = base596 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e596 = { - let l548 = i32::from(*base.add(0).cast::()); - let l552 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l556 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V595; - let v595 = match l556 { - 0 => { - let e595 = { - let l557 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l558 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base563 = l557; - let len563 = l558; - let mut result563 = _rt::Vec::with_capacity(len563); - for i in 0..len563 { - let base = base563 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e563 = { - let l559 = *base.add(0).cast::<*mut u8>(); - let l560 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len561 = l560; - let bytes561 = _rt::Vec::from_raw_parts( - l559.cast(), - len561, - len561, - ); - let l562 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes561), l562) - }; - result563.push(e563); - } - _rt::cabi_dealloc( - base563, - len563 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result563 - }; - V595::RecordType(e595) - } - 1 => { - let e595 = { - let l564 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l565 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base571 = l564; - let len571 = l565; - let mut result571 = _rt::Vec::with_capacity(len571); - for i in 0..len571 { - let base = base571 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e571 = { - let l566 = *base.add(0).cast::<*mut u8>(); - let l567 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len568 = l567; - let bytes568 = _rt::Vec::from_raw_parts( - l566.cast(), - len568, - len568, - ); - let l569 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes568), - match l569 { - 0 => None, - 1 => { - let e = { - let l570 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l570 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result571.push(e571); - } - _rt::cabi_dealloc( - base571, - len571 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result571 - }; - V595::VariantType(e595) - } - 2 => { - let e595 = { - let l572 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l573 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base577 = l572; - let len577 = l573; - let mut result577 = _rt::Vec::with_capacity(len577); - for i in 0..len577 { - let base = base577 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e577 = { - let l574 = *base.add(0).cast::<*mut u8>(); - let l575 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len576 = l575; - let bytes576 = _rt::Vec::from_raw_parts( - l574.cast(), - len576, - len576, - ); - _rt::string_lift(bytes576) - }; - result577.push(e577); - } - _rt::cabi_dealloc( - base577, - len577 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result577 - }; - V595::EnumType(e595) - } - 3 => { - let e595 = { - let l578 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l579 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base583 = l578; - let len583 = l579; - let mut result583 = _rt::Vec::with_capacity(len583); - for i in 0..len583 { - let base = base583 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e583 = { - let l580 = *base.add(0).cast::<*mut u8>(); - let l581 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len582 = l581; - let bytes582 = _rt::Vec::from_raw_parts( - l580.cast(), - len582, - len582, - ); - _rt::string_lift(bytes582) - }; - result583.push(e583); - } - _rt::cabi_dealloc( - base583, - len583 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result583 - }; - V595::FlagsType(e595) - } - 4 => { - let e595 = { - let l584 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l585 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len586 = l585; - _rt::Vec::from_raw_parts(l584.cast(), len586, len586) - }; - V595::TupleType(e595) - } - 5 => { - let e595 = { - let l587 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l587 - }; - V595::ListType(e595) - } - 6 => { - let e595 = { - let l588 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l588 - }; - V595::OptionType(e595) - } - 7 => { - let e595 = { - let l589 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l591 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l589 { - 0 => None, - 1 => { - let e = { - let l590 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l590 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l591 { - 0 => None, - 1 => { - let e = { - let l592 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l592 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V595::ResultType(e595) - } - 8 => V595::PrimU8Type, - 9 => V595::PrimU16Type, - 10 => V595::PrimU32Type, - 11 => V595::PrimU64Type, - 12 => V595::PrimS8Type, - 13 => V595::PrimS16Type, - 14 => V595::PrimS32Type, - 15 => V595::PrimS64Type, - 16 => V595::PrimF32Type, - 17 => V595::PrimF64Type, - 18 => V595::PrimCharType, - 19 => V595::PrimBoolType, - 20 => V595::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e595 = { - let l593 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l594 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l593 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l594 as u8, - ), - ) - }; - V595::HandleType(e595) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l548 { - 0 => None, - 1 => { - let e = { - let l549 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l550 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len551 = l550; - let bytes551 = _rt::Vec::from_raw_parts( - l549.cast(), - len551, - len551, - ); - _rt::string_lift(bytes551) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l552 { - 0 => None, - 1 => { - let e = { - let l553 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l554 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len555 = l554; - let bytes555 = _rt::Vec::from_raw_parts( - l553.cast(), - len555, - len555, - ); - _rt::string_lift(bytes555) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v595, - } - }; - result596.push(e596); - } - _rt::cabi_dealloc( - base596, - len596 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l597 = i32::from( - *base - .add(24 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let v602 = match l597 { - 0 => WrappedFunctionType::ReadLocal, - 1 => WrappedFunctionType::WriteLocal, - 2 => WrappedFunctionType::ReadRemote, - 3 => WrappedFunctionType::WriteRemote, - 4 => { - let e602 = { - let l598 = i32::from( - *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l598 { - 0 => None, - 1 => { - let e = { - let l599 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l599 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteBatched(e602) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e602 = { - let l600 = i32::from( - *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l600 { - 0 => None, - 1 => { - let e = { - let l601 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l601 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteTransaction(e602) - } - }; - HostCallParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l394 as u64, - nanoseconds: l395 as u32, - }, - function_name: _rt::string_lift(bytes398), - request: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result446, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result497, - }, - }, - response: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result545, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result596, - }, - }, - wrapped_function_type: v602, - } - }; - PublicOplogEntry::HostCall(e2893) - } - 2 => { - let e2893 = { - let l603 = *base.add(8).cast::(); - let l604 = *base.add(16).cast::(); - let l605 = i32::from(*base.add(24).cast::()); - let v1321 = match l605 { - 0 => { - let e1321 = { - let l606 = *base.add(32).cast::<*mut u8>(); - let l607 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len608 = l607; - let bytes608 = _rt::Vec::from_raw_parts( - l606.cast(), - len608, - len608, - ); - let l609 = i32::from( - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V765; - let v765 = match l609 { - 0 => { - let e765 = { - let l610 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l611 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base685 = l610; - let len685 = l611; - let mut result685 = _rt::Vec::with_capacity(len685); - for i in 0..len685 { - let base = base685 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e685 = { - let l612 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V684; - let v684 = match l612 { - 0 => { - let e684 = { - let l613 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l614 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base660 = l613; - let len660 = l614; - let mut result660 = _rt::Vec::with_capacity(len660); - for i in 0..len660 { - let base = base660 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e660 = { - let l615 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V659; - let v659 = match l615 { - 0 => { - let e659 = { - let l616 = *base.add(8).cast::<*mut u8>(); - let l617 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len618 = l617; - _rt::Vec::from_raw_parts(l616.cast(), len618, len618) - }; - V659::RecordValue(e659) - } - 1 => { - let e659 = { - let l619 = *base.add(8).cast::(); - let l620 = i32::from(*base.add(12).cast::()); - ( - l619 as u32, - match l620 { - 0 => None, - 1 => { - let e = { - let l621 = *base.add(16).cast::(); - l621 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V659::VariantValue(e659) - } - 2 => { - let e659 = { - let l622 = *base.add(8).cast::(); - l622 as u32 - }; - V659::EnumValue(e659) - } - 3 => { - let e659 = { - let l623 = *base.add(8).cast::<*mut u8>(); - let l624 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base626 = l623; - let len626 = l624; - let mut result626 = _rt::Vec::with_capacity(len626); - for i in 0..len626 { - let base = base626.add(i * 1); - let e626 = { - let l625 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l625 as u8) - }; - result626.push(e626); - } - _rt::cabi_dealloc(base626, len626 * 1, 1); - result626 - }; - V659::FlagsValue(e659) - } - 4 => { - let e659 = { - let l627 = *base.add(8).cast::<*mut u8>(); - let l628 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len629 = l628; - _rt::Vec::from_raw_parts(l627.cast(), len629, len629) - }; - V659::TupleValue(e659) - } - 5 => { - let e659 = { - let l630 = *base.add(8).cast::<*mut u8>(); - let l631 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len632 = l631; - _rt::Vec::from_raw_parts(l630.cast(), len632, len632) - }; - V659::ListValue(e659) - } - 6 => { - let e659 = { - let l633 = i32::from(*base.add(8).cast::()); - match l633 { - 0 => None, - 1 => { - let e = { - let l634 = *base.add(12).cast::(); - l634 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V659::OptionValue(e659) - } - 7 => { - let e659 = { - let l635 = i32::from(*base.add(8).cast::()); - match l635 { - 0 => { - let e = { - let l636 = i32::from(*base.add(12).cast::()); - match l636 { - 0 => None, - 1 => { - let e = { - let l637 = *base.add(16).cast::(); - l637 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l638 = i32::from(*base.add(12).cast::()); - match l638 { - 0 => None, - 1 => { - let e = { - let l639 = *base.add(16).cast::(); - l639 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V659::ResultValue(e659) - } - 8 => { - let e659 = { - let l640 = i32::from(*base.add(8).cast::()); - l640 as u8 - }; - V659::PrimU8(e659) - } - 9 => { - let e659 = { - let l641 = i32::from(*base.add(8).cast::()); - l641 as u16 - }; - V659::PrimU16(e659) - } - 10 => { - let e659 = { - let l642 = *base.add(8).cast::(); - l642 as u32 - }; - V659::PrimU32(e659) - } - 11 => { - let e659 = { - let l643 = *base.add(8).cast::(); - l643 as u64 - }; - V659::PrimU64(e659) - } - 12 => { - let e659 = { - let l644 = i32::from(*base.add(8).cast::()); - l644 as i8 - }; - V659::PrimS8(e659) - } - 13 => { - let e659 = { - let l645 = i32::from(*base.add(8).cast::()); - l645 as i16 - }; - V659::PrimS16(e659) - } - 14 => { - let e659 = { - let l646 = *base.add(8).cast::(); - l646 - }; - V659::PrimS32(e659) - } - 15 => { - let e659 = { - let l647 = *base.add(8).cast::(); - l647 - }; - V659::PrimS64(e659) - } - 16 => { - let e659 = { - let l648 = *base.add(8).cast::(); - l648 - }; - V659::PrimFloat32(e659) - } - 17 => { - let e659 = { - let l649 = *base.add(8).cast::(); - l649 - }; - V659::PrimFloat64(e659) - } - 18 => { - let e659 = { - let l650 = *base.add(8).cast::(); - _rt::char_lift(l650 as u32) - }; - V659::PrimChar(e659) - } - 19 => { - let e659 = { - let l651 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l651 as u8) - }; - V659::PrimBool(e659) - } - 20 => { - let e659 = { - let l652 = *base.add(8).cast::<*mut u8>(); - let l653 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len654 = l653; - let bytes654 = _rt::Vec::from_raw_parts( - l652.cast(), - len654, - len654, - ); - _rt::string_lift(bytes654) - }; - V659::PrimString(e659) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e659 = { - let l655 = *base.add(8).cast::<*mut u8>(); - let l656 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len657 = l656; - let bytes657 = _rt::Vec::from_raw_parts( - l655.cast(), - len657, - len657, - ); - let l658 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes657), - }, - l658 as u64, - ) - }; - V659::Handle(e659) - } - }; - v659 - }; - result660.push(e660); - } - _rt::cabi_dealloc( - base660, - len660 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result660, - } - }; - V684::ComponentModel(e684) - } - 1 => { - let e684 = { - let l661 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V672; - let v672 = match l661 { - 0 => { - let e672 = { - let l662 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l663 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len664 = l663; - let bytes664 = _rt::Vec::from_raw_parts( - l662.cast(), - len664, - len664, - ); - _rt::string_lift(bytes664) - }; - V672::Url(e672) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e672 = { - let l665 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l666 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len667 = l666; - let bytes667 = _rt::Vec::from_raw_parts( - l665.cast(), - len667, - len667, - ); - let l668 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes667), - text_type: match l668 { - 0 => None, - 1 => { - let e = { - let l669 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l670 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len671 = l670; - let bytes671 = _rt::Vec::from_raw_parts( - l669.cast(), - len671, - len671, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes671), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V672::Inline(e672) - } - }; - v672 - }; - V684::UnstructuredText(e684) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e684 = { - let l673 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V683; - let v683 = match l673 { - 0 => { - let e683 = { - let l674 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l675 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len676 = l675; - let bytes676 = _rt::Vec::from_raw_parts( - l674.cast(), - len676, - len676, - ); - _rt::string_lift(bytes676) - }; - V683::Url(e683) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e683 = { - let l677 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l678 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len679 = l678; - let l680 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l681 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len682 = l681; - let bytes682 = _rt::Vec::from_raw_parts( - l680.cast(), - len682, - len682, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l677.cast(), len679, len679), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes682), - }, - } - }; - V683::Inline(e683) - } - }; - v683 - }; - V684::UnstructuredBinary(e684) - } - }; - v684 - }; - result685.push(e685); - } - _rt::cabi_dealloc( - base685, - len685 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result685 - }; - V765::Tuple(e765) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e765 = { - let l686 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l687 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base764 = l686; - let len764 = l687; - let mut result764 = _rt::Vec::with_capacity(len764); - for i in 0..len764 { - let base = base764 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e764 = { - let l688 = *base.add(0).cast::<*mut u8>(); - let l689 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len690 = l689; - let bytes690 = _rt::Vec::from_raw_parts( - l688.cast(), - len690, - len690, - ); - let l691 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V763; - let v763 = match l691 { - 0 => { - let e763 = { - let l692 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l693 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base739 = l692; - let len739 = l693; - let mut result739 = _rt::Vec::with_capacity(len739); - for i in 0..len739 { - let base = base739 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e739 = { - let l694 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V738; - let v738 = match l694 { - 0 => { - let e738 = { - let l695 = *base.add(8).cast::<*mut u8>(); - let l696 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len697 = l696; - _rt::Vec::from_raw_parts(l695.cast(), len697, len697) - }; - V738::RecordValue(e738) - } - 1 => { - let e738 = { - let l698 = *base.add(8).cast::(); - let l699 = i32::from(*base.add(12).cast::()); - ( - l698 as u32, - match l699 { - 0 => None, - 1 => { - let e = { - let l700 = *base.add(16).cast::(); - l700 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V738::VariantValue(e738) - } - 2 => { - let e738 = { - let l701 = *base.add(8).cast::(); - l701 as u32 - }; - V738::EnumValue(e738) - } - 3 => { - let e738 = { - let l702 = *base.add(8).cast::<*mut u8>(); - let l703 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base705 = l702; - let len705 = l703; - let mut result705 = _rt::Vec::with_capacity(len705); - for i in 0..len705 { - let base = base705.add(i * 1); - let e705 = { - let l704 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l704 as u8) - }; - result705.push(e705); - } - _rt::cabi_dealloc(base705, len705 * 1, 1); - result705 - }; - V738::FlagsValue(e738) - } - 4 => { - let e738 = { - let l706 = *base.add(8).cast::<*mut u8>(); - let l707 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len708 = l707; - _rt::Vec::from_raw_parts(l706.cast(), len708, len708) - }; - V738::TupleValue(e738) - } - 5 => { - let e738 = { - let l709 = *base.add(8).cast::<*mut u8>(); - let l710 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len711 = l710; - _rt::Vec::from_raw_parts(l709.cast(), len711, len711) - }; - V738::ListValue(e738) - } - 6 => { - let e738 = { - let l712 = i32::from(*base.add(8).cast::()); - match l712 { - 0 => None, - 1 => { - let e = { - let l713 = *base.add(12).cast::(); - l713 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V738::OptionValue(e738) - } - 7 => { - let e738 = { - let l714 = i32::from(*base.add(8).cast::()); - match l714 { - 0 => { - let e = { - let l715 = i32::from(*base.add(12).cast::()); - match l715 { - 0 => None, - 1 => { - let e = { - let l716 = *base.add(16).cast::(); - l716 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l717 = i32::from(*base.add(12).cast::()); - match l717 { - 0 => None, - 1 => { - let e = { - let l718 = *base.add(16).cast::(); - l718 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V738::ResultValue(e738) - } - 8 => { - let e738 = { - let l719 = i32::from(*base.add(8).cast::()); - l719 as u8 - }; - V738::PrimU8(e738) - } - 9 => { - let e738 = { - let l720 = i32::from(*base.add(8).cast::()); - l720 as u16 - }; - V738::PrimU16(e738) - } - 10 => { - let e738 = { - let l721 = *base.add(8).cast::(); - l721 as u32 - }; - V738::PrimU32(e738) - } - 11 => { - let e738 = { - let l722 = *base.add(8).cast::(); - l722 as u64 - }; - V738::PrimU64(e738) - } - 12 => { - let e738 = { - let l723 = i32::from(*base.add(8).cast::()); - l723 as i8 - }; - V738::PrimS8(e738) - } - 13 => { - let e738 = { - let l724 = i32::from(*base.add(8).cast::()); - l724 as i16 - }; - V738::PrimS16(e738) - } - 14 => { - let e738 = { - let l725 = *base.add(8).cast::(); - l725 - }; - V738::PrimS32(e738) - } - 15 => { - let e738 = { - let l726 = *base.add(8).cast::(); - l726 - }; - V738::PrimS64(e738) - } - 16 => { - let e738 = { - let l727 = *base.add(8).cast::(); - l727 - }; - V738::PrimFloat32(e738) - } - 17 => { - let e738 = { - let l728 = *base.add(8).cast::(); - l728 - }; - V738::PrimFloat64(e738) - } - 18 => { - let e738 = { - let l729 = *base.add(8).cast::(); - _rt::char_lift(l729 as u32) - }; - V738::PrimChar(e738) - } - 19 => { - let e738 = { - let l730 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l730 as u8) - }; - V738::PrimBool(e738) - } - 20 => { - let e738 = { - let l731 = *base.add(8).cast::<*mut u8>(); - let l732 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len733 = l732; - let bytes733 = _rt::Vec::from_raw_parts( - l731.cast(), - len733, - len733, - ); - _rt::string_lift(bytes733) - }; - V738::PrimString(e738) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e738 = { - let l734 = *base.add(8).cast::<*mut u8>(); - let l735 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len736 = l735; - let bytes736 = _rt::Vec::from_raw_parts( - l734.cast(), - len736, - len736, - ); - let l737 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes736), - }, - l737 as u64, - ) - }; - V738::Handle(e738) - } - }; - v738 - }; - result739.push(e739); - } - _rt::cabi_dealloc( - base739, - len739 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result739, - } - }; - V763::ComponentModel(e763) - } - 1 => { - let e763 = { - let l740 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V751; - let v751 = match l740 { - 0 => { - let e751 = { - let l741 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l742 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len743 = l742; - let bytes743 = _rt::Vec::from_raw_parts( - l741.cast(), - len743, - len743, - ); - _rt::string_lift(bytes743) - }; - V751::Url(e751) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e751 = { - let l744 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l745 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len746 = l745; - let bytes746 = _rt::Vec::from_raw_parts( - l744.cast(), - len746, - len746, - ); - let l747 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes746), - text_type: match l747 { - 0 => None, - 1 => { - let e = { - let l748 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l749 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len750 = l749; - let bytes750 = _rt::Vec::from_raw_parts( - l748.cast(), - len750, - len750, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes750), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V751::Inline(e751) - } - }; - v751 - }; - V763::UnstructuredText(e763) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e763 = { - let l752 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V762; - let v762 = match l752 { - 0 => { - let e762 = { - let l753 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l754 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len755 = l754; - let bytes755 = _rt::Vec::from_raw_parts( - l753.cast(), - len755, - len755, - ); - _rt::string_lift(bytes755) - }; - V762::Url(e762) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e762 = { - let l756 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l757 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len758 = l757; - let l759 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l760 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len761 = l760; - let bytes761 = _rt::Vec::from_raw_parts( - l759.cast(), - len761, - len761, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l756.cast(), len758, len758), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes761), - }, - } - }; - V762::Inline(e762) - } - }; - v762 - }; - V763::UnstructuredBinary(e763) - } - }; - (_rt::string_lift(bytes690), v763) - }; - result764.push(e764); - } - _rt::cabi_dealloc( - base764, - len764 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result764 - }; - V765::Multimodal(e765) - } - }; - let l766 = i32::from( - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V913; - let v913 = match l766 { - 0 => { - let e913 = { - let l767 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l768 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base839 = l767; - let len839 = l768; - let mut result839 = _rt::Vec::with_capacity(len839); - for i in 0..len839 { - let base = base839 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e839 = { - let l769 = *base.add(0).cast::<*mut u8>(); - let l770 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len771 = l770; - let bytes771 = _rt::Vec::from_raw_parts( - l769.cast(), - len771, - len771, - ); - let l772 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V838; - let v838 = match l772 { - 0 => { - let e838 = { - let l773 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l774 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base823 = l773; - let len823 = l774; - let mut result823 = _rt::Vec::with_capacity(len823); - for i in 0..len823 { - let base = base823 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e823 = { - let l775 = i32::from(*base.add(0).cast::()); - let l779 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l783 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V822; - let v822 = match l783 { - 0 => { - let e822 = { - let l784 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l785 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base790 = l784; - let len790 = l785; - let mut result790 = _rt::Vec::with_capacity(len790); - for i in 0..len790 { - let base = base790 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e790 = { - let l786 = *base.add(0).cast::<*mut u8>(); - let l787 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len788 = l787; - let bytes788 = _rt::Vec::from_raw_parts( - l786.cast(), - len788, - len788, - ); - let l789 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes788), l789) - }; - result790.push(e790); - } - _rt::cabi_dealloc( - base790, - len790 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result790 - }; - V822::RecordType(e822) - } - 1 => { - let e822 = { - let l791 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l792 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base798 = l791; - let len798 = l792; - let mut result798 = _rt::Vec::with_capacity(len798); - for i in 0..len798 { - let base = base798 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e798 = { - let l793 = *base.add(0).cast::<*mut u8>(); - let l794 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len795 = l794; - let bytes795 = _rt::Vec::from_raw_parts( - l793.cast(), - len795, - len795, - ); - let l796 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes795), - match l796 { - 0 => None, - 1 => { - let e = { - let l797 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l797 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result798.push(e798); - } - _rt::cabi_dealloc( - base798, - len798 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result798 - }; - V822::VariantType(e822) - } - 2 => { - let e822 = { - let l799 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l800 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base804 = l799; - let len804 = l800; - let mut result804 = _rt::Vec::with_capacity(len804); - for i in 0..len804 { - let base = base804 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e804 = { - let l801 = *base.add(0).cast::<*mut u8>(); - let l802 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len803 = l802; - let bytes803 = _rt::Vec::from_raw_parts( - l801.cast(), - len803, - len803, - ); - _rt::string_lift(bytes803) - }; - result804.push(e804); - } - _rt::cabi_dealloc( - base804, - len804 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result804 - }; - V822::EnumType(e822) - } - 3 => { - let e822 = { - let l805 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l806 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base810 = l805; - let len810 = l806; - let mut result810 = _rt::Vec::with_capacity(len810); - for i in 0..len810 { - let base = base810 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e810 = { - let l807 = *base.add(0).cast::<*mut u8>(); - let l808 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len809 = l808; - let bytes809 = _rt::Vec::from_raw_parts( - l807.cast(), - len809, - len809, - ); - _rt::string_lift(bytes809) - }; - result810.push(e810); - } - _rt::cabi_dealloc( - base810, - len810 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result810 - }; - V822::FlagsType(e822) - } - 4 => { - let e822 = { - let l811 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l812 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len813 = l812; - _rt::Vec::from_raw_parts(l811.cast(), len813, len813) - }; - V822::TupleType(e822) - } - 5 => { - let e822 = { - let l814 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l814 - }; - V822::ListType(e822) - } - 6 => { - let e822 = { - let l815 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l815 - }; - V822::OptionType(e822) - } - 7 => { - let e822 = { - let l816 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l818 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l816 { - 0 => None, - 1 => { - let e = { - let l817 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l817 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l818 { - 0 => None, - 1 => { - let e = { - let l819 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l819 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V822::ResultType(e822) - } - 8 => V822::PrimU8Type, - 9 => V822::PrimU16Type, - 10 => V822::PrimU32Type, - 11 => V822::PrimU64Type, - 12 => V822::PrimS8Type, - 13 => V822::PrimS16Type, - 14 => V822::PrimS32Type, - 15 => V822::PrimS64Type, - 16 => V822::PrimF32Type, - 17 => V822::PrimF64Type, - 18 => V822::PrimCharType, - 19 => V822::PrimBoolType, - 20 => V822::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e822 = { - let l820 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l821 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l820 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l821 as u8, - ), - ) - }; - V822::HandleType(e822) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l775 { - 0 => None, - 1 => { - let e = { - let l776 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l777 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len778 = l777; - let bytes778 = _rt::Vec::from_raw_parts( - l776.cast(), - len778, - len778, - ); - _rt::string_lift(bytes778) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l779 { - 0 => None, - 1 => { - let e = { - let l780 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l781 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len782 = l781; - let bytes782 = _rt::Vec::from_raw_parts( - l780.cast(), - len782, - len782, - ); - _rt::string_lift(bytes782) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v822, - } - }; - result823.push(e823); - } - _rt::cabi_dealloc( - base823, - len823 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result823, - } - }; - V838::ComponentModel(e838) - } - 1 => { - let e838 = { - let l824 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l824 { - 0 => None, - 1 => { - let e = { - let l825 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l826 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base830 = l825; - let len830 = l826; - let mut result830 = _rt::Vec::with_capacity(len830); - for i in 0..len830 { - let base = base830 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e830 = { - let l827 = *base.add(0).cast::<*mut u8>(); - let l828 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len829 = l828; - let bytes829 = _rt::Vec::from_raw_parts( - l827.cast(), - len829, - len829, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes829), - } - }; - result830.push(e830); - } - _rt::cabi_dealloc( - base830, - len830 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result830 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V838::UnstructuredText(e838) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e838 = { - let l831 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l831 { - 0 => None, - 1 => { - let e = { - let l832 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l833 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base837 = l832; - let len837 = l833; - let mut result837 = _rt::Vec::with_capacity(len837); - for i in 0..len837 { - let base = base837 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e837 = { - let l834 = *base.add(0).cast::<*mut u8>(); - let l835 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len836 = l835; - let bytes836 = _rt::Vec::from_raw_parts( - l834.cast(), - len836, - len836, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes836), - } - }; - result837.push(e837); - } - _rt::cabi_dealloc( - base837, - len837 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result837 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V838::UnstructuredBinary(e838) - } - }; - (_rt::string_lift(bytes771), v838) - }; - result839.push(e839); - } - _rt::cabi_dealloc( - base839, - len839 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result839 - }; - V913::Tuple(e913) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e913 = { - let l840 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l841 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base912 = l840; - let len912 = l841; - let mut result912 = _rt::Vec::with_capacity(len912); - for i in 0..len912 { - let base = base912 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e912 = { - let l842 = *base.add(0).cast::<*mut u8>(); - let l843 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len844 = l843; - let bytes844 = _rt::Vec::from_raw_parts( - l842.cast(), - len844, - len844, - ); - let l845 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V911; - let v911 = match l845 { - 0 => { - let e911 = { - let l846 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l847 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base896 = l846; - let len896 = l847; - let mut result896 = _rt::Vec::with_capacity(len896); - for i in 0..len896 { - let base = base896 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e896 = { - let l848 = i32::from(*base.add(0).cast::()); - let l852 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l856 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V895; - let v895 = match l856 { - 0 => { - let e895 = { - let l857 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l858 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base863 = l857; - let len863 = l858; - let mut result863 = _rt::Vec::with_capacity(len863); - for i in 0..len863 { - let base = base863 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e863 = { - let l859 = *base.add(0).cast::<*mut u8>(); - let l860 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len861 = l860; - let bytes861 = _rt::Vec::from_raw_parts( - l859.cast(), - len861, - len861, - ); - let l862 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes861), l862) - }; - result863.push(e863); - } - _rt::cabi_dealloc( - base863, - len863 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result863 - }; - V895::RecordType(e895) - } - 1 => { - let e895 = { - let l864 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l865 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base871 = l864; - let len871 = l865; - let mut result871 = _rt::Vec::with_capacity(len871); - for i in 0..len871 { - let base = base871 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e871 = { - let l866 = *base.add(0).cast::<*mut u8>(); - let l867 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len868 = l867; - let bytes868 = _rt::Vec::from_raw_parts( - l866.cast(), - len868, - len868, - ); - let l869 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes868), - match l869 { - 0 => None, - 1 => { - let e = { - let l870 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l870 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result871.push(e871); - } - _rt::cabi_dealloc( - base871, - len871 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result871 - }; - V895::VariantType(e895) - } - 2 => { - let e895 = { - let l872 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l873 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base877 = l872; - let len877 = l873; - let mut result877 = _rt::Vec::with_capacity(len877); - for i in 0..len877 { - let base = base877 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e877 = { - let l874 = *base.add(0).cast::<*mut u8>(); - let l875 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len876 = l875; - let bytes876 = _rt::Vec::from_raw_parts( - l874.cast(), - len876, - len876, - ); - _rt::string_lift(bytes876) - }; - result877.push(e877); - } - _rt::cabi_dealloc( - base877, - len877 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result877 - }; - V895::EnumType(e895) - } - 3 => { - let e895 = { - let l878 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l879 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base883 = l878; - let len883 = l879; - let mut result883 = _rt::Vec::with_capacity(len883); - for i in 0..len883 { - let base = base883 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e883 = { - let l880 = *base.add(0).cast::<*mut u8>(); - let l881 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len882 = l881; - let bytes882 = _rt::Vec::from_raw_parts( - l880.cast(), - len882, - len882, - ); - _rt::string_lift(bytes882) - }; - result883.push(e883); - } - _rt::cabi_dealloc( - base883, - len883 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result883 - }; - V895::FlagsType(e895) - } - 4 => { - let e895 = { - let l884 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l885 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len886 = l885; - _rt::Vec::from_raw_parts(l884.cast(), len886, len886) - }; - V895::TupleType(e895) - } - 5 => { - let e895 = { - let l887 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l887 - }; - V895::ListType(e895) - } - 6 => { - let e895 = { - let l888 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l888 - }; - V895::OptionType(e895) - } - 7 => { - let e895 = { - let l889 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l891 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l889 { - 0 => None, - 1 => { - let e = { - let l890 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l890 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l891 { - 0 => None, - 1 => { - let e = { - let l892 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l892 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V895::ResultType(e895) - } - 8 => V895::PrimU8Type, - 9 => V895::PrimU16Type, - 10 => V895::PrimU32Type, - 11 => V895::PrimU64Type, - 12 => V895::PrimS8Type, - 13 => V895::PrimS16Type, - 14 => V895::PrimS32Type, - 15 => V895::PrimS64Type, - 16 => V895::PrimF32Type, - 17 => V895::PrimF64Type, - 18 => V895::PrimCharType, - 19 => V895::PrimBoolType, - 20 => V895::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e895 = { - let l893 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l894 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l893 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l894 as u8, - ), - ) - }; - V895::HandleType(e895) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l848 { - 0 => None, - 1 => { - let e = { - let l849 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l850 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len851 = l850; - let bytes851 = _rt::Vec::from_raw_parts( - l849.cast(), - len851, - len851, - ); - _rt::string_lift(bytes851) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l852 { - 0 => None, - 1 => { - let e = { - let l853 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l854 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len855 = l854; - let bytes855 = _rt::Vec::from_raw_parts( - l853.cast(), - len855, - len855, - ); - _rt::string_lift(bytes855) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v895, - } - }; - result896.push(e896); - } - _rt::cabi_dealloc( - base896, - len896 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result896, - } - }; - V911::ComponentModel(e911) - } - 1 => { - let e911 = { - let l897 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l897 { - 0 => None, - 1 => { - let e = { - let l898 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l899 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base903 = l898; - let len903 = l899; - let mut result903 = _rt::Vec::with_capacity(len903); - for i in 0..len903 { - let base = base903 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e903 = { - let l900 = *base.add(0).cast::<*mut u8>(); - let l901 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len902 = l901; - let bytes902 = _rt::Vec::from_raw_parts( - l900.cast(), - len902, - len902, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes902), - } - }; - result903.push(e903); - } - _rt::cabi_dealloc( - base903, - len903 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result903 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V911::UnstructuredText(e911) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e911 = { - let l904 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l904 { - 0 => None, - 1 => { - let e = { - let l905 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l906 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base910 = l905; - let len910 = l906; - let mut result910 = _rt::Vec::with_capacity(len910); - for i in 0..len910 { - let base = base910 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e910 = { - let l907 = *base.add(0).cast::<*mut u8>(); - let l908 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len909 = l908; - let bytes909 = _rt::Vec::from_raw_parts( - l907.cast(), - len909, - len909, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes909), - } - }; - result910.push(e910); - } - _rt::cabi_dealloc( - base910, - len910 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result910 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V911::UnstructuredBinary(e911) - } - }; - (_rt::string_lift(bytes844), v911) - }; - result912.push(e912); - } - _rt::cabi_dealloc( - base912, - len912 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result912 - }; - V913::Multimodal(e913) - } - }; - let l914 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l915 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len916 = l915; - let bytes916 = _rt::Vec::from_raw_parts( - l914.cast(), - len916, - len916, - ); - let l917 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l918 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base922 = l917; - let len922 = l918; - let mut result922 = _rt::Vec::with_capacity(len922); - for i in 0..len922 { - let base = base922 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e922 = { - let l919 = *base.add(0).cast::<*mut u8>(); - let l920 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len921 = l920; - let bytes921 = _rt::Vec::from_raw_parts( - l919.cast(), - len921, - len921, - ); - _rt::string_lift(bytes921) - }; - result922.push(e922); - } - _rt::cabi_dealloc( - base922, - len922 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l923 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l924 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base956 = l923; - let len956 = l924; - let mut result956 = _rt::Vec::with_capacity(len956); - for i in 0..len956 { - let base = base956 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e956 = { - let l925 = *base.add(0).cast::<*mut u8>(); - let l926 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base955 = l925; - let len955 = l926; - let mut result955 = _rt::Vec::with_capacity(len955); - for i in 0..len955 { - let base = base955 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e955 = { - let l927 = i32::from(*base.add(0).cast::()); - let v954 = match l927 { - 0 => { - let e954 = { - let l928 = *base.add(8).cast::<*mut u8>(); - let l929 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len930 = l929; - let bytes930 = _rt::Vec::from_raw_parts( - l928.cast(), - len930, - len930, - ); - let l931 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l932 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l933 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l937 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l939 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l940 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base949 = l939; - let len949 = l940; - let mut result949 = _rt::Vec::with_capacity(len949); - for i in 0..len949 { - let base = base949 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e949 = { - let l941 = *base.add(0).cast::<*mut u8>(); - let l942 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len943 = l942; - let bytes943 = _rt::Vec::from_raw_parts( - l941.cast(), - len943, - len943, - ); - let l944 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V948; - let v948 = match l944 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e948 = { - let l945 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l946 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len947 = l946; - let bytes947 = _rt::Vec::from_raw_parts( - l945.cast(), - len947, - len947, - ); - _rt::string_lift(bytes947) - }; - V948::String(e948) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes943), - value: v948, - } - }; - result949.push(e949); - } - _rt::cabi_dealloc( - base949, - len949 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l950 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes930), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l931 as u64, - nanoseconds: l932 as u32, - }, - parent: match l933 { - 0 => None, - 1 => { - let e = { - let l934 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l935 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len936 = l935; - let bytes936 = _rt::Vec::from_raw_parts( - l934.cast(), - len936, - len936, - ); - _rt::string_lift(bytes936) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l937 { - 0 => None, - 1 => { - let e = { - let l938 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l938 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result949, - inherited: _rt::bool_lift(l950 as u8), - } - }; - SpanData::LocalSpan(e954) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e954 = { - let l951 = *base.add(8).cast::<*mut u8>(); - let l952 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len953 = l952; - let bytes953 = _rt::Vec::from_raw_parts( - l951.cast(), - len953, - len953, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes953), - } - }; - SpanData::ExternalSpan(e954) - } - }; - v954 - }; - result955.push(e955); - } - _rt::cabi_dealloc( - base955, - len955 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result955 - }; - result956.push(e956); - } - _rt::cabi_dealloc( - base956, - len956 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes608), - constructor_parameters: TypedDataValue { - value: v765, - schema: v913, - }, - trace_id: _rt::string_lift(bytes916), - trace_states: result922, - invocation_context: result956, - } - }; - AgentInvocation::AgentInitialization(e1321) - } - 1 => { - let e1321 = { - let l957 = *base.add(32).cast::<*mut u8>(); - let l958 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len959 = l958; - let bytes959 = _rt::Vec::from_raw_parts( - l957.cast(), - len959, - len959, - ); - let l960 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l961 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len962 = l961; - let bytes962 = _rt::Vec::from_raw_parts( - l960.cast(), - len962, - len962, - ); - let l963 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1119; - let v1119 = match l963 { - 0 => { - let e1119 = { - let l964 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l965 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1039 = l964; - let len1039 = l965; - let mut result1039 = _rt::Vec::with_capacity(len1039); - for i in 0..len1039 { - let base = base1039 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1039 = { - let l966 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1038; - let v1038 = match l966 { - 0 => { - let e1038 = { - let l967 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l968 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1014 = l967; - let len1014 = l968; - let mut result1014 = _rt::Vec::with_capacity(len1014); - for i in 0..len1014 { - let base = base1014 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1014 = { - let l969 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1013; - let v1013 = match l969 { - 0 => { - let e1013 = { - let l970 = *base.add(8).cast::<*mut u8>(); - let l971 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len972 = l971; - _rt::Vec::from_raw_parts(l970.cast(), len972, len972) - }; - V1013::RecordValue(e1013) - } - 1 => { - let e1013 = { - let l973 = *base.add(8).cast::(); - let l974 = i32::from(*base.add(12).cast::()); - ( - l973 as u32, - match l974 { - 0 => None, - 1 => { - let e = { - let l975 = *base.add(16).cast::(); - l975 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1013::VariantValue(e1013) - } - 2 => { - let e1013 = { - let l976 = *base.add(8).cast::(); - l976 as u32 - }; - V1013::EnumValue(e1013) - } - 3 => { - let e1013 = { - let l977 = *base.add(8).cast::<*mut u8>(); - let l978 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base980 = l977; - let len980 = l978; - let mut result980 = _rt::Vec::with_capacity(len980); - for i in 0..len980 { - let base = base980.add(i * 1); - let e980 = { - let l979 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l979 as u8) - }; - result980.push(e980); - } - _rt::cabi_dealloc(base980, len980 * 1, 1); - result980 - }; - V1013::FlagsValue(e1013) - } - 4 => { - let e1013 = { - let l981 = *base.add(8).cast::<*mut u8>(); - let l982 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len983 = l982; - _rt::Vec::from_raw_parts(l981.cast(), len983, len983) - }; - V1013::TupleValue(e1013) - } - 5 => { - let e1013 = { - let l984 = *base.add(8).cast::<*mut u8>(); - let l985 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len986 = l985; - _rt::Vec::from_raw_parts(l984.cast(), len986, len986) - }; - V1013::ListValue(e1013) - } - 6 => { - let e1013 = { - let l987 = i32::from(*base.add(8).cast::()); - match l987 { - 0 => None, - 1 => { - let e = { - let l988 = *base.add(12).cast::(); - l988 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1013::OptionValue(e1013) - } - 7 => { - let e1013 = { - let l989 = i32::from(*base.add(8).cast::()); - match l989 { - 0 => { - let e = { - let l990 = i32::from(*base.add(12).cast::()); - match l990 { - 0 => None, - 1 => { - let e = { - let l991 = *base.add(16).cast::(); - l991 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l992 = i32::from(*base.add(12).cast::()); - match l992 { - 0 => None, - 1 => { - let e = { - let l993 = *base.add(16).cast::(); - l993 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1013::ResultValue(e1013) - } - 8 => { - let e1013 = { - let l994 = i32::from(*base.add(8).cast::()); - l994 as u8 - }; - V1013::PrimU8(e1013) - } - 9 => { - let e1013 = { - let l995 = i32::from(*base.add(8).cast::()); - l995 as u16 - }; - V1013::PrimU16(e1013) - } - 10 => { - let e1013 = { - let l996 = *base.add(8).cast::(); - l996 as u32 - }; - V1013::PrimU32(e1013) - } - 11 => { - let e1013 = { - let l997 = *base.add(8).cast::(); - l997 as u64 - }; - V1013::PrimU64(e1013) - } - 12 => { - let e1013 = { - let l998 = i32::from(*base.add(8).cast::()); - l998 as i8 - }; - V1013::PrimS8(e1013) - } - 13 => { - let e1013 = { - let l999 = i32::from(*base.add(8).cast::()); - l999 as i16 - }; - V1013::PrimS16(e1013) - } - 14 => { - let e1013 = { - let l1000 = *base.add(8).cast::(); - l1000 - }; - V1013::PrimS32(e1013) - } - 15 => { - let e1013 = { - let l1001 = *base.add(8).cast::(); - l1001 - }; - V1013::PrimS64(e1013) - } - 16 => { - let e1013 = { - let l1002 = *base.add(8).cast::(); - l1002 - }; - V1013::PrimFloat32(e1013) - } - 17 => { - let e1013 = { - let l1003 = *base.add(8).cast::(); - l1003 - }; - V1013::PrimFloat64(e1013) - } - 18 => { - let e1013 = { - let l1004 = *base.add(8).cast::(); - _rt::char_lift(l1004 as u32) - }; - V1013::PrimChar(e1013) - } - 19 => { - let e1013 = { - let l1005 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1005 as u8) - }; - V1013::PrimBool(e1013) - } - 20 => { - let e1013 = { - let l1006 = *base.add(8).cast::<*mut u8>(); - let l1007 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1008 = l1007; - let bytes1008 = _rt::Vec::from_raw_parts( - l1006.cast(), - len1008, - len1008, - ); - _rt::string_lift(bytes1008) - }; - V1013::PrimString(e1013) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1013 = { - let l1009 = *base.add(8).cast::<*mut u8>(); - let l1010 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1011 = l1010; - let bytes1011 = _rt::Vec::from_raw_parts( - l1009.cast(), - len1011, - len1011, - ); - let l1012 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1011), - }, - l1012 as u64, - ) - }; - V1013::Handle(e1013) - } - }; - v1013 - }; - result1014.push(e1014); - } - _rt::cabi_dealloc( - base1014, - len1014 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1014, - } - }; - V1038::ComponentModel(e1038) - } - 1 => { - let e1038 = { - let l1015 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1026; - let v1026 = match l1015 { - 0 => { - let e1026 = { - let l1016 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1017 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1018 = l1017; - let bytes1018 = _rt::Vec::from_raw_parts( - l1016.cast(), - len1018, - len1018, - ); - _rt::string_lift(bytes1018) - }; - V1026::Url(e1026) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1026 = { - let l1019 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1020 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1021 = l1020; - let bytes1021 = _rt::Vec::from_raw_parts( - l1019.cast(), - len1021, - len1021, - ); - let l1022 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1021), - text_type: match l1022 { - 0 => None, - 1 => { - let e = { - let l1023 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1024 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1025 = l1024; - let bytes1025 = _rt::Vec::from_raw_parts( - l1023.cast(), - len1025, - len1025, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1025), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1026::Inline(e1026) - } - }; - v1026 - }; - V1038::UnstructuredText(e1038) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1038 = { - let l1027 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1037; - let v1037 = match l1027 { - 0 => { - let e1037 = { - let l1028 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1029 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1030 = l1029; - let bytes1030 = _rt::Vec::from_raw_parts( - l1028.cast(), - len1030, - len1030, - ); - _rt::string_lift(bytes1030) - }; - V1037::Url(e1037) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1037 = { - let l1031 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1032 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1033 = l1032; - let l1034 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1035 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1036 = l1035; - let bytes1036 = _rt::Vec::from_raw_parts( - l1034.cast(), - len1036, - len1036, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1031.cast(), - len1033, - len1033, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1036), - }, - } - }; - V1037::Inline(e1037) - } - }; - v1037 - }; - V1038::UnstructuredBinary(e1038) - } - }; - v1038 - }; - result1039.push(e1039); - } - _rt::cabi_dealloc( - base1039, - len1039 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1039 - }; - V1119::Tuple(e1119) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1119 = { - let l1040 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1041 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1118 = l1040; - let len1118 = l1041; - let mut result1118 = _rt::Vec::with_capacity(len1118); - for i in 0..len1118 { - let base = base1118 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1118 = { - let l1042 = *base.add(0).cast::<*mut u8>(); - let l1043 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1044 = l1043; - let bytes1044 = _rt::Vec::from_raw_parts( - l1042.cast(), - len1044, - len1044, - ); - let l1045 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1117; - let v1117 = match l1045 { - 0 => { - let e1117 = { - let l1046 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1047 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1093 = l1046; - let len1093 = l1047; - let mut result1093 = _rt::Vec::with_capacity(len1093); - for i in 0..len1093 { - let base = base1093 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1093 = { - let l1048 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1092; - let v1092 = match l1048 { - 0 => { - let e1092 = { - let l1049 = *base.add(8).cast::<*mut u8>(); - let l1050 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1051 = l1050; - _rt::Vec::from_raw_parts(l1049.cast(), len1051, len1051) - }; - V1092::RecordValue(e1092) - } - 1 => { - let e1092 = { - let l1052 = *base.add(8).cast::(); - let l1053 = i32::from(*base.add(12).cast::()); - ( - l1052 as u32, - match l1053 { - 0 => None, - 1 => { - let e = { - let l1054 = *base.add(16).cast::(); - l1054 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1092::VariantValue(e1092) - } - 2 => { - let e1092 = { - let l1055 = *base.add(8).cast::(); - l1055 as u32 - }; - V1092::EnumValue(e1092) - } - 3 => { - let e1092 = { - let l1056 = *base.add(8).cast::<*mut u8>(); - let l1057 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1059 = l1056; - let len1059 = l1057; - let mut result1059 = _rt::Vec::with_capacity(len1059); - for i in 0..len1059 { - let base = base1059.add(i * 1); - let e1059 = { - let l1058 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1058 as u8) - }; - result1059.push(e1059); - } - _rt::cabi_dealloc(base1059, len1059 * 1, 1); - result1059 - }; - V1092::FlagsValue(e1092) - } - 4 => { - let e1092 = { - let l1060 = *base.add(8).cast::<*mut u8>(); - let l1061 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1062 = l1061; - _rt::Vec::from_raw_parts(l1060.cast(), len1062, len1062) - }; - V1092::TupleValue(e1092) - } - 5 => { - let e1092 = { - let l1063 = *base.add(8).cast::<*mut u8>(); - let l1064 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1065 = l1064; - _rt::Vec::from_raw_parts(l1063.cast(), len1065, len1065) - }; - V1092::ListValue(e1092) - } - 6 => { - let e1092 = { - let l1066 = i32::from(*base.add(8).cast::()); - match l1066 { - 0 => None, - 1 => { - let e = { - let l1067 = *base.add(12).cast::(); - l1067 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1092::OptionValue(e1092) - } - 7 => { - let e1092 = { - let l1068 = i32::from(*base.add(8).cast::()); - match l1068 { - 0 => { - let e = { - let l1069 = i32::from(*base.add(12).cast::()); - match l1069 { - 0 => None, - 1 => { - let e = { - let l1070 = *base.add(16).cast::(); - l1070 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1071 = i32::from(*base.add(12).cast::()); - match l1071 { - 0 => None, - 1 => { - let e = { - let l1072 = *base.add(16).cast::(); - l1072 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1092::ResultValue(e1092) - } - 8 => { - let e1092 = { - let l1073 = i32::from(*base.add(8).cast::()); - l1073 as u8 - }; - V1092::PrimU8(e1092) - } - 9 => { - let e1092 = { - let l1074 = i32::from(*base.add(8).cast::()); - l1074 as u16 - }; - V1092::PrimU16(e1092) - } - 10 => { - let e1092 = { - let l1075 = *base.add(8).cast::(); - l1075 as u32 - }; - V1092::PrimU32(e1092) - } - 11 => { - let e1092 = { - let l1076 = *base.add(8).cast::(); - l1076 as u64 - }; - V1092::PrimU64(e1092) - } - 12 => { - let e1092 = { - let l1077 = i32::from(*base.add(8).cast::()); - l1077 as i8 - }; - V1092::PrimS8(e1092) - } - 13 => { - let e1092 = { - let l1078 = i32::from(*base.add(8).cast::()); - l1078 as i16 - }; - V1092::PrimS16(e1092) - } - 14 => { - let e1092 = { - let l1079 = *base.add(8).cast::(); - l1079 - }; - V1092::PrimS32(e1092) - } - 15 => { - let e1092 = { - let l1080 = *base.add(8).cast::(); - l1080 - }; - V1092::PrimS64(e1092) - } - 16 => { - let e1092 = { - let l1081 = *base.add(8).cast::(); - l1081 - }; - V1092::PrimFloat32(e1092) - } - 17 => { - let e1092 = { - let l1082 = *base.add(8).cast::(); - l1082 - }; - V1092::PrimFloat64(e1092) - } - 18 => { - let e1092 = { - let l1083 = *base.add(8).cast::(); - _rt::char_lift(l1083 as u32) - }; - V1092::PrimChar(e1092) - } - 19 => { - let e1092 = { - let l1084 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1084 as u8) - }; - V1092::PrimBool(e1092) - } - 20 => { - let e1092 = { - let l1085 = *base.add(8).cast::<*mut u8>(); - let l1086 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1087 = l1086; - let bytes1087 = _rt::Vec::from_raw_parts( - l1085.cast(), - len1087, - len1087, - ); - _rt::string_lift(bytes1087) - }; - V1092::PrimString(e1092) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1092 = { - let l1088 = *base.add(8).cast::<*mut u8>(); - let l1089 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1090 = l1089; - let bytes1090 = _rt::Vec::from_raw_parts( - l1088.cast(), - len1090, - len1090, - ); - let l1091 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1090), - }, - l1091 as u64, - ) - }; - V1092::Handle(e1092) - } - }; - v1092 - }; - result1093.push(e1093); - } - _rt::cabi_dealloc( - base1093, - len1093 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1093, - } - }; - V1117::ComponentModel(e1117) - } - 1 => { - let e1117 = { - let l1094 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1105; - let v1105 = match l1094 { - 0 => { - let e1105 = { - let l1095 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1096 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1097 = l1096; - let bytes1097 = _rt::Vec::from_raw_parts( - l1095.cast(), - len1097, - len1097, - ); - _rt::string_lift(bytes1097) - }; - V1105::Url(e1105) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1105 = { - let l1098 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1099 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1100 = l1099; - let bytes1100 = _rt::Vec::from_raw_parts( - l1098.cast(), - len1100, - len1100, - ); - let l1101 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1100), - text_type: match l1101 { - 0 => None, - 1 => { - let e = { - let l1102 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1103 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1104 = l1103; - let bytes1104 = _rt::Vec::from_raw_parts( - l1102.cast(), - len1104, - len1104, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1104), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1105::Inline(e1105) - } - }; - v1105 - }; - V1117::UnstructuredText(e1117) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1117 = { - let l1106 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1116; - let v1116 = match l1106 { - 0 => { - let e1116 = { - let l1107 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1108 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1109 = l1108; - let bytes1109 = _rt::Vec::from_raw_parts( - l1107.cast(), - len1109, - len1109, - ); - _rt::string_lift(bytes1109) - }; - V1116::Url(e1116) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1116 = { - let l1110 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1111 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1112 = l1111; - let l1113 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1114 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1115 = l1114; - let bytes1115 = _rt::Vec::from_raw_parts( - l1113.cast(), - len1115, - len1115, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1110.cast(), - len1112, - len1112, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1115), - }, - } - }; - V1116::Inline(e1116) - } - }; - v1116 - }; - V1117::UnstructuredBinary(e1117) - } - }; - (_rt::string_lift(bytes1044), v1117) - }; - result1118.push(e1118); - } - _rt::cabi_dealloc( - base1118, - len1118 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1118 - }; - V1119::Multimodal(e1119) - } - }; - let l1120 = i32::from( - *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1267; - let v1267 = match l1120 { - 0 => { - let e1267 = { - let l1121 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1122 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1193 = l1121; - let len1193 = l1122; - let mut result1193 = _rt::Vec::with_capacity(len1193); - for i in 0..len1193 { - let base = base1193 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1193 = { - let l1123 = *base.add(0).cast::<*mut u8>(); - let l1124 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1125 = l1124; - let bytes1125 = _rt::Vec::from_raw_parts( - l1123.cast(), - len1125, - len1125, - ); - let l1126 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1192; - let v1192 = match l1126 { - 0 => { - let e1192 = { - let l1127 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1128 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1177 = l1127; - let len1177 = l1128; - let mut result1177 = _rt::Vec::with_capacity(len1177); - for i in 0..len1177 { - let base = base1177 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1177 = { - let l1129 = i32::from(*base.add(0).cast::()); - let l1133 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1137 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1176; - let v1176 = match l1137 { - 0 => { - let e1176 = { - let l1138 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1139 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1144 = l1138; - let len1144 = l1139; - let mut result1144 = _rt::Vec::with_capacity(len1144); - for i in 0..len1144 { - let base = base1144 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1144 = { - let l1140 = *base.add(0).cast::<*mut u8>(); - let l1141 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1142 = l1141; - let bytes1142 = _rt::Vec::from_raw_parts( - l1140.cast(), - len1142, - len1142, - ); - let l1143 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1142), l1143) - }; - result1144.push(e1144); - } - _rt::cabi_dealloc( - base1144, - len1144 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1144 - }; - V1176::RecordType(e1176) - } - 1 => { - let e1176 = { - let l1145 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1146 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1152 = l1145; - let len1152 = l1146; - let mut result1152 = _rt::Vec::with_capacity(len1152); - for i in 0..len1152 { - let base = base1152 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1152 = { - let l1147 = *base.add(0).cast::<*mut u8>(); - let l1148 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1149 = l1148; - let bytes1149 = _rt::Vec::from_raw_parts( - l1147.cast(), - len1149, - len1149, - ); - let l1150 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1149), - match l1150 { - 0 => None, - 1 => { - let e = { - let l1151 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1151 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1152.push(e1152); - } - _rt::cabi_dealloc( - base1152, - len1152 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1152 - }; - V1176::VariantType(e1176) - } - 2 => { - let e1176 = { - let l1153 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1154 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1158 = l1153; - let len1158 = l1154; - let mut result1158 = _rt::Vec::with_capacity(len1158); - for i in 0..len1158 { - let base = base1158 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1158 = { - let l1155 = *base.add(0).cast::<*mut u8>(); - let l1156 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1157 = l1156; - let bytes1157 = _rt::Vec::from_raw_parts( - l1155.cast(), - len1157, - len1157, - ); - _rt::string_lift(bytes1157) - }; - result1158.push(e1158); - } - _rt::cabi_dealloc( - base1158, - len1158 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1158 - }; - V1176::EnumType(e1176) - } - 3 => { - let e1176 = { - let l1159 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1160 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1164 = l1159; - let len1164 = l1160; - let mut result1164 = _rt::Vec::with_capacity(len1164); - for i in 0..len1164 { - let base = base1164 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1164 = { - let l1161 = *base.add(0).cast::<*mut u8>(); - let l1162 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1163 = l1162; - let bytes1163 = _rt::Vec::from_raw_parts( - l1161.cast(), - len1163, - len1163, - ); - _rt::string_lift(bytes1163) - }; - result1164.push(e1164); - } - _rt::cabi_dealloc( - base1164, - len1164 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1164 - }; - V1176::FlagsType(e1176) - } - 4 => { - let e1176 = { - let l1165 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1166 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1167 = l1166; - _rt::Vec::from_raw_parts(l1165.cast(), len1167, len1167) - }; - V1176::TupleType(e1176) - } - 5 => { - let e1176 = { - let l1168 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1168 - }; - V1176::ListType(e1176) - } - 6 => { - let e1176 = { - let l1169 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1169 - }; - V1176::OptionType(e1176) - } - 7 => { - let e1176 = { - let l1170 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1172 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1170 { - 0 => None, - 1 => { - let e = { - let l1171 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1171 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1172 { - 0 => None, - 1 => { - let e = { - let l1173 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1173 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1176::ResultType(e1176) - } - 8 => V1176::PrimU8Type, - 9 => V1176::PrimU16Type, - 10 => V1176::PrimU32Type, - 11 => V1176::PrimU64Type, - 12 => V1176::PrimS8Type, - 13 => V1176::PrimS16Type, - 14 => V1176::PrimS32Type, - 15 => V1176::PrimS64Type, - 16 => V1176::PrimF32Type, - 17 => V1176::PrimF64Type, - 18 => V1176::PrimCharType, - 19 => V1176::PrimBoolType, - 20 => V1176::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1176 = { - let l1174 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1175 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1174 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1175 as u8, - ), - ) - }; - V1176::HandleType(e1176) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1129 { - 0 => None, - 1 => { - let e = { - let l1130 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1131 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1132 = l1131; - let bytes1132 = _rt::Vec::from_raw_parts( - l1130.cast(), - len1132, - len1132, - ); - _rt::string_lift(bytes1132) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1133 { - 0 => None, - 1 => { - let e = { - let l1134 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1135 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1136 = l1135; - let bytes1136 = _rt::Vec::from_raw_parts( - l1134.cast(), - len1136, - len1136, - ); - _rt::string_lift(bytes1136) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1176, - } - }; - result1177.push(e1177); - } - _rt::cabi_dealloc( - base1177, - len1177 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1177, - } - }; - V1192::ComponentModel(e1192) - } - 1 => { - let e1192 = { - let l1178 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1178 { - 0 => None, - 1 => { - let e = { - let l1179 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1180 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1184 = l1179; - let len1184 = l1180; - let mut result1184 = _rt::Vec::with_capacity(len1184); - for i in 0..len1184 { - let base = base1184 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1184 = { - let l1181 = *base.add(0).cast::<*mut u8>(); - let l1182 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1183 = l1182; - let bytes1183 = _rt::Vec::from_raw_parts( - l1181.cast(), - len1183, - len1183, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1183), - } - }; - result1184.push(e1184); - } - _rt::cabi_dealloc( - base1184, - len1184 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1184 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1192::UnstructuredText(e1192) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1192 = { - let l1185 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1185 { - 0 => None, - 1 => { - let e = { - let l1186 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1187 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1191 = l1186; - let len1191 = l1187; - let mut result1191 = _rt::Vec::with_capacity(len1191); - for i in 0..len1191 { - let base = base1191 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1191 = { - let l1188 = *base.add(0).cast::<*mut u8>(); - let l1189 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1190 = l1189; - let bytes1190 = _rt::Vec::from_raw_parts( - l1188.cast(), - len1190, - len1190, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1190), - } - }; - result1191.push(e1191); - } - _rt::cabi_dealloc( - base1191, - len1191 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1191 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1192::UnstructuredBinary(e1192) - } - }; - (_rt::string_lift(bytes1125), v1192) - }; - result1193.push(e1193); - } - _rt::cabi_dealloc( - base1193, - len1193 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1193 - }; - V1267::Tuple(e1267) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1267 = { - let l1194 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1195 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1266 = l1194; - let len1266 = l1195; - let mut result1266 = _rt::Vec::with_capacity(len1266); - for i in 0..len1266 { - let base = base1266 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1266 = { - let l1196 = *base.add(0).cast::<*mut u8>(); - let l1197 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1198 = l1197; - let bytes1198 = _rt::Vec::from_raw_parts( - l1196.cast(), - len1198, - len1198, - ); - let l1199 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1265; - let v1265 = match l1199 { - 0 => { - let e1265 = { - let l1200 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1201 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1250 = l1200; - let len1250 = l1201; - let mut result1250 = _rt::Vec::with_capacity(len1250); - for i in 0..len1250 { - let base = base1250 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1250 = { - let l1202 = i32::from(*base.add(0).cast::()); - let l1206 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1210 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1249; - let v1249 = match l1210 { - 0 => { - let e1249 = { - let l1211 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1212 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1217 = l1211; - let len1217 = l1212; - let mut result1217 = _rt::Vec::with_capacity(len1217); - for i in 0..len1217 { - let base = base1217 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1217 = { - let l1213 = *base.add(0).cast::<*mut u8>(); - let l1214 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1215 = l1214; - let bytes1215 = _rt::Vec::from_raw_parts( - l1213.cast(), - len1215, - len1215, - ); - let l1216 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1215), l1216) - }; - result1217.push(e1217); - } - _rt::cabi_dealloc( - base1217, - len1217 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1217 - }; - V1249::RecordType(e1249) - } - 1 => { - let e1249 = { - let l1218 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1219 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1225 = l1218; - let len1225 = l1219; - let mut result1225 = _rt::Vec::with_capacity(len1225); - for i in 0..len1225 { - let base = base1225 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1225 = { - let l1220 = *base.add(0).cast::<*mut u8>(); - let l1221 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1222 = l1221; - let bytes1222 = _rt::Vec::from_raw_parts( - l1220.cast(), - len1222, - len1222, - ); - let l1223 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1222), - match l1223 { - 0 => None, - 1 => { - let e = { - let l1224 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1224 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1225.push(e1225); - } - _rt::cabi_dealloc( - base1225, - len1225 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1225 - }; - V1249::VariantType(e1249) - } - 2 => { - let e1249 = { - let l1226 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1227 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1231 = l1226; - let len1231 = l1227; - let mut result1231 = _rt::Vec::with_capacity(len1231); - for i in 0..len1231 { - let base = base1231 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1231 = { - let l1228 = *base.add(0).cast::<*mut u8>(); - let l1229 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1230 = l1229; - let bytes1230 = _rt::Vec::from_raw_parts( - l1228.cast(), - len1230, - len1230, - ); - _rt::string_lift(bytes1230) - }; - result1231.push(e1231); - } - _rt::cabi_dealloc( - base1231, - len1231 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1231 - }; - V1249::EnumType(e1249) - } - 3 => { - let e1249 = { - let l1232 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1233 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1237 = l1232; - let len1237 = l1233; - let mut result1237 = _rt::Vec::with_capacity(len1237); - for i in 0..len1237 { - let base = base1237 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1237 = { - let l1234 = *base.add(0).cast::<*mut u8>(); - let l1235 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1236 = l1235; - let bytes1236 = _rt::Vec::from_raw_parts( - l1234.cast(), - len1236, - len1236, - ); - _rt::string_lift(bytes1236) - }; - result1237.push(e1237); - } - _rt::cabi_dealloc( - base1237, - len1237 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1237 - }; - V1249::FlagsType(e1249) - } - 4 => { - let e1249 = { - let l1238 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1239 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1240 = l1239; - _rt::Vec::from_raw_parts(l1238.cast(), len1240, len1240) - }; - V1249::TupleType(e1249) - } - 5 => { - let e1249 = { - let l1241 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1241 - }; - V1249::ListType(e1249) - } - 6 => { - let e1249 = { - let l1242 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1242 - }; - V1249::OptionType(e1249) - } - 7 => { - let e1249 = { - let l1243 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1245 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1243 { - 0 => None, - 1 => { - let e = { - let l1244 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1244 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1245 { - 0 => None, - 1 => { - let e = { - let l1246 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1246 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1249::ResultType(e1249) - } - 8 => V1249::PrimU8Type, - 9 => V1249::PrimU16Type, - 10 => V1249::PrimU32Type, - 11 => V1249::PrimU64Type, - 12 => V1249::PrimS8Type, - 13 => V1249::PrimS16Type, - 14 => V1249::PrimS32Type, - 15 => V1249::PrimS64Type, - 16 => V1249::PrimF32Type, - 17 => V1249::PrimF64Type, - 18 => V1249::PrimCharType, - 19 => V1249::PrimBoolType, - 20 => V1249::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1249 = { - let l1247 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1248 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1247 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1248 as u8, - ), - ) - }; - V1249::HandleType(e1249) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1202 { - 0 => None, - 1 => { - let e = { - let l1203 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1204 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1205 = l1204; - let bytes1205 = _rt::Vec::from_raw_parts( - l1203.cast(), - len1205, - len1205, - ); - _rt::string_lift(bytes1205) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1206 { - 0 => None, - 1 => { - let e = { - let l1207 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1208 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1209 = l1208; - let bytes1209 = _rt::Vec::from_raw_parts( - l1207.cast(), - len1209, - len1209, - ); - _rt::string_lift(bytes1209) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1249, - } - }; - result1250.push(e1250); - } - _rt::cabi_dealloc( - base1250, - len1250 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1250, - } - }; - V1265::ComponentModel(e1265) - } - 1 => { - let e1265 = { - let l1251 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1251 { - 0 => None, - 1 => { - let e = { - let l1252 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1253 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1257 = l1252; - let len1257 = l1253; - let mut result1257 = _rt::Vec::with_capacity(len1257); - for i in 0..len1257 { - let base = base1257 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1257 = { - let l1254 = *base.add(0).cast::<*mut u8>(); - let l1255 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1256 = l1255; - let bytes1256 = _rt::Vec::from_raw_parts( - l1254.cast(), - len1256, - len1256, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1256), - } - }; - result1257.push(e1257); - } - _rt::cabi_dealloc( - base1257, - len1257 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1257 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1265::UnstructuredText(e1265) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1265 = { - let l1258 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1258 { - 0 => None, - 1 => { - let e = { - let l1259 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1260 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1264 = l1259; - let len1264 = l1260; - let mut result1264 = _rt::Vec::with_capacity(len1264); - for i in 0..len1264 { - let base = base1264 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1264 = { - let l1261 = *base.add(0).cast::<*mut u8>(); - let l1262 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1263 = l1262; - let bytes1263 = _rt::Vec::from_raw_parts( - l1261.cast(), - len1263, - len1263, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1263), - } - }; - result1264.push(e1264); - } - _rt::cabi_dealloc( - base1264, - len1264 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1264 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1265::UnstructuredBinary(e1265) - } - }; - (_rt::string_lift(bytes1198), v1265) - }; - result1266.push(e1266); - } - _rt::cabi_dealloc( - base1266, - len1266 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1266 - }; - V1267::Multimodal(e1267) - } - }; - let l1268 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1269 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1270 = l1269; - let bytes1270 = _rt::Vec::from_raw_parts( - l1268.cast(), - len1270, - len1270, - ); - let l1271 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1272 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1276 = l1271; - let len1276 = l1272; - let mut result1276 = _rt::Vec::with_capacity(len1276); - for i in 0..len1276 { - let base = base1276 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1276 = { - let l1273 = *base.add(0).cast::<*mut u8>(); - let l1274 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1275 = l1274; - let bytes1275 = _rt::Vec::from_raw_parts( - l1273.cast(), - len1275, - len1275, - ); - _rt::string_lift(bytes1275) - }; - result1276.push(e1276); - } - _rt::cabi_dealloc( - base1276, - len1276 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1277 = *base - .add(32 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1278 = *base - .add(32 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1310 = l1277; - let len1310 = l1278; - let mut result1310 = _rt::Vec::with_capacity(len1310); - for i in 0..len1310 { - let base = base1310 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1310 = { - let l1279 = *base.add(0).cast::<*mut u8>(); - let l1280 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base1309 = l1279; - let len1309 = l1280; - let mut result1309 = _rt::Vec::with_capacity(len1309); - for i in 0..len1309 { - let base = base1309 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e1309 = { - let l1281 = i32::from(*base.add(0).cast::()); - let v1308 = match l1281 { - 0 => { - let e1308 = { - let l1282 = *base.add(8).cast::<*mut u8>(); - let l1283 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1284 = l1283; - let bytes1284 = _rt::Vec::from_raw_parts( - l1282.cast(), - len1284, - len1284, - ); - let l1285 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1286 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1287 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1291 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1293 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1294 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1303 = l1293; - let len1303 = l1294; - let mut result1303 = _rt::Vec::with_capacity(len1303); - for i in 0..len1303 { - let base = base1303 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e1303 = { - let l1295 = *base.add(0).cast::<*mut u8>(); - let l1296 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1297 = l1296; - let bytes1297 = _rt::Vec::from_raw_parts( - l1295.cast(), - len1297, - len1297, - ); - let l1298 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V1302; - let v1302 = match l1298 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e1302 = { - let l1299 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1300 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1301 = l1300; - let bytes1301 = _rt::Vec::from_raw_parts( - l1299.cast(), - len1301, - len1301, - ); - _rt::string_lift(bytes1301) - }; - V1302::String(e1302) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes1297), - value: v1302, - } - }; - result1303.push(e1303); - } - _rt::cabi_dealloc( - base1303, - len1303 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1304 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes1284), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1285 as u64, - nanoseconds: l1286 as u32, - }, - parent: match l1287 { - 0 => None, - 1 => { - let e = { - let l1288 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1289 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1290 = l1289; - let bytes1290 = _rt::Vec::from_raw_parts( - l1288.cast(), - len1290, - len1290, - ); - _rt::string_lift(bytes1290) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l1291 { - 0 => None, - 1 => { - let e = { - let l1292 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1292 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result1303, - inherited: _rt::bool_lift(l1304 as u8), - } - }; - SpanData::LocalSpan(e1308) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1308 = { - let l1305 = *base.add(8).cast::<*mut u8>(); - let l1306 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1307 = l1306; - let bytes1307 = _rt::Vec::from_raw_parts( - l1305.cast(), - len1307, - len1307, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes1307), - } - }; - SpanData::ExternalSpan(e1308) - } - }; - v1308 - }; - result1309.push(e1309); - } - _rt::cabi_dealloc( - base1309, - len1309 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result1309 - }; - result1310.push(e1310); - } - _rt::cabi_dealloc( - base1310, - len1310 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes959), - method_name: _rt::string_lift(bytes962), - function_input: TypedDataValue { - value: v1119, - schema: v1267, - }, - trace_id: _rt::string_lift(bytes1270), - trace_states: result1276, - invocation_context: result1310, - } - }; - AgentInvocation::AgentMethodInvocation(e1321) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e1321 = { - let l1311 = *base.add(32).cast::<*mut u8>(); - let l1312 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1313 = l1312; - let l1314 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1315 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1316 = l1315; - let bytes1316 = _rt::Vec::from_raw_parts( - l1314.cast(), - len1316, - len1316, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1311.cast(), - len1313, - len1313, - ), - mime_type: _rt::string_lift(bytes1316), - }, - } - }; - AgentInvocation::LoadSnapshot(e1321) - } - 4 => { - let e1321 = { - let l1317 = *base.add(32).cast::<*mut u8>(); - let l1318 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1319 = l1318; - let bytes1319 = _rt::Vec::from_raw_parts( - l1317.cast(), - len1319, - len1319, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes1319), - } - }; - AgentInvocation::ProcessOplogEntries(e1321) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1321 = { - let l1320 = *base.add(32).cast::(); - ManualUpdateParameters { - target_revision: l1320 as u64, - } - }; - AgentInvocation::ManualUpdate(e1321) - } - }; - AgentInvocationStartedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l603 as u64, - nanoseconds: l604 as u32, - }, - invocation: v1321, - } - }; - PublicOplogEntry::AgentInvocationStarted(e2893) - } - 3 => { - let e2893 = { - let l1322 = *base.add(8).cast::(); - let l1323 = *base.add(16).cast::(); - let l1324 = i32::from(*base.add(24).cast::()); - let v1949 = match l1324 { - 0 => { - let e1949 = { - let l1325 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1481; - let v1481 = match l1325 { - 0 => { - let e1481 = { - let l1326 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1327 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1401 = l1326; - let len1401 = l1327; - let mut result1401 = _rt::Vec::with_capacity(len1401); - for i in 0..len1401 { - let base = base1401 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1401 = { - let l1328 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1400; - let v1400 = match l1328 { - 0 => { - let e1400 = { - let l1329 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1330 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1376 = l1329; - let len1376 = l1330; - let mut result1376 = _rt::Vec::with_capacity(len1376); - for i in 0..len1376 { - let base = base1376 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1376 = { - let l1331 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1375; - let v1375 = match l1331 { - 0 => { - let e1375 = { - let l1332 = *base.add(8).cast::<*mut u8>(); - let l1333 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1334 = l1333; - _rt::Vec::from_raw_parts(l1332.cast(), len1334, len1334) - }; - V1375::RecordValue(e1375) - } - 1 => { - let e1375 = { - let l1335 = *base.add(8).cast::(); - let l1336 = i32::from(*base.add(12).cast::()); - ( - l1335 as u32, - match l1336 { - 0 => None, - 1 => { - let e = { - let l1337 = *base.add(16).cast::(); - l1337 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1375::VariantValue(e1375) - } - 2 => { - let e1375 = { - let l1338 = *base.add(8).cast::(); - l1338 as u32 - }; - V1375::EnumValue(e1375) - } - 3 => { - let e1375 = { - let l1339 = *base.add(8).cast::<*mut u8>(); - let l1340 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1342 = l1339; - let len1342 = l1340; - let mut result1342 = _rt::Vec::with_capacity(len1342); - for i in 0..len1342 { - let base = base1342.add(i * 1); - let e1342 = { - let l1341 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1341 as u8) - }; - result1342.push(e1342); - } - _rt::cabi_dealloc(base1342, len1342 * 1, 1); - result1342 - }; - V1375::FlagsValue(e1375) - } - 4 => { - let e1375 = { - let l1343 = *base.add(8).cast::<*mut u8>(); - let l1344 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1345 = l1344; - _rt::Vec::from_raw_parts(l1343.cast(), len1345, len1345) - }; - V1375::TupleValue(e1375) - } - 5 => { - let e1375 = { - let l1346 = *base.add(8).cast::<*mut u8>(); - let l1347 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1348 = l1347; - _rt::Vec::from_raw_parts(l1346.cast(), len1348, len1348) - }; - V1375::ListValue(e1375) - } - 6 => { - let e1375 = { - let l1349 = i32::from(*base.add(8).cast::()); - match l1349 { - 0 => None, - 1 => { - let e = { - let l1350 = *base.add(12).cast::(); - l1350 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1375::OptionValue(e1375) - } - 7 => { - let e1375 = { - let l1351 = i32::from(*base.add(8).cast::()); - match l1351 { - 0 => { - let e = { - let l1352 = i32::from(*base.add(12).cast::()); - match l1352 { - 0 => None, - 1 => { - let e = { - let l1353 = *base.add(16).cast::(); - l1353 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1354 = i32::from(*base.add(12).cast::()); - match l1354 { - 0 => None, - 1 => { - let e = { - let l1355 = *base.add(16).cast::(); - l1355 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1375::ResultValue(e1375) - } - 8 => { - let e1375 = { - let l1356 = i32::from(*base.add(8).cast::()); - l1356 as u8 - }; - V1375::PrimU8(e1375) - } - 9 => { - let e1375 = { - let l1357 = i32::from(*base.add(8).cast::()); - l1357 as u16 - }; - V1375::PrimU16(e1375) - } - 10 => { - let e1375 = { - let l1358 = *base.add(8).cast::(); - l1358 as u32 - }; - V1375::PrimU32(e1375) - } - 11 => { - let e1375 = { - let l1359 = *base.add(8).cast::(); - l1359 as u64 - }; - V1375::PrimU64(e1375) - } - 12 => { - let e1375 = { - let l1360 = i32::from(*base.add(8).cast::()); - l1360 as i8 - }; - V1375::PrimS8(e1375) - } - 13 => { - let e1375 = { - let l1361 = i32::from(*base.add(8).cast::()); - l1361 as i16 - }; - V1375::PrimS16(e1375) - } - 14 => { - let e1375 = { - let l1362 = *base.add(8).cast::(); - l1362 - }; - V1375::PrimS32(e1375) - } - 15 => { - let e1375 = { - let l1363 = *base.add(8).cast::(); - l1363 - }; - V1375::PrimS64(e1375) - } - 16 => { - let e1375 = { - let l1364 = *base.add(8).cast::(); - l1364 - }; - V1375::PrimFloat32(e1375) - } - 17 => { - let e1375 = { - let l1365 = *base.add(8).cast::(); - l1365 - }; - V1375::PrimFloat64(e1375) - } - 18 => { - let e1375 = { - let l1366 = *base.add(8).cast::(); - _rt::char_lift(l1366 as u32) - }; - V1375::PrimChar(e1375) - } - 19 => { - let e1375 = { - let l1367 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1367 as u8) - }; - V1375::PrimBool(e1375) - } - 20 => { - let e1375 = { - let l1368 = *base.add(8).cast::<*mut u8>(); - let l1369 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1370 = l1369; - let bytes1370 = _rt::Vec::from_raw_parts( - l1368.cast(), - len1370, - len1370, - ); - _rt::string_lift(bytes1370) - }; - V1375::PrimString(e1375) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1375 = { - let l1371 = *base.add(8).cast::<*mut u8>(); - let l1372 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1373 = l1372; - let bytes1373 = _rt::Vec::from_raw_parts( - l1371.cast(), - len1373, - len1373, - ); - let l1374 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1373), - }, - l1374 as u64, - ) - }; - V1375::Handle(e1375) - } - }; - v1375 - }; - result1376.push(e1376); - } - _rt::cabi_dealloc( - base1376, - len1376 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1376, - } - }; - V1400::ComponentModel(e1400) - } - 1 => { - let e1400 = { - let l1377 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1388; - let v1388 = match l1377 { - 0 => { - let e1388 = { - let l1378 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1379 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1380 = l1379; - let bytes1380 = _rt::Vec::from_raw_parts( - l1378.cast(), - len1380, - len1380, - ); - _rt::string_lift(bytes1380) - }; - V1388::Url(e1388) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1388 = { - let l1381 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1382 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1383 = l1382; - let bytes1383 = _rt::Vec::from_raw_parts( - l1381.cast(), - len1383, - len1383, - ); - let l1384 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1383), - text_type: match l1384 { - 0 => None, - 1 => { - let e = { - let l1385 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1386 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1387 = l1386; - let bytes1387 = _rt::Vec::from_raw_parts( - l1385.cast(), - len1387, - len1387, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1387), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1388::Inline(e1388) - } - }; - v1388 - }; - V1400::UnstructuredText(e1400) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1400 = { - let l1389 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1399; - let v1399 = match l1389 { - 0 => { - let e1399 = { - let l1390 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1391 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1392 = l1391; - let bytes1392 = _rt::Vec::from_raw_parts( - l1390.cast(), - len1392, - len1392, - ); - _rt::string_lift(bytes1392) - }; - V1399::Url(e1399) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1399 = { - let l1393 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1394 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1395 = l1394; - let l1396 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1397 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1398 = l1397; - let bytes1398 = _rt::Vec::from_raw_parts( - l1396.cast(), - len1398, - len1398, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1393.cast(), - len1395, - len1395, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1398), - }, - } - }; - V1399::Inline(e1399) - } - }; - v1399 - }; - V1400::UnstructuredBinary(e1400) - } - }; - v1400 - }; - result1401.push(e1401); - } - _rt::cabi_dealloc( - base1401, - len1401 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1401 - }; - V1481::Tuple(e1481) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1481 = { - let l1402 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1403 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1480 = l1402; - let len1480 = l1403; - let mut result1480 = _rt::Vec::with_capacity(len1480); - for i in 0..len1480 { - let base = base1480 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1480 = { - let l1404 = *base.add(0).cast::<*mut u8>(); - let l1405 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1406 = l1405; - let bytes1406 = _rt::Vec::from_raw_parts( - l1404.cast(), - len1406, - len1406, - ); - let l1407 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1479; - let v1479 = match l1407 { - 0 => { - let e1479 = { - let l1408 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1409 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1455 = l1408; - let len1455 = l1409; - let mut result1455 = _rt::Vec::with_capacity(len1455); - for i in 0..len1455 { - let base = base1455 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1455 = { - let l1410 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1454; - let v1454 = match l1410 { - 0 => { - let e1454 = { - let l1411 = *base.add(8).cast::<*mut u8>(); - let l1412 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1413 = l1412; - _rt::Vec::from_raw_parts(l1411.cast(), len1413, len1413) - }; - V1454::RecordValue(e1454) - } - 1 => { - let e1454 = { - let l1414 = *base.add(8).cast::(); - let l1415 = i32::from(*base.add(12).cast::()); - ( - l1414 as u32, - match l1415 { - 0 => None, - 1 => { - let e = { - let l1416 = *base.add(16).cast::(); - l1416 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1454::VariantValue(e1454) - } - 2 => { - let e1454 = { - let l1417 = *base.add(8).cast::(); - l1417 as u32 - }; - V1454::EnumValue(e1454) - } - 3 => { - let e1454 = { - let l1418 = *base.add(8).cast::<*mut u8>(); - let l1419 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1421 = l1418; - let len1421 = l1419; - let mut result1421 = _rt::Vec::with_capacity(len1421); - for i in 0..len1421 { - let base = base1421.add(i * 1); - let e1421 = { - let l1420 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1420 as u8) - }; - result1421.push(e1421); - } - _rt::cabi_dealloc(base1421, len1421 * 1, 1); - result1421 - }; - V1454::FlagsValue(e1454) - } - 4 => { - let e1454 = { - let l1422 = *base.add(8).cast::<*mut u8>(); - let l1423 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1424 = l1423; - _rt::Vec::from_raw_parts(l1422.cast(), len1424, len1424) - }; - V1454::TupleValue(e1454) - } - 5 => { - let e1454 = { - let l1425 = *base.add(8).cast::<*mut u8>(); - let l1426 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1427 = l1426; - _rt::Vec::from_raw_parts(l1425.cast(), len1427, len1427) - }; - V1454::ListValue(e1454) - } - 6 => { - let e1454 = { - let l1428 = i32::from(*base.add(8).cast::()); - match l1428 { - 0 => None, - 1 => { - let e = { - let l1429 = *base.add(12).cast::(); - l1429 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1454::OptionValue(e1454) - } - 7 => { - let e1454 = { - let l1430 = i32::from(*base.add(8).cast::()); - match l1430 { - 0 => { - let e = { - let l1431 = i32::from(*base.add(12).cast::()); - match l1431 { - 0 => None, - 1 => { - let e = { - let l1432 = *base.add(16).cast::(); - l1432 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1433 = i32::from(*base.add(12).cast::()); - match l1433 { - 0 => None, - 1 => { - let e = { - let l1434 = *base.add(16).cast::(); - l1434 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1454::ResultValue(e1454) - } - 8 => { - let e1454 = { - let l1435 = i32::from(*base.add(8).cast::()); - l1435 as u8 - }; - V1454::PrimU8(e1454) - } - 9 => { - let e1454 = { - let l1436 = i32::from(*base.add(8).cast::()); - l1436 as u16 - }; - V1454::PrimU16(e1454) - } - 10 => { - let e1454 = { - let l1437 = *base.add(8).cast::(); - l1437 as u32 - }; - V1454::PrimU32(e1454) - } - 11 => { - let e1454 = { - let l1438 = *base.add(8).cast::(); - l1438 as u64 - }; - V1454::PrimU64(e1454) - } - 12 => { - let e1454 = { - let l1439 = i32::from(*base.add(8).cast::()); - l1439 as i8 - }; - V1454::PrimS8(e1454) - } - 13 => { - let e1454 = { - let l1440 = i32::from(*base.add(8).cast::()); - l1440 as i16 - }; - V1454::PrimS16(e1454) - } - 14 => { - let e1454 = { - let l1441 = *base.add(8).cast::(); - l1441 - }; - V1454::PrimS32(e1454) - } - 15 => { - let e1454 = { - let l1442 = *base.add(8).cast::(); - l1442 - }; - V1454::PrimS64(e1454) - } - 16 => { - let e1454 = { - let l1443 = *base.add(8).cast::(); - l1443 - }; - V1454::PrimFloat32(e1454) - } - 17 => { - let e1454 = { - let l1444 = *base.add(8).cast::(); - l1444 - }; - V1454::PrimFloat64(e1454) - } - 18 => { - let e1454 = { - let l1445 = *base.add(8).cast::(); - _rt::char_lift(l1445 as u32) - }; - V1454::PrimChar(e1454) - } - 19 => { - let e1454 = { - let l1446 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1446 as u8) - }; - V1454::PrimBool(e1454) - } - 20 => { - let e1454 = { - let l1447 = *base.add(8).cast::<*mut u8>(); - let l1448 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1449 = l1448; - let bytes1449 = _rt::Vec::from_raw_parts( - l1447.cast(), - len1449, - len1449, - ); - _rt::string_lift(bytes1449) - }; - V1454::PrimString(e1454) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1454 = { - let l1450 = *base.add(8).cast::<*mut u8>(); - let l1451 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1452 = l1451; - let bytes1452 = _rt::Vec::from_raw_parts( - l1450.cast(), - len1452, - len1452, - ); - let l1453 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1452), - }, - l1453 as u64, - ) - }; - V1454::Handle(e1454) - } - }; - v1454 - }; - result1455.push(e1455); - } - _rt::cabi_dealloc( - base1455, - len1455 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1455, - } - }; - V1479::ComponentModel(e1479) - } - 1 => { - let e1479 = { - let l1456 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1467; - let v1467 = match l1456 { - 0 => { - let e1467 = { - let l1457 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1458 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1459 = l1458; - let bytes1459 = _rt::Vec::from_raw_parts( - l1457.cast(), - len1459, - len1459, - ); - _rt::string_lift(bytes1459) - }; - V1467::Url(e1467) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1467 = { - let l1460 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1461 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1462 = l1461; - let bytes1462 = _rt::Vec::from_raw_parts( - l1460.cast(), - len1462, - len1462, - ); - let l1463 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1462), - text_type: match l1463 { - 0 => None, - 1 => { - let e = { - let l1464 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1465 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1466 = l1465; - let bytes1466 = _rt::Vec::from_raw_parts( - l1464.cast(), - len1466, - len1466, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1466), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1467::Inline(e1467) - } - }; - v1467 - }; - V1479::UnstructuredText(e1479) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1479 = { - let l1468 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1478; - let v1478 = match l1468 { - 0 => { - let e1478 = { - let l1469 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1470 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1471 = l1470; - let bytes1471 = _rt::Vec::from_raw_parts( - l1469.cast(), - len1471, - len1471, - ); - _rt::string_lift(bytes1471) - }; - V1478::Url(e1478) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1478 = { - let l1472 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1473 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1474 = l1473; - let l1475 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1476 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1477 = l1476; - let bytes1477 = _rt::Vec::from_raw_parts( - l1475.cast(), - len1477, - len1477, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1472.cast(), - len1474, - len1474, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1477), - }, - } - }; - V1478::Inline(e1478) - } - }; - v1478 - }; - V1479::UnstructuredBinary(e1479) - } - }; - (_rt::string_lift(bytes1406), v1479) - }; - result1480.push(e1480); - } - _rt::cabi_dealloc( - base1480, - len1480 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1480 - }; - V1481::Multimodal(e1481) - } - }; - let l1482 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1629; - let v1629 = match l1482 { - 0 => { - let e1629 = { - let l1483 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1484 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1555 = l1483; - let len1555 = l1484; - let mut result1555 = _rt::Vec::with_capacity(len1555); - for i in 0..len1555 { - let base = base1555 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1555 = { - let l1485 = *base.add(0).cast::<*mut u8>(); - let l1486 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1487 = l1486; - let bytes1487 = _rt::Vec::from_raw_parts( - l1485.cast(), - len1487, - len1487, - ); - let l1488 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1554; - let v1554 = match l1488 { - 0 => { - let e1554 = { - let l1489 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1490 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1539 = l1489; - let len1539 = l1490; - let mut result1539 = _rt::Vec::with_capacity(len1539); - for i in 0..len1539 { - let base = base1539 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1539 = { - let l1491 = i32::from(*base.add(0).cast::()); - let l1495 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1499 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1538; - let v1538 = match l1499 { - 0 => { - let e1538 = { - let l1500 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1501 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1506 = l1500; - let len1506 = l1501; - let mut result1506 = _rt::Vec::with_capacity(len1506); - for i in 0..len1506 { - let base = base1506 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1506 = { - let l1502 = *base.add(0).cast::<*mut u8>(); - let l1503 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1504 = l1503; - let bytes1504 = _rt::Vec::from_raw_parts( - l1502.cast(), - len1504, - len1504, - ); - let l1505 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1504), l1505) - }; - result1506.push(e1506); - } - _rt::cabi_dealloc( - base1506, - len1506 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1506 - }; - V1538::RecordType(e1538) - } - 1 => { - let e1538 = { - let l1507 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1508 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1514 = l1507; - let len1514 = l1508; - let mut result1514 = _rt::Vec::with_capacity(len1514); - for i in 0..len1514 { - let base = base1514 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1514 = { - let l1509 = *base.add(0).cast::<*mut u8>(); - let l1510 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1511 = l1510; - let bytes1511 = _rt::Vec::from_raw_parts( - l1509.cast(), - len1511, - len1511, - ); - let l1512 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1511), - match l1512 { - 0 => None, - 1 => { - let e = { - let l1513 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1513 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1514.push(e1514); - } - _rt::cabi_dealloc( - base1514, - len1514 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1514 - }; - V1538::VariantType(e1538) - } - 2 => { - let e1538 = { - let l1515 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1516 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1520 = l1515; - let len1520 = l1516; - let mut result1520 = _rt::Vec::with_capacity(len1520); - for i in 0..len1520 { - let base = base1520 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1520 = { - let l1517 = *base.add(0).cast::<*mut u8>(); - let l1518 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1519 = l1518; - let bytes1519 = _rt::Vec::from_raw_parts( - l1517.cast(), - len1519, - len1519, - ); - _rt::string_lift(bytes1519) - }; - result1520.push(e1520); - } - _rt::cabi_dealloc( - base1520, - len1520 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1520 - }; - V1538::EnumType(e1538) - } - 3 => { - let e1538 = { - let l1521 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1522 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1526 = l1521; - let len1526 = l1522; - let mut result1526 = _rt::Vec::with_capacity(len1526); - for i in 0..len1526 { - let base = base1526 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1526 = { - let l1523 = *base.add(0).cast::<*mut u8>(); - let l1524 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1525 = l1524; - let bytes1525 = _rt::Vec::from_raw_parts( - l1523.cast(), - len1525, - len1525, - ); - _rt::string_lift(bytes1525) - }; - result1526.push(e1526); - } - _rt::cabi_dealloc( - base1526, - len1526 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1526 - }; - V1538::FlagsType(e1538) - } - 4 => { - let e1538 = { - let l1527 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1528 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1529 = l1528; - _rt::Vec::from_raw_parts(l1527.cast(), len1529, len1529) - }; - V1538::TupleType(e1538) - } - 5 => { - let e1538 = { - let l1530 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1530 - }; - V1538::ListType(e1538) - } - 6 => { - let e1538 = { - let l1531 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1531 - }; - V1538::OptionType(e1538) - } - 7 => { - let e1538 = { - let l1532 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1534 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1532 { - 0 => None, - 1 => { - let e = { - let l1533 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1533 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1534 { - 0 => None, - 1 => { - let e = { - let l1535 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1535 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1538::ResultType(e1538) - } - 8 => V1538::PrimU8Type, - 9 => V1538::PrimU16Type, - 10 => V1538::PrimU32Type, - 11 => V1538::PrimU64Type, - 12 => V1538::PrimS8Type, - 13 => V1538::PrimS16Type, - 14 => V1538::PrimS32Type, - 15 => V1538::PrimS64Type, - 16 => V1538::PrimF32Type, - 17 => V1538::PrimF64Type, - 18 => V1538::PrimCharType, - 19 => V1538::PrimBoolType, - 20 => V1538::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1538 = { - let l1536 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1537 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1536 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1537 as u8, - ), - ) - }; - V1538::HandleType(e1538) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1491 { - 0 => None, - 1 => { - let e = { - let l1492 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1493 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1494 = l1493; - let bytes1494 = _rt::Vec::from_raw_parts( - l1492.cast(), - len1494, - len1494, - ); - _rt::string_lift(bytes1494) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1495 { - 0 => None, - 1 => { - let e = { - let l1496 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1497 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1498 = l1497; - let bytes1498 = _rt::Vec::from_raw_parts( - l1496.cast(), - len1498, - len1498, - ); - _rt::string_lift(bytes1498) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1538, - } - }; - result1539.push(e1539); - } - _rt::cabi_dealloc( - base1539, - len1539 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1539, - } - }; - V1554::ComponentModel(e1554) - } - 1 => { - let e1554 = { - let l1540 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1540 { - 0 => None, - 1 => { - let e = { - let l1541 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1542 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1546 = l1541; - let len1546 = l1542; - let mut result1546 = _rt::Vec::with_capacity(len1546); - for i in 0..len1546 { - let base = base1546 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1546 = { - let l1543 = *base.add(0).cast::<*mut u8>(); - let l1544 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1545 = l1544; - let bytes1545 = _rt::Vec::from_raw_parts( - l1543.cast(), - len1545, - len1545, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1545), - } - }; - result1546.push(e1546); - } - _rt::cabi_dealloc( - base1546, - len1546 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1546 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1554::UnstructuredText(e1554) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1554 = { - let l1547 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1547 { - 0 => None, - 1 => { - let e = { - let l1548 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1549 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1553 = l1548; - let len1553 = l1549; - let mut result1553 = _rt::Vec::with_capacity(len1553); - for i in 0..len1553 { - let base = base1553 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1553 = { - let l1550 = *base.add(0).cast::<*mut u8>(); - let l1551 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1552 = l1551; - let bytes1552 = _rt::Vec::from_raw_parts( - l1550.cast(), - len1552, - len1552, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1552), - } - }; - result1553.push(e1553); - } - _rt::cabi_dealloc( - base1553, - len1553 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1553 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1554::UnstructuredBinary(e1554) - } - }; - (_rt::string_lift(bytes1487), v1554) - }; - result1555.push(e1555); - } - _rt::cabi_dealloc( - base1555, - len1555 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1555 - }; - V1629::Tuple(e1629) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1629 = { - let l1556 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1557 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1628 = l1556; - let len1628 = l1557; - let mut result1628 = _rt::Vec::with_capacity(len1628); - for i in 0..len1628 { - let base = base1628 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1628 = { - let l1558 = *base.add(0).cast::<*mut u8>(); - let l1559 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1560 = l1559; - let bytes1560 = _rt::Vec::from_raw_parts( - l1558.cast(), - len1560, - len1560, - ); - let l1561 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1627; - let v1627 = match l1561 { - 0 => { - let e1627 = { - let l1562 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1563 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1612 = l1562; - let len1612 = l1563; - let mut result1612 = _rt::Vec::with_capacity(len1612); - for i in 0..len1612 { - let base = base1612 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1612 = { - let l1564 = i32::from(*base.add(0).cast::()); - let l1568 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1572 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1611; - let v1611 = match l1572 { - 0 => { - let e1611 = { - let l1573 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1574 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1579 = l1573; - let len1579 = l1574; - let mut result1579 = _rt::Vec::with_capacity(len1579); - for i in 0..len1579 { - let base = base1579 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1579 = { - let l1575 = *base.add(0).cast::<*mut u8>(); - let l1576 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1577 = l1576; - let bytes1577 = _rt::Vec::from_raw_parts( - l1575.cast(), - len1577, - len1577, - ); - let l1578 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1577), l1578) - }; - result1579.push(e1579); - } - _rt::cabi_dealloc( - base1579, - len1579 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1579 - }; - V1611::RecordType(e1611) - } - 1 => { - let e1611 = { - let l1580 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1581 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1587 = l1580; - let len1587 = l1581; - let mut result1587 = _rt::Vec::with_capacity(len1587); - for i in 0..len1587 { - let base = base1587 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1587 = { - let l1582 = *base.add(0).cast::<*mut u8>(); - let l1583 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1584 = l1583; - let bytes1584 = _rt::Vec::from_raw_parts( - l1582.cast(), - len1584, - len1584, - ); - let l1585 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1584), - match l1585 { - 0 => None, - 1 => { - let e = { - let l1586 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1586 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1587.push(e1587); - } - _rt::cabi_dealloc( - base1587, - len1587 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1587 - }; - V1611::VariantType(e1611) - } - 2 => { - let e1611 = { - let l1588 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1589 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1593 = l1588; - let len1593 = l1589; - let mut result1593 = _rt::Vec::with_capacity(len1593); - for i in 0..len1593 { - let base = base1593 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1593 = { - let l1590 = *base.add(0).cast::<*mut u8>(); - let l1591 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1592 = l1591; - let bytes1592 = _rt::Vec::from_raw_parts( - l1590.cast(), - len1592, - len1592, - ); - _rt::string_lift(bytes1592) - }; - result1593.push(e1593); - } - _rt::cabi_dealloc( - base1593, - len1593 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1593 - }; - V1611::EnumType(e1611) - } - 3 => { - let e1611 = { - let l1594 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1595 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1599 = l1594; - let len1599 = l1595; - let mut result1599 = _rt::Vec::with_capacity(len1599); - for i in 0..len1599 { - let base = base1599 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1599 = { - let l1596 = *base.add(0).cast::<*mut u8>(); - let l1597 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1598 = l1597; - let bytes1598 = _rt::Vec::from_raw_parts( - l1596.cast(), - len1598, - len1598, - ); - _rt::string_lift(bytes1598) - }; - result1599.push(e1599); - } - _rt::cabi_dealloc( - base1599, - len1599 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1599 - }; - V1611::FlagsType(e1611) - } - 4 => { - let e1611 = { - let l1600 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1601 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1602 = l1601; - _rt::Vec::from_raw_parts(l1600.cast(), len1602, len1602) - }; - V1611::TupleType(e1611) - } - 5 => { - let e1611 = { - let l1603 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1603 - }; - V1611::ListType(e1611) - } - 6 => { - let e1611 = { - let l1604 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1604 - }; - V1611::OptionType(e1611) - } - 7 => { - let e1611 = { - let l1605 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1607 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1605 { - 0 => None, - 1 => { - let e = { - let l1606 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1606 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1607 { - 0 => None, - 1 => { - let e = { - let l1608 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1608 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1611::ResultType(e1611) - } - 8 => V1611::PrimU8Type, - 9 => V1611::PrimU16Type, - 10 => V1611::PrimU32Type, - 11 => V1611::PrimU64Type, - 12 => V1611::PrimS8Type, - 13 => V1611::PrimS16Type, - 14 => V1611::PrimS32Type, - 15 => V1611::PrimS64Type, - 16 => V1611::PrimF32Type, - 17 => V1611::PrimF64Type, - 18 => V1611::PrimCharType, - 19 => V1611::PrimBoolType, - 20 => V1611::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1611 = { - let l1609 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1610 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1609 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1610 as u8, - ), - ) - }; - V1611::HandleType(e1611) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1564 { - 0 => None, - 1 => { - let e = { - let l1565 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1566 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1567 = l1566; - let bytes1567 = _rt::Vec::from_raw_parts( - l1565.cast(), - len1567, - len1567, - ); - _rt::string_lift(bytes1567) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1568 { - 0 => None, - 1 => { - let e = { - let l1569 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1570 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1571 = l1570; - let bytes1571 = _rt::Vec::from_raw_parts( - l1569.cast(), - len1571, - len1571, - ); - _rt::string_lift(bytes1571) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1611, - } - }; - result1612.push(e1612); - } - _rt::cabi_dealloc( - base1612, - len1612 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1612, - } - }; - V1627::ComponentModel(e1627) - } - 1 => { - let e1627 = { - let l1613 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1613 { - 0 => None, - 1 => { - let e = { - let l1614 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1615 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1619 = l1614; - let len1619 = l1615; - let mut result1619 = _rt::Vec::with_capacity(len1619); - for i in 0..len1619 { - let base = base1619 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1619 = { - let l1616 = *base.add(0).cast::<*mut u8>(); - let l1617 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1618 = l1617; - let bytes1618 = _rt::Vec::from_raw_parts( - l1616.cast(), - len1618, - len1618, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1618), - } - }; - result1619.push(e1619); - } - _rt::cabi_dealloc( - base1619, - len1619 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1619 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1627::UnstructuredText(e1627) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1627 = { - let l1620 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1620 { - 0 => None, - 1 => { - let e = { - let l1621 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1622 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1626 = l1621; - let len1626 = l1622; - let mut result1626 = _rt::Vec::with_capacity(len1626); - for i in 0..len1626 { - let base = base1626 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1626 = { - let l1623 = *base.add(0).cast::<*mut u8>(); - let l1624 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1625 = l1624; - let bytes1625 = _rt::Vec::from_raw_parts( - l1623.cast(), - len1625, - len1625, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1625), - } - }; - result1626.push(e1626); - } - _rt::cabi_dealloc( - base1626, - len1626 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1626 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1627::UnstructuredBinary(e1627) - } - }; - (_rt::string_lift(bytes1560), v1627) - }; - result1628.push(e1628); - } - _rt::cabi_dealloc( - base1628, - len1628 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1628 - }; - V1629::Multimodal(e1629) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1481, - schema: v1629, - }, - } - }; - AgentInvocationResult::AgentInitialization(e1949) - } - 1 => { - let e1949 = { - let l1630 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1786; - let v1786 = match l1630 { - 0 => { - let e1786 = { - let l1631 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1632 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1706 = l1631; - let len1706 = l1632; - let mut result1706 = _rt::Vec::with_capacity(len1706); - for i in 0..len1706 { - let base = base1706 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1706 = { - let l1633 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1705; - let v1705 = match l1633 { - 0 => { - let e1705 = { - let l1634 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1635 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1681 = l1634; - let len1681 = l1635; - let mut result1681 = _rt::Vec::with_capacity(len1681); - for i in 0..len1681 { - let base = base1681 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1681 = { - let l1636 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1680; - let v1680 = match l1636 { - 0 => { - let e1680 = { - let l1637 = *base.add(8).cast::<*mut u8>(); - let l1638 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1639 = l1638; - _rt::Vec::from_raw_parts(l1637.cast(), len1639, len1639) - }; - V1680::RecordValue(e1680) - } - 1 => { - let e1680 = { - let l1640 = *base.add(8).cast::(); - let l1641 = i32::from(*base.add(12).cast::()); - ( - l1640 as u32, - match l1641 { - 0 => None, - 1 => { - let e = { - let l1642 = *base.add(16).cast::(); - l1642 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1680::VariantValue(e1680) - } - 2 => { - let e1680 = { - let l1643 = *base.add(8).cast::(); - l1643 as u32 - }; - V1680::EnumValue(e1680) - } - 3 => { - let e1680 = { - let l1644 = *base.add(8).cast::<*mut u8>(); - let l1645 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1647 = l1644; - let len1647 = l1645; - let mut result1647 = _rt::Vec::with_capacity(len1647); - for i in 0..len1647 { - let base = base1647.add(i * 1); - let e1647 = { - let l1646 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1646 as u8) - }; - result1647.push(e1647); - } - _rt::cabi_dealloc(base1647, len1647 * 1, 1); - result1647 - }; - V1680::FlagsValue(e1680) - } - 4 => { - let e1680 = { - let l1648 = *base.add(8).cast::<*mut u8>(); - let l1649 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1650 = l1649; - _rt::Vec::from_raw_parts(l1648.cast(), len1650, len1650) - }; - V1680::TupleValue(e1680) - } - 5 => { - let e1680 = { - let l1651 = *base.add(8).cast::<*mut u8>(); - let l1652 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1653 = l1652; - _rt::Vec::from_raw_parts(l1651.cast(), len1653, len1653) - }; - V1680::ListValue(e1680) - } - 6 => { - let e1680 = { - let l1654 = i32::from(*base.add(8).cast::()); - match l1654 { - 0 => None, - 1 => { - let e = { - let l1655 = *base.add(12).cast::(); - l1655 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1680::OptionValue(e1680) - } - 7 => { - let e1680 = { - let l1656 = i32::from(*base.add(8).cast::()); - match l1656 { - 0 => { - let e = { - let l1657 = i32::from(*base.add(12).cast::()); - match l1657 { - 0 => None, - 1 => { - let e = { - let l1658 = *base.add(16).cast::(); - l1658 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1659 = i32::from(*base.add(12).cast::()); - match l1659 { - 0 => None, - 1 => { - let e = { - let l1660 = *base.add(16).cast::(); - l1660 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1680::ResultValue(e1680) - } - 8 => { - let e1680 = { - let l1661 = i32::from(*base.add(8).cast::()); - l1661 as u8 - }; - V1680::PrimU8(e1680) - } - 9 => { - let e1680 = { - let l1662 = i32::from(*base.add(8).cast::()); - l1662 as u16 - }; - V1680::PrimU16(e1680) - } - 10 => { - let e1680 = { - let l1663 = *base.add(8).cast::(); - l1663 as u32 - }; - V1680::PrimU32(e1680) - } - 11 => { - let e1680 = { - let l1664 = *base.add(8).cast::(); - l1664 as u64 - }; - V1680::PrimU64(e1680) - } - 12 => { - let e1680 = { - let l1665 = i32::from(*base.add(8).cast::()); - l1665 as i8 - }; - V1680::PrimS8(e1680) - } - 13 => { - let e1680 = { - let l1666 = i32::from(*base.add(8).cast::()); - l1666 as i16 - }; - V1680::PrimS16(e1680) - } - 14 => { - let e1680 = { - let l1667 = *base.add(8).cast::(); - l1667 - }; - V1680::PrimS32(e1680) - } - 15 => { - let e1680 = { - let l1668 = *base.add(8).cast::(); - l1668 - }; - V1680::PrimS64(e1680) - } - 16 => { - let e1680 = { - let l1669 = *base.add(8).cast::(); - l1669 - }; - V1680::PrimFloat32(e1680) - } - 17 => { - let e1680 = { - let l1670 = *base.add(8).cast::(); - l1670 - }; - V1680::PrimFloat64(e1680) - } - 18 => { - let e1680 = { - let l1671 = *base.add(8).cast::(); - _rt::char_lift(l1671 as u32) - }; - V1680::PrimChar(e1680) - } - 19 => { - let e1680 = { - let l1672 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1672 as u8) - }; - V1680::PrimBool(e1680) - } - 20 => { - let e1680 = { - let l1673 = *base.add(8).cast::<*mut u8>(); - let l1674 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1675 = l1674; - let bytes1675 = _rt::Vec::from_raw_parts( - l1673.cast(), - len1675, - len1675, - ); - _rt::string_lift(bytes1675) - }; - V1680::PrimString(e1680) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1680 = { - let l1676 = *base.add(8).cast::<*mut u8>(); - let l1677 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1678 = l1677; - let bytes1678 = _rt::Vec::from_raw_parts( - l1676.cast(), - len1678, - len1678, - ); - let l1679 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1678), - }, - l1679 as u64, - ) - }; - V1680::Handle(e1680) - } - }; - v1680 - }; - result1681.push(e1681); - } - _rt::cabi_dealloc( - base1681, - len1681 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1681, - } - }; - V1705::ComponentModel(e1705) - } - 1 => { - let e1705 = { - let l1682 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1693; - let v1693 = match l1682 { - 0 => { - let e1693 = { - let l1683 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1684 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1685 = l1684; - let bytes1685 = _rt::Vec::from_raw_parts( - l1683.cast(), - len1685, - len1685, - ); - _rt::string_lift(bytes1685) - }; - V1693::Url(e1693) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1693 = { - let l1686 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1687 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1688 = l1687; - let bytes1688 = _rt::Vec::from_raw_parts( - l1686.cast(), - len1688, - len1688, - ); - let l1689 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1688), - text_type: match l1689 { - 0 => None, - 1 => { - let e = { - let l1690 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1691 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1692 = l1691; - let bytes1692 = _rt::Vec::from_raw_parts( - l1690.cast(), - len1692, - len1692, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1692), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1693::Inline(e1693) - } - }; - v1693 - }; - V1705::UnstructuredText(e1705) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1705 = { - let l1694 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1704; - let v1704 = match l1694 { - 0 => { - let e1704 = { - let l1695 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1696 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1697 = l1696; - let bytes1697 = _rt::Vec::from_raw_parts( - l1695.cast(), - len1697, - len1697, - ); - _rt::string_lift(bytes1697) - }; - V1704::Url(e1704) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1704 = { - let l1698 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1699 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1700 = l1699; - let l1701 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1702 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1703 = l1702; - let bytes1703 = _rt::Vec::from_raw_parts( - l1701.cast(), - len1703, - len1703, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1698.cast(), - len1700, - len1700, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1703), - }, - } - }; - V1704::Inline(e1704) - } - }; - v1704 - }; - V1705::UnstructuredBinary(e1705) - } - }; - v1705 - }; - result1706.push(e1706); - } - _rt::cabi_dealloc( - base1706, - len1706 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1706 - }; - V1786::Tuple(e1786) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1786 = { - let l1707 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1708 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1785 = l1707; - let len1785 = l1708; - let mut result1785 = _rt::Vec::with_capacity(len1785); - for i in 0..len1785 { - let base = base1785 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1785 = { - let l1709 = *base.add(0).cast::<*mut u8>(); - let l1710 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1711 = l1710; - let bytes1711 = _rt::Vec::from_raw_parts( - l1709.cast(), - len1711, - len1711, - ); - let l1712 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1784; - let v1784 = match l1712 { - 0 => { - let e1784 = { - let l1713 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1714 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1760 = l1713; - let len1760 = l1714; - let mut result1760 = _rt::Vec::with_capacity(len1760); - for i in 0..len1760 { - let base = base1760 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1760 = { - let l1715 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1759; - let v1759 = match l1715 { - 0 => { - let e1759 = { - let l1716 = *base.add(8).cast::<*mut u8>(); - let l1717 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1718 = l1717; - _rt::Vec::from_raw_parts(l1716.cast(), len1718, len1718) - }; - V1759::RecordValue(e1759) - } - 1 => { - let e1759 = { - let l1719 = *base.add(8).cast::(); - let l1720 = i32::from(*base.add(12).cast::()); - ( - l1719 as u32, - match l1720 { - 0 => None, - 1 => { - let e = { - let l1721 = *base.add(16).cast::(); - l1721 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1759::VariantValue(e1759) - } - 2 => { - let e1759 = { - let l1722 = *base.add(8).cast::(); - l1722 as u32 - }; - V1759::EnumValue(e1759) - } - 3 => { - let e1759 = { - let l1723 = *base.add(8).cast::<*mut u8>(); - let l1724 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1726 = l1723; - let len1726 = l1724; - let mut result1726 = _rt::Vec::with_capacity(len1726); - for i in 0..len1726 { - let base = base1726.add(i * 1); - let e1726 = { - let l1725 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1725 as u8) - }; - result1726.push(e1726); - } - _rt::cabi_dealloc(base1726, len1726 * 1, 1); - result1726 - }; - V1759::FlagsValue(e1759) - } - 4 => { - let e1759 = { - let l1727 = *base.add(8).cast::<*mut u8>(); - let l1728 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1729 = l1728; - _rt::Vec::from_raw_parts(l1727.cast(), len1729, len1729) - }; - V1759::TupleValue(e1759) - } - 5 => { - let e1759 = { - let l1730 = *base.add(8).cast::<*mut u8>(); - let l1731 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1732 = l1731; - _rt::Vec::from_raw_parts(l1730.cast(), len1732, len1732) - }; - V1759::ListValue(e1759) - } - 6 => { - let e1759 = { - let l1733 = i32::from(*base.add(8).cast::()); - match l1733 { - 0 => None, - 1 => { - let e = { - let l1734 = *base.add(12).cast::(); - l1734 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1759::OptionValue(e1759) - } - 7 => { - let e1759 = { - let l1735 = i32::from(*base.add(8).cast::()); - match l1735 { - 0 => { - let e = { - let l1736 = i32::from(*base.add(12).cast::()); - match l1736 { - 0 => None, - 1 => { - let e = { - let l1737 = *base.add(16).cast::(); - l1737 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1738 = i32::from(*base.add(12).cast::()); - match l1738 { - 0 => None, - 1 => { - let e = { - let l1739 = *base.add(16).cast::(); - l1739 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1759::ResultValue(e1759) - } - 8 => { - let e1759 = { - let l1740 = i32::from(*base.add(8).cast::()); - l1740 as u8 - }; - V1759::PrimU8(e1759) - } - 9 => { - let e1759 = { - let l1741 = i32::from(*base.add(8).cast::()); - l1741 as u16 - }; - V1759::PrimU16(e1759) - } - 10 => { - let e1759 = { - let l1742 = *base.add(8).cast::(); - l1742 as u32 - }; - V1759::PrimU32(e1759) - } - 11 => { - let e1759 = { - let l1743 = *base.add(8).cast::(); - l1743 as u64 - }; - V1759::PrimU64(e1759) - } - 12 => { - let e1759 = { - let l1744 = i32::from(*base.add(8).cast::()); - l1744 as i8 - }; - V1759::PrimS8(e1759) - } - 13 => { - let e1759 = { - let l1745 = i32::from(*base.add(8).cast::()); - l1745 as i16 - }; - V1759::PrimS16(e1759) - } - 14 => { - let e1759 = { - let l1746 = *base.add(8).cast::(); - l1746 - }; - V1759::PrimS32(e1759) - } - 15 => { - let e1759 = { - let l1747 = *base.add(8).cast::(); - l1747 - }; - V1759::PrimS64(e1759) - } - 16 => { - let e1759 = { - let l1748 = *base.add(8).cast::(); - l1748 - }; - V1759::PrimFloat32(e1759) - } - 17 => { - let e1759 = { - let l1749 = *base.add(8).cast::(); - l1749 - }; - V1759::PrimFloat64(e1759) - } - 18 => { - let e1759 = { - let l1750 = *base.add(8).cast::(); - _rt::char_lift(l1750 as u32) - }; - V1759::PrimChar(e1759) - } - 19 => { - let e1759 = { - let l1751 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1751 as u8) - }; - V1759::PrimBool(e1759) - } - 20 => { - let e1759 = { - let l1752 = *base.add(8).cast::<*mut u8>(); - let l1753 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1754 = l1753; - let bytes1754 = _rt::Vec::from_raw_parts( - l1752.cast(), - len1754, - len1754, - ); - _rt::string_lift(bytes1754) - }; - V1759::PrimString(e1759) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1759 = { - let l1755 = *base.add(8).cast::<*mut u8>(); - let l1756 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1757 = l1756; - let bytes1757 = _rt::Vec::from_raw_parts( - l1755.cast(), - len1757, - len1757, - ); - let l1758 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1757), - }, - l1758 as u64, - ) - }; - V1759::Handle(e1759) - } - }; - v1759 - }; - result1760.push(e1760); - } - _rt::cabi_dealloc( - base1760, - len1760 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1760, - } - }; - V1784::ComponentModel(e1784) - } - 1 => { - let e1784 = { - let l1761 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1772; - let v1772 = match l1761 { - 0 => { - let e1772 = { - let l1762 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1763 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1764 = l1763; - let bytes1764 = _rt::Vec::from_raw_parts( - l1762.cast(), - len1764, - len1764, - ); - _rt::string_lift(bytes1764) - }; - V1772::Url(e1772) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1772 = { - let l1765 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1766 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1767 = l1766; - let bytes1767 = _rt::Vec::from_raw_parts( - l1765.cast(), - len1767, - len1767, - ); - let l1768 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1767), - text_type: match l1768 { - 0 => None, - 1 => { - let e = { - let l1769 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1770 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1771 = l1770; - let bytes1771 = _rt::Vec::from_raw_parts( - l1769.cast(), - len1771, - len1771, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1771), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1772::Inline(e1772) - } - }; - v1772 - }; - V1784::UnstructuredText(e1784) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1784 = { - let l1773 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1783; - let v1783 = match l1773 { - 0 => { - let e1783 = { - let l1774 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1775 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1776 = l1775; - let bytes1776 = _rt::Vec::from_raw_parts( - l1774.cast(), - len1776, - len1776, - ); - _rt::string_lift(bytes1776) - }; - V1783::Url(e1783) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1783 = { - let l1777 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1778 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1779 = l1778; - let l1780 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1781 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1782 = l1781; - let bytes1782 = _rt::Vec::from_raw_parts( - l1780.cast(), - len1782, - len1782, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1777.cast(), - len1779, - len1779, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1782), - }, - } - }; - V1783::Inline(e1783) - } - }; - v1783 - }; - V1784::UnstructuredBinary(e1784) - } - }; - (_rt::string_lift(bytes1711), v1784) - }; - result1785.push(e1785); - } - _rt::cabi_dealloc( - base1785, - len1785 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1785 - }; - V1786::Multimodal(e1786) - } - }; - let l1787 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1934; - let v1934 = match l1787 { - 0 => { - let e1934 = { - let l1788 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1789 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1860 = l1788; - let len1860 = l1789; - let mut result1860 = _rt::Vec::with_capacity(len1860); - for i in 0..len1860 { - let base = base1860 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1860 = { - let l1790 = *base.add(0).cast::<*mut u8>(); - let l1791 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1792 = l1791; - let bytes1792 = _rt::Vec::from_raw_parts( - l1790.cast(), - len1792, - len1792, - ); - let l1793 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1859; - let v1859 = match l1793 { - 0 => { - let e1859 = { - let l1794 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1795 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1844 = l1794; - let len1844 = l1795; - let mut result1844 = _rt::Vec::with_capacity(len1844); - for i in 0..len1844 { - let base = base1844 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1844 = { - let l1796 = i32::from(*base.add(0).cast::()); - let l1800 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1804 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1843; - let v1843 = match l1804 { - 0 => { - let e1843 = { - let l1805 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1806 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1811 = l1805; - let len1811 = l1806; - let mut result1811 = _rt::Vec::with_capacity(len1811); - for i in 0..len1811 { - let base = base1811 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1811 = { - let l1807 = *base.add(0).cast::<*mut u8>(); - let l1808 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1809 = l1808; - let bytes1809 = _rt::Vec::from_raw_parts( - l1807.cast(), - len1809, - len1809, - ); - let l1810 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1809), l1810) - }; - result1811.push(e1811); - } - _rt::cabi_dealloc( - base1811, - len1811 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1811 - }; - V1843::RecordType(e1843) - } - 1 => { - let e1843 = { - let l1812 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1813 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1819 = l1812; - let len1819 = l1813; - let mut result1819 = _rt::Vec::with_capacity(len1819); - for i in 0..len1819 { - let base = base1819 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1819 = { - let l1814 = *base.add(0).cast::<*mut u8>(); - let l1815 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1816 = l1815; - let bytes1816 = _rt::Vec::from_raw_parts( - l1814.cast(), - len1816, - len1816, - ); - let l1817 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1816), - match l1817 { - 0 => None, - 1 => { - let e = { - let l1818 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1818 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1819.push(e1819); - } - _rt::cabi_dealloc( - base1819, - len1819 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1819 - }; - V1843::VariantType(e1843) - } - 2 => { - let e1843 = { - let l1820 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1821 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1825 = l1820; - let len1825 = l1821; - let mut result1825 = _rt::Vec::with_capacity(len1825); - for i in 0..len1825 { - let base = base1825 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1825 = { - let l1822 = *base.add(0).cast::<*mut u8>(); - let l1823 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1824 = l1823; - let bytes1824 = _rt::Vec::from_raw_parts( - l1822.cast(), - len1824, - len1824, - ); - _rt::string_lift(bytes1824) - }; - result1825.push(e1825); - } - _rt::cabi_dealloc( - base1825, - len1825 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1825 - }; - V1843::EnumType(e1843) - } - 3 => { - let e1843 = { - let l1826 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1827 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1831 = l1826; - let len1831 = l1827; - let mut result1831 = _rt::Vec::with_capacity(len1831); - for i in 0..len1831 { - let base = base1831 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1831 = { - let l1828 = *base.add(0).cast::<*mut u8>(); - let l1829 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1830 = l1829; - let bytes1830 = _rt::Vec::from_raw_parts( - l1828.cast(), - len1830, - len1830, - ); - _rt::string_lift(bytes1830) - }; - result1831.push(e1831); - } - _rt::cabi_dealloc( - base1831, - len1831 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1831 - }; - V1843::FlagsType(e1843) - } - 4 => { - let e1843 = { - let l1832 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1833 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1834 = l1833; - _rt::Vec::from_raw_parts(l1832.cast(), len1834, len1834) - }; - V1843::TupleType(e1843) - } - 5 => { - let e1843 = { - let l1835 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1835 - }; - V1843::ListType(e1843) - } - 6 => { - let e1843 = { - let l1836 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1836 - }; - V1843::OptionType(e1843) - } - 7 => { - let e1843 = { - let l1837 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1839 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1837 { - 0 => None, - 1 => { - let e = { - let l1838 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1838 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1839 { - 0 => None, - 1 => { - let e = { - let l1840 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1840 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1843::ResultType(e1843) - } - 8 => V1843::PrimU8Type, - 9 => V1843::PrimU16Type, - 10 => V1843::PrimU32Type, - 11 => V1843::PrimU64Type, - 12 => V1843::PrimS8Type, - 13 => V1843::PrimS16Type, - 14 => V1843::PrimS32Type, - 15 => V1843::PrimS64Type, - 16 => V1843::PrimF32Type, - 17 => V1843::PrimF64Type, - 18 => V1843::PrimCharType, - 19 => V1843::PrimBoolType, - 20 => V1843::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1843 = { - let l1841 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1842 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1841 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1842 as u8, - ), - ) - }; - V1843::HandleType(e1843) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1796 { - 0 => None, - 1 => { - let e = { - let l1797 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1798 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1799 = l1798; - let bytes1799 = _rt::Vec::from_raw_parts( - l1797.cast(), - len1799, - len1799, - ); - _rt::string_lift(bytes1799) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1800 { - 0 => None, - 1 => { - let e = { - let l1801 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1802 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1803 = l1802; - let bytes1803 = _rt::Vec::from_raw_parts( - l1801.cast(), - len1803, - len1803, - ); - _rt::string_lift(bytes1803) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1843, - } - }; - result1844.push(e1844); - } - _rt::cabi_dealloc( - base1844, - len1844 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1844, - } - }; - V1859::ComponentModel(e1859) - } - 1 => { - let e1859 = { - let l1845 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1845 { - 0 => None, - 1 => { - let e = { - let l1846 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1847 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1851 = l1846; - let len1851 = l1847; - let mut result1851 = _rt::Vec::with_capacity(len1851); - for i in 0..len1851 { - let base = base1851 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1851 = { - let l1848 = *base.add(0).cast::<*mut u8>(); - let l1849 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1850 = l1849; - let bytes1850 = _rt::Vec::from_raw_parts( - l1848.cast(), - len1850, - len1850, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1850), - } - }; - result1851.push(e1851); - } - _rt::cabi_dealloc( - base1851, - len1851 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1851 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1859::UnstructuredText(e1859) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1859 = { - let l1852 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1852 { - 0 => None, - 1 => { - let e = { - let l1853 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1854 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1858 = l1853; - let len1858 = l1854; - let mut result1858 = _rt::Vec::with_capacity(len1858); - for i in 0..len1858 { - let base = base1858 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1858 = { - let l1855 = *base.add(0).cast::<*mut u8>(); - let l1856 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1857 = l1856; - let bytes1857 = _rt::Vec::from_raw_parts( - l1855.cast(), - len1857, - len1857, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1857), - } - }; - result1858.push(e1858); - } - _rt::cabi_dealloc( - base1858, - len1858 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1858 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1859::UnstructuredBinary(e1859) - } - }; - (_rt::string_lift(bytes1792), v1859) - }; - result1860.push(e1860); - } - _rt::cabi_dealloc( - base1860, - len1860 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1860 - }; - V1934::Tuple(e1934) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1934 = { - let l1861 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1862 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1933 = l1861; - let len1933 = l1862; - let mut result1933 = _rt::Vec::with_capacity(len1933); - for i in 0..len1933 { - let base = base1933 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1933 = { - let l1863 = *base.add(0).cast::<*mut u8>(); - let l1864 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1865 = l1864; - let bytes1865 = _rt::Vec::from_raw_parts( - l1863.cast(), - len1865, - len1865, - ); - let l1866 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1932; - let v1932 = match l1866 { - 0 => { - let e1932 = { - let l1867 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1868 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1917 = l1867; - let len1917 = l1868; - let mut result1917 = _rt::Vec::with_capacity(len1917); - for i in 0..len1917 { - let base = base1917 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1917 = { - let l1869 = i32::from(*base.add(0).cast::()); - let l1873 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1877 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1916; - let v1916 = match l1877 { - 0 => { - let e1916 = { - let l1878 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1879 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1884 = l1878; - let len1884 = l1879; - let mut result1884 = _rt::Vec::with_capacity(len1884); - for i in 0..len1884 { - let base = base1884 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1884 = { - let l1880 = *base.add(0).cast::<*mut u8>(); - let l1881 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1882 = l1881; - let bytes1882 = _rt::Vec::from_raw_parts( - l1880.cast(), - len1882, - len1882, - ); - let l1883 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1882), l1883) - }; - result1884.push(e1884); - } - _rt::cabi_dealloc( - base1884, - len1884 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1884 - }; - V1916::RecordType(e1916) - } - 1 => { - let e1916 = { - let l1885 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1886 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1892 = l1885; - let len1892 = l1886; - let mut result1892 = _rt::Vec::with_capacity(len1892); - for i in 0..len1892 { - let base = base1892 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1892 = { - let l1887 = *base.add(0).cast::<*mut u8>(); - let l1888 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1889 = l1888; - let bytes1889 = _rt::Vec::from_raw_parts( - l1887.cast(), - len1889, - len1889, - ); - let l1890 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1889), - match l1890 { - 0 => None, - 1 => { - let e = { - let l1891 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1891 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1892.push(e1892); - } - _rt::cabi_dealloc( - base1892, - len1892 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1892 - }; - V1916::VariantType(e1916) - } - 2 => { - let e1916 = { - let l1893 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1894 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1898 = l1893; - let len1898 = l1894; - let mut result1898 = _rt::Vec::with_capacity(len1898); - for i in 0..len1898 { - let base = base1898 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1898 = { - let l1895 = *base.add(0).cast::<*mut u8>(); - let l1896 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1897 = l1896; - let bytes1897 = _rt::Vec::from_raw_parts( - l1895.cast(), - len1897, - len1897, - ); - _rt::string_lift(bytes1897) - }; - result1898.push(e1898); - } - _rt::cabi_dealloc( - base1898, - len1898 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1898 - }; - V1916::EnumType(e1916) - } - 3 => { - let e1916 = { - let l1899 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1900 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1904 = l1899; - let len1904 = l1900; - let mut result1904 = _rt::Vec::with_capacity(len1904); - for i in 0..len1904 { - let base = base1904 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1904 = { - let l1901 = *base.add(0).cast::<*mut u8>(); - let l1902 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1903 = l1902; - let bytes1903 = _rt::Vec::from_raw_parts( - l1901.cast(), - len1903, - len1903, - ); - _rt::string_lift(bytes1903) - }; - result1904.push(e1904); - } - _rt::cabi_dealloc( - base1904, - len1904 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1904 - }; - V1916::FlagsType(e1916) - } - 4 => { - let e1916 = { - let l1905 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1906 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1907 = l1906; - _rt::Vec::from_raw_parts(l1905.cast(), len1907, len1907) - }; - V1916::TupleType(e1916) - } - 5 => { - let e1916 = { - let l1908 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1908 - }; - V1916::ListType(e1916) - } - 6 => { - let e1916 = { - let l1909 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1909 - }; - V1916::OptionType(e1916) - } - 7 => { - let e1916 = { - let l1910 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1912 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1910 { - 0 => None, - 1 => { - let e = { - let l1911 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1911 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1912 { - 0 => None, - 1 => { - let e = { - let l1913 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1913 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1916::ResultType(e1916) - } - 8 => V1916::PrimU8Type, - 9 => V1916::PrimU16Type, - 10 => V1916::PrimU32Type, - 11 => V1916::PrimU64Type, - 12 => V1916::PrimS8Type, - 13 => V1916::PrimS16Type, - 14 => V1916::PrimS32Type, - 15 => V1916::PrimS64Type, - 16 => V1916::PrimF32Type, - 17 => V1916::PrimF64Type, - 18 => V1916::PrimCharType, - 19 => V1916::PrimBoolType, - 20 => V1916::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1916 = { - let l1914 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1915 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1914 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1915 as u8, - ), - ) - }; - V1916::HandleType(e1916) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1869 { - 0 => None, - 1 => { - let e = { - let l1870 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1871 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1872 = l1871; - let bytes1872 = _rt::Vec::from_raw_parts( - l1870.cast(), - len1872, - len1872, - ); - _rt::string_lift(bytes1872) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1873 { - 0 => None, - 1 => { - let e = { - let l1874 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1875 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1876 = l1875; - let bytes1876 = _rt::Vec::from_raw_parts( - l1874.cast(), - len1876, - len1876, - ); - _rt::string_lift(bytes1876) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1916, - } - }; - result1917.push(e1917); - } - _rt::cabi_dealloc( - base1917, - len1917 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1917, - } - }; - V1932::ComponentModel(e1932) - } - 1 => { - let e1932 = { - let l1918 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1918 { - 0 => None, - 1 => { - let e = { - let l1919 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1920 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1924 = l1919; - let len1924 = l1920; - let mut result1924 = _rt::Vec::with_capacity(len1924); - for i in 0..len1924 { - let base = base1924 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1924 = { - let l1921 = *base.add(0).cast::<*mut u8>(); - let l1922 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1923 = l1922; - let bytes1923 = _rt::Vec::from_raw_parts( - l1921.cast(), - len1923, - len1923, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1923), - } - }; - result1924.push(e1924); - } - _rt::cabi_dealloc( - base1924, - len1924 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1924 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1932::UnstructuredText(e1932) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1932 = { - let l1925 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1925 { - 0 => None, - 1 => { - let e = { - let l1926 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1927 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1931 = l1926; - let len1931 = l1927; - let mut result1931 = _rt::Vec::with_capacity(len1931); - for i in 0..len1931 { - let base = base1931 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1931 = { - let l1928 = *base.add(0).cast::<*mut u8>(); - let l1929 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1930 = l1929; - let bytes1930 = _rt::Vec::from_raw_parts( - l1928.cast(), - len1930, - len1930, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1930), - } - }; - result1931.push(e1931); - } - _rt::cabi_dealloc( - base1931, - len1931 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1931 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1932::UnstructuredBinary(e1932) - } - }; - (_rt::string_lift(bytes1865), v1932) - }; - result1933.push(e1933); - } - _rt::cabi_dealloc( - base1933, - len1933 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1933 - }; - V1934::Multimodal(e1934) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1786, - schema: v1934, - }, - } - }; - AgentInvocationResult::AgentMethod(e1949) - } - 2 => AgentInvocationResult::ManualUpdate, - 3 => { - let e1949 = { - let l1935 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1935 { - 0 => None, - 1 => { - let e = { - let l1936 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1937 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1938 = l1937; - let bytes1938 = _rt::Vec::from_raw_parts( - l1936.cast(), - len1938, - len1938, - ); - _rt::string_lift(bytes1938) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::LoadSnapshot(e1949) - } - 4 => { - let e1949 = { - let l1939 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1940 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1941 = l1940; - let l1942 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1943 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1944 = l1943; - let bytes1944 = _rt::Vec::from_raw_parts( - l1942.cast(), - len1944, - len1944, - ); - SaveSnapshotResultParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1939.cast(), - len1941, - len1941, - ), - mime_type: _rt::string_lift(bytes1944), - }, - } - }; - AgentInvocationResult::SaveSnapshot(e1949) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1949 = { - let l1945 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1945 { - 0 => None, - 1 => { - let e = { - let l1946 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1947 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1948 = l1947; - let bytes1948 = _rt::Vec::from_raw_parts( - l1946.cast(), - len1948, - len1948, - ); - _rt::string_lift(bytes1948) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::ProcessOplogEntries(e1949) - } - }; - let l1950 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1951 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - AgentInvocationFinishedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1322 as u64, - nanoseconds: l1323 as u32, - }, - invocation_result: v1949, - consumed_fuel: l1950, - component_revision: l1951 as u64, - } - }; - PublicOplogEntry::AgentInvocationFinished(e2893) - } - 4 => { - let e2893 = { - let l1952 = *base.add(8).cast::(); - let l1953 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1952 as u64, - nanoseconds: l1953 as u32, - }, - } - }; - PublicOplogEntry::Suspend(e2893) - } - 5 => { - let e2893 = { - let l1954 = *base.add(8).cast::(); - let l1955 = *base.add(16).cast::(); - let l1956 = *base.add(24).cast::<*mut u8>(); - let l1957 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1958 = l1957; - let bytes1958 = _rt::Vec::from_raw_parts( - l1956.cast(), - len1958, - len1958, - ); - let l1959 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ErrorParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1954 as u64, - nanoseconds: l1955 as u32, - }, - error: _rt::string_lift(bytes1958), - retry_from: l1959 as u64, - } - }; - PublicOplogEntry::Error(e2893) - } - 6 => { - let e2893 = { - let l1960 = *base.add(8).cast::(); - let l1961 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1960 as u64, - nanoseconds: l1961 as u32, - }, - } - }; - PublicOplogEntry::NoOp(e2893) - } - 7 => { - let e2893 = { - let l1962 = *base.add(8).cast::(); - let l1963 = *base.add(16).cast::(); - let l1964 = *base.add(24).cast::(); - let l1965 = *base.add(32).cast::(); - JumpParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1962 as u64, - nanoseconds: l1963 as u32, - }, - jump: OplogRegion { - start: l1964 as u64, - end: l1965 as u64, - }, - } - }; - PublicOplogEntry::Jump(e2893) - } - 8 => { - let e2893 = { - let l1966 = *base.add(8).cast::(); - let l1967 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1966 as u64, - nanoseconds: l1967 as u32, - }, - } - }; - PublicOplogEntry::Interrupted(e2893) - } - 9 => { - let e2893 = { - let l1968 = *base.add(8).cast::(); - let l1969 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1968 as u64, - nanoseconds: l1969 as u32, - }, - } - }; - PublicOplogEntry::Exited(e2893) - } - 10 => { - let e2893 = { - let l1970 = *base.add(8).cast::(); - let l1971 = *base.add(16).cast::(); - let l1972 = *base.add(24).cast::(); - let l1973 = *base.add(32).cast::(); - let l1974 = *base.add(40).cast::(); - let l1975 = *base.add(48).cast::(); - let l1976 = i32::from(*base.add(56).cast::()); - ChangeRetryPolicyParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1970 as u64, - nanoseconds: l1971 as u32, - }, - new_policy: super::super::super::golem::api::host::RetryPolicy { - max_attempts: l1972 as u32, - min_delay: l1973 as u64, - max_delay: l1974 as u64, - multiplier: l1975, - max_jitter_factor: match l1976 { - 0 => None, - 1 => { - let e = { - let l1977 = *base.add(64).cast::(); - l1977 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - }, - } - }; - PublicOplogEntry::ChangeRetryPolicy(e2893) - } - 11 => { - let e2893 = { - let l1978 = *base.add(8).cast::(); - let l1979 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1978 as u64, - nanoseconds: l1979 as u32, - }, - } - }; - PublicOplogEntry::BeginAtomicRegion(e2893) - } - 12 => { - let e2893 = { - let l1980 = *base.add(8).cast::(); - let l1981 = *base.add(16).cast::(); - let l1982 = *base.add(24).cast::(); - EndAtomicRegionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1980 as u64, - nanoseconds: l1981 as u32, - }, - begin_index: l1982 as u64, - } - }; - PublicOplogEntry::EndAtomicRegion(e2893) - } - 13 => { - let e2893 = { - let l1983 = *base.add(8).cast::(); - let l1984 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1983 as u64, - nanoseconds: l1984 as u32, - }, - } - }; - PublicOplogEntry::BeginRemoteWrite(e2893) - } - 14 => { - let e2893 = { - let l1985 = *base.add(8).cast::(); - let l1986 = *base.add(16).cast::(); - let l1987 = *base.add(24).cast::(); - EndRemoteWriteParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1985 as u64, - nanoseconds: l1986 as u32, - }, - begin_index: l1987 as u64, - } - }; - PublicOplogEntry::EndRemoteWrite(e2893) - } - 15 => { - let e2893 = { - let l1988 = *base.add(8).cast::(); - let l1989 = *base.add(16).cast::(); - let l1990 = i32::from(*base.add(24).cast::()); - let v2706 = match l1990 { - 0 => { - let e2706 = { - let l1991 = *base.add(32).cast::<*mut u8>(); - let l1992 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1993 = l1992; - let bytes1993 = _rt::Vec::from_raw_parts( - l1991.cast(), - len1993, - len1993, - ); - let l1994 = i32::from( - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V2150; - let v2150 = match l1994 { - 0 => { - let e2150 = { - let l1995 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1996 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2070 = l1995; - let len2070 = l1996; - let mut result2070 = _rt::Vec::with_capacity(len2070); - for i in 0..len2070 { - let base = base2070 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e2070 = { - let l1997 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V2069; - let v2069 = match l1997 { - 0 => { - let e2069 = { - let l1998 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1999 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2045 = l1998; - let len2045 = l1999; - let mut result2045 = _rt::Vec::with_capacity(len2045); - for i in 0..len2045 { - let base = base2045 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2045 = { - let l2000 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2044; - let v2044 = match l2000 { - 0 => { - let e2044 = { - let l2001 = *base.add(8).cast::<*mut u8>(); - let l2002 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2003 = l2002; - _rt::Vec::from_raw_parts(l2001.cast(), len2003, len2003) - }; - V2044::RecordValue(e2044) - } - 1 => { - let e2044 = { - let l2004 = *base.add(8).cast::(); - let l2005 = i32::from(*base.add(12).cast::()); - ( - l2004 as u32, - match l2005 { - 0 => None, - 1 => { - let e = { - let l2006 = *base.add(16).cast::(); - l2006 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2044::VariantValue(e2044) - } - 2 => { - let e2044 = { - let l2007 = *base.add(8).cast::(); - l2007 as u32 - }; - V2044::EnumValue(e2044) - } - 3 => { - let e2044 = { - let l2008 = *base.add(8).cast::<*mut u8>(); - let l2009 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2011 = l2008; - let len2011 = l2009; - let mut result2011 = _rt::Vec::with_capacity(len2011); - for i in 0..len2011 { - let base = base2011.add(i * 1); - let e2011 = { - let l2010 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2010 as u8) - }; - result2011.push(e2011); - } - _rt::cabi_dealloc(base2011, len2011 * 1, 1); - result2011 - }; - V2044::FlagsValue(e2044) - } - 4 => { - let e2044 = { - let l2012 = *base.add(8).cast::<*mut u8>(); - let l2013 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2014 = l2013; - _rt::Vec::from_raw_parts(l2012.cast(), len2014, len2014) - }; - V2044::TupleValue(e2044) - } - 5 => { - let e2044 = { - let l2015 = *base.add(8).cast::<*mut u8>(); - let l2016 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2017 = l2016; - _rt::Vec::from_raw_parts(l2015.cast(), len2017, len2017) - }; - V2044::ListValue(e2044) - } - 6 => { - let e2044 = { - let l2018 = i32::from(*base.add(8).cast::()); - match l2018 { - 0 => None, - 1 => { - let e = { - let l2019 = *base.add(12).cast::(); - l2019 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2044::OptionValue(e2044) - } - 7 => { - let e2044 = { - let l2020 = i32::from(*base.add(8).cast::()); - match l2020 { - 0 => { - let e = { - let l2021 = i32::from(*base.add(12).cast::()); - match l2021 { - 0 => None, - 1 => { - let e = { - let l2022 = *base.add(16).cast::(); - l2022 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2023 = i32::from(*base.add(12).cast::()); - match l2023 { - 0 => None, - 1 => { - let e = { - let l2024 = *base.add(16).cast::(); - l2024 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2044::ResultValue(e2044) - } - 8 => { - let e2044 = { - let l2025 = i32::from(*base.add(8).cast::()); - l2025 as u8 - }; - V2044::PrimU8(e2044) - } - 9 => { - let e2044 = { - let l2026 = i32::from(*base.add(8).cast::()); - l2026 as u16 - }; - V2044::PrimU16(e2044) - } - 10 => { - let e2044 = { - let l2027 = *base.add(8).cast::(); - l2027 as u32 - }; - V2044::PrimU32(e2044) - } - 11 => { - let e2044 = { - let l2028 = *base.add(8).cast::(); - l2028 as u64 - }; - V2044::PrimU64(e2044) - } - 12 => { - let e2044 = { - let l2029 = i32::from(*base.add(8).cast::()); - l2029 as i8 - }; - V2044::PrimS8(e2044) - } - 13 => { - let e2044 = { - let l2030 = i32::from(*base.add(8).cast::()); - l2030 as i16 - }; - V2044::PrimS16(e2044) - } - 14 => { - let e2044 = { - let l2031 = *base.add(8).cast::(); - l2031 - }; - V2044::PrimS32(e2044) - } - 15 => { - let e2044 = { - let l2032 = *base.add(8).cast::(); - l2032 - }; - V2044::PrimS64(e2044) - } - 16 => { - let e2044 = { - let l2033 = *base.add(8).cast::(); - l2033 - }; - V2044::PrimFloat32(e2044) - } - 17 => { - let e2044 = { - let l2034 = *base.add(8).cast::(); - l2034 - }; - V2044::PrimFloat64(e2044) - } - 18 => { - let e2044 = { - let l2035 = *base.add(8).cast::(); - _rt::char_lift(l2035 as u32) - }; - V2044::PrimChar(e2044) - } - 19 => { - let e2044 = { - let l2036 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2036 as u8) - }; - V2044::PrimBool(e2044) - } - 20 => { - let e2044 = { - let l2037 = *base.add(8).cast::<*mut u8>(); - let l2038 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2039 = l2038; - let bytes2039 = _rt::Vec::from_raw_parts( - l2037.cast(), - len2039, - len2039, - ); - _rt::string_lift(bytes2039) - }; - V2044::PrimString(e2044) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2044 = { - let l2040 = *base.add(8).cast::<*mut u8>(); - let l2041 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2042 = l2041; - let bytes2042 = _rt::Vec::from_raw_parts( - l2040.cast(), - len2042, - len2042, - ); - let l2043 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2042), - }, - l2043 as u64, - ) - }; - V2044::Handle(e2044) - } - }; - v2044 - }; - result2045.push(e2045); - } - _rt::cabi_dealloc( - base2045, - len2045 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2045, - } - }; - V2069::ComponentModel(e2069) - } - 1 => { - let e2069 = { - let l2046 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2057; - let v2057 = match l2046 { - 0 => { - let e2057 = { - let l2047 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2048 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2049 = l2048; - let bytes2049 = _rt::Vec::from_raw_parts( - l2047.cast(), - len2049, - len2049, - ); - _rt::string_lift(bytes2049) - }; - V2057::Url(e2057) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2057 = { - let l2050 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2051 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2052 = l2051; - let bytes2052 = _rt::Vec::from_raw_parts( - l2050.cast(), - len2052, - len2052, - ); - let l2053 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2052), - text_type: match l2053 { - 0 => None, - 1 => { - let e = { - let l2054 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2055 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2056 = l2055; - let bytes2056 = _rt::Vec::from_raw_parts( - l2054.cast(), - len2056, - len2056, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2056), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2057::Inline(e2057) - } - }; - v2057 - }; - V2069::UnstructuredText(e2069) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2069 = { - let l2058 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2068; - let v2068 = match l2058 { - 0 => { - let e2068 = { - let l2059 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2060 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2061 = l2060; - let bytes2061 = _rt::Vec::from_raw_parts( - l2059.cast(), - len2061, - len2061, - ); - _rt::string_lift(bytes2061) - }; - V2068::Url(e2068) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2068 = { - let l2062 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2063 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2064 = l2063; - let l2065 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2066 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2067 = l2066; - let bytes2067 = _rt::Vec::from_raw_parts( - l2065.cast(), - len2067, - len2067, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2062.cast(), - len2064, - len2064, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2067), - }, - } - }; - V2068::Inline(e2068) - } - }; - v2068 - }; - V2069::UnstructuredBinary(e2069) - } - }; - v2069 - }; - result2070.push(e2070); - } - _rt::cabi_dealloc( - base2070, - len2070 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2070 - }; - V2150::Tuple(e2150) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2150 = { - let l2071 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2072 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2149 = l2071; - let len2149 = l2072; - let mut result2149 = _rt::Vec::with_capacity(len2149); - for i in 0..len2149 { - let base = base2149 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e2149 = { - let l2073 = *base.add(0).cast::<*mut u8>(); - let l2074 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2075 = l2074; - let bytes2075 = _rt::Vec::from_raw_parts( - l2073.cast(), - len2075, - len2075, - ); - let l2076 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V2148; - let v2148 = match l2076 { - 0 => { - let e2148 = { - let l2077 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2078 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2124 = l2077; - let len2124 = l2078; - let mut result2124 = _rt::Vec::with_capacity(len2124); - for i in 0..len2124 { - let base = base2124 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2124 = { - let l2079 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2123; - let v2123 = match l2079 { - 0 => { - let e2123 = { - let l2080 = *base.add(8).cast::<*mut u8>(); - let l2081 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2082 = l2081; - _rt::Vec::from_raw_parts(l2080.cast(), len2082, len2082) - }; - V2123::RecordValue(e2123) - } - 1 => { - let e2123 = { - let l2083 = *base.add(8).cast::(); - let l2084 = i32::from(*base.add(12).cast::()); - ( - l2083 as u32, - match l2084 { - 0 => None, - 1 => { - let e = { - let l2085 = *base.add(16).cast::(); - l2085 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2123::VariantValue(e2123) - } - 2 => { - let e2123 = { - let l2086 = *base.add(8).cast::(); - l2086 as u32 - }; - V2123::EnumValue(e2123) - } - 3 => { - let e2123 = { - let l2087 = *base.add(8).cast::<*mut u8>(); - let l2088 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2090 = l2087; - let len2090 = l2088; - let mut result2090 = _rt::Vec::with_capacity(len2090); - for i in 0..len2090 { - let base = base2090.add(i * 1); - let e2090 = { - let l2089 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2089 as u8) - }; - result2090.push(e2090); - } - _rt::cabi_dealloc(base2090, len2090 * 1, 1); - result2090 - }; - V2123::FlagsValue(e2123) - } - 4 => { - let e2123 = { - let l2091 = *base.add(8).cast::<*mut u8>(); - let l2092 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2093 = l2092; - _rt::Vec::from_raw_parts(l2091.cast(), len2093, len2093) - }; - V2123::TupleValue(e2123) - } - 5 => { - let e2123 = { - let l2094 = *base.add(8).cast::<*mut u8>(); - let l2095 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2096 = l2095; - _rt::Vec::from_raw_parts(l2094.cast(), len2096, len2096) - }; - V2123::ListValue(e2123) - } - 6 => { - let e2123 = { - let l2097 = i32::from(*base.add(8).cast::()); - match l2097 { - 0 => None, - 1 => { - let e = { - let l2098 = *base.add(12).cast::(); - l2098 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2123::OptionValue(e2123) - } - 7 => { - let e2123 = { - let l2099 = i32::from(*base.add(8).cast::()); - match l2099 { - 0 => { - let e = { - let l2100 = i32::from(*base.add(12).cast::()); - match l2100 { - 0 => None, - 1 => { - let e = { - let l2101 = *base.add(16).cast::(); - l2101 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2102 = i32::from(*base.add(12).cast::()); - match l2102 { - 0 => None, - 1 => { - let e = { - let l2103 = *base.add(16).cast::(); - l2103 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2123::ResultValue(e2123) - } - 8 => { - let e2123 = { - let l2104 = i32::from(*base.add(8).cast::()); - l2104 as u8 - }; - V2123::PrimU8(e2123) - } - 9 => { - let e2123 = { - let l2105 = i32::from(*base.add(8).cast::()); - l2105 as u16 - }; - V2123::PrimU16(e2123) - } - 10 => { - let e2123 = { - let l2106 = *base.add(8).cast::(); - l2106 as u32 - }; - V2123::PrimU32(e2123) - } - 11 => { - let e2123 = { - let l2107 = *base.add(8).cast::(); - l2107 as u64 - }; - V2123::PrimU64(e2123) - } - 12 => { - let e2123 = { - let l2108 = i32::from(*base.add(8).cast::()); - l2108 as i8 - }; - V2123::PrimS8(e2123) - } - 13 => { - let e2123 = { - let l2109 = i32::from(*base.add(8).cast::()); - l2109 as i16 - }; - V2123::PrimS16(e2123) - } - 14 => { - let e2123 = { - let l2110 = *base.add(8).cast::(); - l2110 - }; - V2123::PrimS32(e2123) - } - 15 => { - let e2123 = { - let l2111 = *base.add(8).cast::(); - l2111 - }; - V2123::PrimS64(e2123) - } - 16 => { - let e2123 = { - let l2112 = *base.add(8).cast::(); - l2112 - }; - V2123::PrimFloat32(e2123) - } - 17 => { - let e2123 = { - let l2113 = *base.add(8).cast::(); - l2113 - }; - V2123::PrimFloat64(e2123) - } - 18 => { - let e2123 = { - let l2114 = *base.add(8).cast::(); - _rt::char_lift(l2114 as u32) - }; - V2123::PrimChar(e2123) - } - 19 => { - let e2123 = { - let l2115 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2115 as u8) - }; - V2123::PrimBool(e2123) - } - 20 => { - let e2123 = { - let l2116 = *base.add(8).cast::<*mut u8>(); - let l2117 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2118 = l2117; - let bytes2118 = _rt::Vec::from_raw_parts( - l2116.cast(), - len2118, - len2118, - ); - _rt::string_lift(bytes2118) - }; - V2123::PrimString(e2123) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2123 = { - let l2119 = *base.add(8).cast::<*mut u8>(); - let l2120 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2121 = l2120; - let bytes2121 = _rt::Vec::from_raw_parts( - l2119.cast(), - len2121, - len2121, - ); - let l2122 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2121), - }, - l2122 as u64, - ) - }; - V2123::Handle(e2123) - } - }; - v2123 - }; - result2124.push(e2124); - } - _rt::cabi_dealloc( - base2124, - len2124 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2124, - } - }; - V2148::ComponentModel(e2148) - } - 1 => { - let e2148 = { - let l2125 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2136; - let v2136 = match l2125 { - 0 => { - let e2136 = { - let l2126 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2127 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2128 = l2127; - let bytes2128 = _rt::Vec::from_raw_parts( - l2126.cast(), - len2128, - len2128, - ); - _rt::string_lift(bytes2128) - }; - V2136::Url(e2136) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2136 = { - let l2129 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2130 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2131 = l2130; - let bytes2131 = _rt::Vec::from_raw_parts( - l2129.cast(), - len2131, - len2131, - ); - let l2132 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2131), - text_type: match l2132 { - 0 => None, - 1 => { - let e = { - let l2133 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2134 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2135 = l2134; - let bytes2135 = _rt::Vec::from_raw_parts( - l2133.cast(), - len2135, - len2135, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2135), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2136::Inline(e2136) - } - }; - v2136 - }; - V2148::UnstructuredText(e2148) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2148 = { - let l2137 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2147; - let v2147 = match l2137 { - 0 => { - let e2147 = { - let l2138 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2139 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2140 = l2139; - let bytes2140 = _rt::Vec::from_raw_parts( - l2138.cast(), - len2140, - len2140, - ); - _rt::string_lift(bytes2140) - }; - V2147::Url(e2147) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2147 = { - let l2141 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2142 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2143 = l2142; - let l2144 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2145 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2146 = l2145; - let bytes2146 = _rt::Vec::from_raw_parts( - l2144.cast(), - len2146, - len2146, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2141.cast(), - len2143, - len2143, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2146), - }, - } - }; - V2147::Inline(e2147) - } - }; - v2147 - }; - V2148::UnstructuredBinary(e2148) - } - }; - (_rt::string_lift(bytes2075), v2148) - }; - result2149.push(e2149); - } - _rt::cabi_dealloc( - base2149, - len2149 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2149 - }; - V2150::Multimodal(e2150) - } - }; - let l2151 = i32::from( - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2298; - let v2298 = match l2151 { - 0 => { - let e2298 = { - let l2152 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2153 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2224 = l2152; - let len2224 = l2153; - let mut result2224 = _rt::Vec::with_capacity(len2224); - for i in 0..len2224 { - let base = base2224 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2224 = { - let l2154 = *base.add(0).cast::<*mut u8>(); - let l2155 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2156 = l2155; - let bytes2156 = _rt::Vec::from_raw_parts( - l2154.cast(), - len2156, - len2156, - ); - let l2157 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2223; - let v2223 = match l2157 { - 0 => { - let e2223 = { - let l2158 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2159 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2208 = l2158; - let len2208 = l2159; - let mut result2208 = _rt::Vec::with_capacity(len2208); - for i in 0..len2208 { - let base = base2208 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2208 = { - let l2160 = i32::from(*base.add(0).cast::()); - let l2164 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2168 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2207; - let v2207 = match l2168 { - 0 => { - let e2207 = { - let l2169 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2170 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2175 = l2169; - let len2175 = l2170; - let mut result2175 = _rt::Vec::with_capacity(len2175); - for i in 0..len2175 { - let base = base2175 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2175 = { - let l2171 = *base.add(0).cast::<*mut u8>(); - let l2172 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2173 = l2172; - let bytes2173 = _rt::Vec::from_raw_parts( - l2171.cast(), - len2173, - len2173, - ); - let l2174 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2173), l2174) - }; - result2175.push(e2175); - } - _rt::cabi_dealloc( - base2175, - len2175 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2175 - }; - V2207::RecordType(e2207) - } - 1 => { - let e2207 = { - let l2176 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2177 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2183 = l2176; - let len2183 = l2177; - let mut result2183 = _rt::Vec::with_capacity(len2183); - for i in 0..len2183 { - let base = base2183 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2183 = { - let l2178 = *base.add(0).cast::<*mut u8>(); - let l2179 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2180 = l2179; - let bytes2180 = _rt::Vec::from_raw_parts( - l2178.cast(), - len2180, - len2180, - ); - let l2181 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2180), - match l2181 { - 0 => None, - 1 => { - let e = { - let l2182 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2182 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2183.push(e2183); - } - _rt::cabi_dealloc( - base2183, - len2183 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2183 - }; - V2207::VariantType(e2207) - } - 2 => { - let e2207 = { - let l2184 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2185 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2189 = l2184; - let len2189 = l2185; - let mut result2189 = _rt::Vec::with_capacity(len2189); - for i in 0..len2189 { - let base = base2189 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2189 = { - let l2186 = *base.add(0).cast::<*mut u8>(); - let l2187 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2188 = l2187; - let bytes2188 = _rt::Vec::from_raw_parts( - l2186.cast(), - len2188, - len2188, - ); - _rt::string_lift(bytes2188) - }; - result2189.push(e2189); - } - _rt::cabi_dealloc( - base2189, - len2189 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2189 - }; - V2207::EnumType(e2207) - } - 3 => { - let e2207 = { - let l2190 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2191 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2195 = l2190; - let len2195 = l2191; - let mut result2195 = _rt::Vec::with_capacity(len2195); - for i in 0..len2195 { - let base = base2195 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2195 = { - let l2192 = *base.add(0).cast::<*mut u8>(); - let l2193 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2194 = l2193; - let bytes2194 = _rt::Vec::from_raw_parts( - l2192.cast(), - len2194, - len2194, - ); - _rt::string_lift(bytes2194) - }; - result2195.push(e2195); - } - _rt::cabi_dealloc( - base2195, - len2195 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2195 - }; - V2207::FlagsType(e2207) - } - 4 => { - let e2207 = { - let l2196 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2197 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2198 = l2197; - _rt::Vec::from_raw_parts(l2196.cast(), len2198, len2198) - }; - V2207::TupleType(e2207) - } - 5 => { - let e2207 = { - let l2199 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2199 - }; - V2207::ListType(e2207) - } - 6 => { - let e2207 = { - let l2200 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2200 - }; - V2207::OptionType(e2207) - } - 7 => { - let e2207 = { - let l2201 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2203 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2201 { - 0 => None, - 1 => { - let e = { - let l2202 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2202 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2203 { - 0 => None, - 1 => { - let e = { - let l2204 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2204 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2207::ResultType(e2207) - } - 8 => V2207::PrimU8Type, - 9 => V2207::PrimU16Type, - 10 => V2207::PrimU32Type, - 11 => V2207::PrimU64Type, - 12 => V2207::PrimS8Type, - 13 => V2207::PrimS16Type, - 14 => V2207::PrimS32Type, - 15 => V2207::PrimS64Type, - 16 => V2207::PrimF32Type, - 17 => V2207::PrimF64Type, - 18 => V2207::PrimCharType, - 19 => V2207::PrimBoolType, - 20 => V2207::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2207 = { - let l2205 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2206 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2205 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2206 as u8, - ), - ) - }; - V2207::HandleType(e2207) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2160 { - 0 => None, - 1 => { - let e = { - let l2161 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2162 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2163 = l2162; - let bytes2163 = _rt::Vec::from_raw_parts( - l2161.cast(), - len2163, - len2163, - ); - _rt::string_lift(bytes2163) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2164 { - 0 => None, - 1 => { - let e = { - let l2165 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2166 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2167 = l2166; - let bytes2167 = _rt::Vec::from_raw_parts( - l2165.cast(), - len2167, - len2167, - ); - _rt::string_lift(bytes2167) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2207, - } - }; - result2208.push(e2208); - } - _rt::cabi_dealloc( - base2208, - len2208 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2208, - } - }; - V2223::ComponentModel(e2223) - } - 1 => { - let e2223 = { - let l2209 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2209 { - 0 => None, - 1 => { - let e = { - let l2210 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2211 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2215 = l2210; - let len2215 = l2211; - let mut result2215 = _rt::Vec::with_capacity(len2215); - for i in 0..len2215 { - let base = base2215 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2215 = { - let l2212 = *base.add(0).cast::<*mut u8>(); - let l2213 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2214 = l2213; - let bytes2214 = _rt::Vec::from_raw_parts( - l2212.cast(), - len2214, - len2214, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2214), - } - }; - result2215.push(e2215); - } - _rt::cabi_dealloc( - base2215, - len2215 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2215 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2223::UnstructuredText(e2223) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2223 = { - let l2216 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2216 { - 0 => None, - 1 => { - let e = { - let l2217 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2218 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2222 = l2217; - let len2222 = l2218; - let mut result2222 = _rt::Vec::with_capacity(len2222); - for i in 0..len2222 { - let base = base2222 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2222 = { - let l2219 = *base.add(0).cast::<*mut u8>(); - let l2220 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2221 = l2220; - let bytes2221 = _rt::Vec::from_raw_parts( - l2219.cast(), - len2221, - len2221, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2221), - } - }; - result2222.push(e2222); - } - _rt::cabi_dealloc( - base2222, - len2222 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2222 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2223::UnstructuredBinary(e2223) - } - }; - (_rt::string_lift(bytes2156), v2223) - }; - result2224.push(e2224); - } - _rt::cabi_dealloc( - base2224, - len2224 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2224 - }; - V2298::Tuple(e2298) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2298 = { - let l2225 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2226 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2297 = l2225; - let len2297 = l2226; - let mut result2297 = _rt::Vec::with_capacity(len2297); - for i in 0..len2297 { - let base = base2297 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2297 = { - let l2227 = *base.add(0).cast::<*mut u8>(); - let l2228 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2229 = l2228; - let bytes2229 = _rt::Vec::from_raw_parts( - l2227.cast(), - len2229, - len2229, - ); - let l2230 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2296; - let v2296 = match l2230 { - 0 => { - let e2296 = { - let l2231 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2232 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2281 = l2231; - let len2281 = l2232; - let mut result2281 = _rt::Vec::with_capacity(len2281); - for i in 0..len2281 { - let base = base2281 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2281 = { - let l2233 = i32::from(*base.add(0).cast::()); - let l2237 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2241 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2280; - let v2280 = match l2241 { - 0 => { - let e2280 = { - let l2242 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2243 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2248 = l2242; - let len2248 = l2243; - let mut result2248 = _rt::Vec::with_capacity(len2248); - for i in 0..len2248 { - let base = base2248 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2248 = { - let l2244 = *base.add(0).cast::<*mut u8>(); - let l2245 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2246 = l2245; - let bytes2246 = _rt::Vec::from_raw_parts( - l2244.cast(), - len2246, - len2246, - ); - let l2247 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2246), l2247) - }; - result2248.push(e2248); - } - _rt::cabi_dealloc( - base2248, - len2248 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2248 - }; - V2280::RecordType(e2280) - } - 1 => { - let e2280 = { - let l2249 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2250 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2256 = l2249; - let len2256 = l2250; - let mut result2256 = _rt::Vec::with_capacity(len2256); - for i in 0..len2256 { - let base = base2256 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2256 = { - let l2251 = *base.add(0).cast::<*mut u8>(); - let l2252 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2253 = l2252; - let bytes2253 = _rt::Vec::from_raw_parts( - l2251.cast(), - len2253, - len2253, - ); - let l2254 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2253), - match l2254 { - 0 => None, - 1 => { - let e = { - let l2255 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2255 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2256.push(e2256); - } - _rt::cabi_dealloc( - base2256, - len2256 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2256 - }; - V2280::VariantType(e2280) - } - 2 => { - let e2280 = { - let l2257 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2258 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2262 = l2257; - let len2262 = l2258; - let mut result2262 = _rt::Vec::with_capacity(len2262); - for i in 0..len2262 { - let base = base2262 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2262 = { - let l2259 = *base.add(0).cast::<*mut u8>(); - let l2260 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2261 = l2260; - let bytes2261 = _rt::Vec::from_raw_parts( - l2259.cast(), - len2261, - len2261, - ); - _rt::string_lift(bytes2261) - }; - result2262.push(e2262); - } - _rt::cabi_dealloc( - base2262, - len2262 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2262 - }; - V2280::EnumType(e2280) - } - 3 => { - let e2280 = { - let l2263 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2264 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2268 = l2263; - let len2268 = l2264; - let mut result2268 = _rt::Vec::with_capacity(len2268); - for i in 0..len2268 { - let base = base2268 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2268 = { - let l2265 = *base.add(0).cast::<*mut u8>(); - let l2266 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2267 = l2266; - let bytes2267 = _rt::Vec::from_raw_parts( - l2265.cast(), - len2267, - len2267, - ); - _rt::string_lift(bytes2267) - }; - result2268.push(e2268); - } - _rt::cabi_dealloc( - base2268, - len2268 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2268 - }; - V2280::FlagsType(e2280) - } - 4 => { - let e2280 = { - let l2269 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2270 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2271 = l2270; - _rt::Vec::from_raw_parts(l2269.cast(), len2271, len2271) - }; - V2280::TupleType(e2280) - } - 5 => { - let e2280 = { - let l2272 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2272 - }; - V2280::ListType(e2280) - } - 6 => { - let e2280 = { - let l2273 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2273 - }; - V2280::OptionType(e2280) - } - 7 => { - let e2280 = { - let l2274 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2276 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2274 { - 0 => None, - 1 => { - let e = { - let l2275 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2275 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2276 { - 0 => None, - 1 => { - let e = { - let l2277 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2277 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2280::ResultType(e2280) - } - 8 => V2280::PrimU8Type, - 9 => V2280::PrimU16Type, - 10 => V2280::PrimU32Type, - 11 => V2280::PrimU64Type, - 12 => V2280::PrimS8Type, - 13 => V2280::PrimS16Type, - 14 => V2280::PrimS32Type, - 15 => V2280::PrimS64Type, - 16 => V2280::PrimF32Type, - 17 => V2280::PrimF64Type, - 18 => V2280::PrimCharType, - 19 => V2280::PrimBoolType, - 20 => V2280::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2280 = { - let l2278 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2279 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2278 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2279 as u8, - ), - ) - }; - V2280::HandleType(e2280) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2233 { - 0 => None, - 1 => { - let e = { - let l2234 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2235 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2236 = l2235; - let bytes2236 = _rt::Vec::from_raw_parts( - l2234.cast(), - len2236, - len2236, - ); - _rt::string_lift(bytes2236) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2237 { - 0 => None, - 1 => { - let e = { - let l2238 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2239 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2240 = l2239; - let bytes2240 = _rt::Vec::from_raw_parts( - l2238.cast(), - len2240, - len2240, - ); - _rt::string_lift(bytes2240) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2280, - } - }; - result2281.push(e2281); - } - _rt::cabi_dealloc( - base2281, - len2281 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2281, - } - }; - V2296::ComponentModel(e2296) - } - 1 => { - let e2296 = { - let l2282 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2282 { - 0 => None, - 1 => { - let e = { - let l2283 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2284 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2288 = l2283; - let len2288 = l2284; - let mut result2288 = _rt::Vec::with_capacity(len2288); - for i in 0..len2288 { - let base = base2288 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2288 = { - let l2285 = *base.add(0).cast::<*mut u8>(); - let l2286 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2287 = l2286; - let bytes2287 = _rt::Vec::from_raw_parts( - l2285.cast(), - len2287, - len2287, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2287), - } - }; - result2288.push(e2288); - } - _rt::cabi_dealloc( - base2288, - len2288 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2288 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2296::UnstructuredText(e2296) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2296 = { - let l2289 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2289 { - 0 => None, - 1 => { - let e = { - let l2290 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2291 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2295 = l2290; - let len2295 = l2291; - let mut result2295 = _rt::Vec::with_capacity(len2295); - for i in 0..len2295 { - let base = base2295 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2295 = { - let l2292 = *base.add(0).cast::<*mut u8>(); - let l2293 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2294 = l2293; - let bytes2294 = _rt::Vec::from_raw_parts( - l2292.cast(), - len2294, - len2294, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2294), - } - }; - result2295.push(e2295); - } - _rt::cabi_dealloc( - base2295, - len2295 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2295 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2296::UnstructuredBinary(e2296) - } - }; - (_rt::string_lift(bytes2229), v2296) - }; - result2297.push(e2297); - } - _rt::cabi_dealloc( - base2297, - len2297 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2297 - }; - V2298::Multimodal(e2298) - } - }; - let l2299 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2300 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2301 = l2300; - let bytes2301 = _rt::Vec::from_raw_parts( - l2299.cast(), - len2301, - len2301, - ); - let l2302 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2303 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2307 = l2302; - let len2307 = l2303; - let mut result2307 = _rt::Vec::with_capacity(len2307); - for i in 0..len2307 { - let base = base2307 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2307 = { - let l2304 = *base.add(0).cast::<*mut u8>(); - let l2305 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2306 = l2305; - let bytes2306 = _rt::Vec::from_raw_parts( - l2304.cast(), - len2306, - len2306, - ); - _rt::string_lift(bytes2306) - }; - result2307.push(e2307); - } - _rt::cabi_dealloc( - base2307, - len2307 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2308 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2309 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2341 = l2308; - let len2341 = l2309; - let mut result2341 = _rt::Vec::with_capacity(len2341); - for i in 0..len2341 { - let base = base2341 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2341 = { - let l2310 = *base.add(0).cast::<*mut u8>(); - let l2311 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2340 = l2310; - let len2340 = l2311; - let mut result2340 = _rt::Vec::with_capacity(len2340); - for i in 0..len2340 { - let base = base2340 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2340 = { - let l2312 = i32::from(*base.add(0).cast::()); - let v2339 = match l2312 { - 0 => { - let e2339 = { - let l2313 = *base.add(8).cast::<*mut u8>(); - let l2314 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2315 = l2314; - let bytes2315 = _rt::Vec::from_raw_parts( - l2313.cast(), - len2315, - len2315, - ); - let l2316 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2317 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2318 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2322 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2324 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2325 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2334 = l2324; - let len2334 = l2325; - let mut result2334 = _rt::Vec::with_capacity(len2334); - for i in 0..len2334 { - let base = base2334 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2334 = { - let l2326 = *base.add(0).cast::<*mut u8>(); - let l2327 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2328 = l2327; - let bytes2328 = _rt::Vec::from_raw_parts( - l2326.cast(), - len2328, - len2328, - ); - let l2329 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2333; - let v2333 = match l2329 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2333 = { - let l2330 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2331 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2332 = l2331; - let bytes2332 = _rt::Vec::from_raw_parts( - l2330.cast(), - len2332, - len2332, - ); - _rt::string_lift(bytes2332) - }; - V2333::String(e2333) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2328), - value: v2333, - } - }; - result2334.push(e2334); - } - _rt::cabi_dealloc( - base2334, - len2334 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2335 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2315), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2316 as u64, - nanoseconds: l2317 as u32, - }, - parent: match l2318 { - 0 => None, - 1 => { - let e = { - let l2319 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2320 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2321 = l2320; - let bytes2321 = _rt::Vec::from_raw_parts( - l2319.cast(), - len2321, - len2321, - ); - _rt::string_lift(bytes2321) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2322 { - 0 => None, - 1 => { - let e = { - let l2323 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2323 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2334, - inherited: _rt::bool_lift(l2335 as u8), - } - }; - SpanData::LocalSpan(e2339) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2339 = { - let l2336 = *base.add(8).cast::<*mut u8>(); - let l2337 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2338 = l2337; - let bytes2338 = _rt::Vec::from_raw_parts( - l2336.cast(), - len2338, - len2338, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2338), - } - }; - SpanData::ExternalSpan(e2339) - } - }; - v2339 - }; - result2340.push(e2340); - } - _rt::cabi_dealloc( - base2340, - len2340 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2340 - }; - result2341.push(e2341); - } - _rt::cabi_dealloc( - base2341, - len2341 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes1993), - constructor_parameters: TypedDataValue { - value: v2150, - schema: v2298, - }, - trace_id: _rt::string_lift(bytes2301), - trace_states: result2307, - invocation_context: result2341, - } - }; - AgentInvocation::AgentInitialization(e2706) - } - 1 => { - let e2706 = { - let l2342 = *base.add(32).cast::<*mut u8>(); - let l2343 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2344 = l2343; - let bytes2344 = _rt::Vec::from_raw_parts( - l2342.cast(), - len2344, - len2344, - ); - let l2345 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2346 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2347 = l2346; - let bytes2347 = _rt::Vec::from_raw_parts( - l2345.cast(), - len2347, - len2347, - ); - let l2348 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V2504; - let v2504 = match l2348 { - 0 => { - let e2504 = { - let l2349 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2350 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2424 = l2349; - let len2424 = l2350; - let mut result2424 = _rt::Vec::with_capacity(len2424); - for i in 0..len2424 { - let base = base2424 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e2424 = { - let l2351 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V2423; - let v2423 = match l2351 { - 0 => { - let e2423 = { - let l2352 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2353 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2399 = l2352; - let len2399 = l2353; - let mut result2399 = _rt::Vec::with_capacity(len2399); - for i in 0..len2399 { - let base = base2399 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2399 = { - let l2354 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2398; - let v2398 = match l2354 { - 0 => { - let e2398 = { - let l2355 = *base.add(8).cast::<*mut u8>(); - let l2356 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2357 = l2356; - _rt::Vec::from_raw_parts(l2355.cast(), len2357, len2357) - }; - V2398::RecordValue(e2398) - } - 1 => { - let e2398 = { - let l2358 = *base.add(8).cast::(); - let l2359 = i32::from(*base.add(12).cast::()); - ( - l2358 as u32, - match l2359 { - 0 => None, - 1 => { - let e = { - let l2360 = *base.add(16).cast::(); - l2360 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2398::VariantValue(e2398) - } - 2 => { - let e2398 = { - let l2361 = *base.add(8).cast::(); - l2361 as u32 - }; - V2398::EnumValue(e2398) - } - 3 => { - let e2398 = { - let l2362 = *base.add(8).cast::<*mut u8>(); - let l2363 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2365 = l2362; - let len2365 = l2363; - let mut result2365 = _rt::Vec::with_capacity(len2365); - for i in 0..len2365 { - let base = base2365.add(i * 1); - let e2365 = { - let l2364 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2364 as u8) - }; - result2365.push(e2365); - } - _rt::cabi_dealloc(base2365, len2365 * 1, 1); - result2365 - }; - V2398::FlagsValue(e2398) - } - 4 => { - let e2398 = { - let l2366 = *base.add(8).cast::<*mut u8>(); - let l2367 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2368 = l2367; - _rt::Vec::from_raw_parts(l2366.cast(), len2368, len2368) - }; - V2398::TupleValue(e2398) - } - 5 => { - let e2398 = { - let l2369 = *base.add(8).cast::<*mut u8>(); - let l2370 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2371 = l2370; - _rt::Vec::from_raw_parts(l2369.cast(), len2371, len2371) - }; - V2398::ListValue(e2398) - } - 6 => { - let e2398 = { - let l2372 = i32::from(*base.add(8).cast::()); - match l2372 { - 0 => None, - 1 => { - let e = { - let l2373 = *base.add(12).cast::(); - l2373 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2398::OptionValue(e2398) - } - 7 => { - let e2398 = { - let l2374 = i32::from(*base.add(8).cast::()); - match l2374 { - 0 => { - let e = { - let l2375 = i32::from(*base.add(12).cast::()); - match l2375 { - 0 => None, - 1 => { - let e = { - let l2376 = *base.add(16).cast::(); - l2376 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2377 = i32::from(*base.add(12).cast::()); - match l2377 { - 0 => None, - 1 => { - let e = { - let l2378 = *base.add(16).cast::(); - l2378 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2398::ResultValue(e2398) - } - 8 => { - let e2398 = { - let l2379 = i32::from(*base.add(8).cast::()); - l2379 as u8 - }; - V2398::PrimU8(e2398) - } - 9 => { - let e2398 = { - let l2380 = i32::from(*base.add(8).cast::()); - l2380 as u16 - }; - V2398::PrimU16(e2398) - } - 10 => { - let e2398 = { - let l2381 = *base.add(8).cast::(); - l2381 as u32 - }; - V2398::PrimU32(e2398) - } - 11 => { - let e2398 = { - let l2382 = *base.add(8).cast::(); - l2382 as u64 - }; - V2398::PrimU64(e2398) - } - 12 => { - let e2398 = { - let l2383 = i32::from(*base.add(8).cast::()); - l2383 as i8 - }; - V2398::PrimS8(e2398) - } - 13 => { - let e2398 = { - let l2384 = i32::from(*base.add(8).cast::()); - l2384 as i16 - }; - V2398::PrimS16(e2398) - } - 14 => { - let e2398 = { - let l2385 = *base.add(8).cast::(); - l2385 - }; - V2398::PrimS32(e2398) - } - 15 => { - let e2398 = { - let l2386 = *base.add(8).cast::(); - l2386 - }; - V2398::PrimS64(e2398) - } - 16 => { - let e2398 = { - let l2387 = *base.add(8).cast::(); - l2387 - }; - V2398::PrimFloat32(e2398) - } - 17 => { - let e2398 = { - let l2388 = *base.add(8).cast::(); - l2388 - }; - V2398::PrimFloat64(e2398) - } - 18 => { - let e2398 = { - let l2389 = *base.add(8).cast::(); - _rt::char_lift(l2389 as u32) - }; - V2398::PrimChar(e2398) - } - 19 => { - let e2398 = { - let l2390 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2390 as u8) - }; - V2398::PrimBool(e2398) - } - 20 => { - let e2398 = { - let l2391 = *base.add(8).cast::<*mut u8>(); - let l2392 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2393 = l2392; - let bytes2393 = _rt::Vec::from_raw_parts( - l2391.cast(), - len2393, - len2393, - ); - _rt::string_lift(bytes2393) - }; - V2398::PrimString(e2398) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2398 = { - let l2394 = *base.add(8).cast::<*mut u8>(); - let l2395 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2396 = l2395; - let bytes2396 = _rt::Vec::from_raw_parts( - l2394.cast(), - len2396, - len2396, - ); - let l2397 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2396), - }, - l2397 as u64, - ) - }; - V2398::Handle(e2398) - } - }; - v2398 - }; - result2399.push(e2399); - } - _rt::cabi_dealloc( - base2399, - len2399 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2399, - } - }; - V2423::ComponentModel(e2423) - } - 1 => { - let e2423 = { - let l2400 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2411; - let v2411 = match l2400 { - 0 => { - let e2411 = { - let l2401 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2402 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2403 = l2402; - let bytes2403 = _rt::Vec::from_raw_parts( - l2401.cast(), - len2403, - len2403, - ); - _rt::string_lift(bytes2403) - }; - V2411::Url(e2411) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2411 = { - let l2404 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2405 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2406 = l2405; - let bytes2406 = _rt::Vec::from_raw_parts( - l2404.cast(), - len2406, - len2406, - ); - let l2407 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2406), - text_type: match l2407 { - 0 => None, - 1 => { - let e = { - let l2408 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2409 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2410 = l2409; - let bytes2410 = _rt::Vec::from_raw_parts( - l2408.cast(), - len2410, - len2410, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2410), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2411::Inline(e2411) - } - }; - v2411 - }; - V2423::UnstructuredText(e2423) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2423 = { - let l2412 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2422; - let v2422 = match l2412 { - 0 => { - let e2422 = { - let l2413 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2414 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2415 = l2414; - let bytes2415 = _rt::Vec::from_raw_parts( - l2413.cast(), - len2415, - len2415, - ); - _rt::string_lift(bytes2415) - }; - V2422::Url(e2422) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2422 = { - let l2416 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2417 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2418 = l2417; - let l2419 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2420 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2421 = l2420; - let bytes2421 = _rt::Vec::from_raw_parts( - l2419.cast(), - len2421, - len2421, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2416.cast(), - len2418, - len2418, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2421), - }, - } - }; - V2422::Inline(e2422) - } - }; - v2422 - }; - V2423::UnstructuredBinary(e2423) - } - }; - v2423 - }; - result2424.push(e2424); - } - _rt::cabi_dealloc( - base2424, - len2424 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2424 - }; - V2504::Tuple(e2504) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2504 = { - let l2425 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2426 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2503 = l2425; - let len2503 = l2426; - let mut result2503 = _rt::Vec::with_capacity(len2503); - for i in 0..len2503 { - let base = base2503 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e2503 = { - let l2427 = *base.add(0).cast::<*mut u8>(); - let l2428 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2429 = l2428; - let bytes2429 = _rt::Vec::from_raw_parts( - l2427.cast(), - len2429, - len2429, - ); - let l2430 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V2502; - let v2502 = match l2430 { - 0 => { - let e2502 = { - let l2431 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2432 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2478 = l2431; - let len2478 = l2432; - let mut result2478 = _rt::Vec::with_capacity(len2478); - for i in 0..len2478 { - let base = base2478 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2478 = { - let l2433 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2477; - let v2477 = match l2433 { - 0 => { - let e2477 = { - let l2434 = *base.add(8).cast::<*mut u8>(); - let l2435 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2436 = l2435; - _rt::Vec::from_raw_parts(l2434.cast(), len2436, len2436) - }; - V2477::RecordValue(e2477) - } - 1 => { - let e2477 = { - let l2437 = *base.add(8).cast::(); - let l2438 = i32::from(*base.add(12).cast::()); - ( - l2437 as u32, - match l2438 { - 0 => None, - 1 => { - let e = { - let l2439 = *base.add(16).cast::(); - l2439 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2477::VariantValue(e2477) - } - 2 => { - let e2477 = { - let l2440 = *base.add(8).cast::(); - l2440 as u32 - }; - V2477::EnumValue(e2477) - } - 3 => { - let e2477 = { - let l2441 = *base.add(8).cast::<*mut u8>(); - let l2442 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2444 = l2441; - let len2444 = l2442; - let mut result2444 = _rt::Vec::with_capacity(len2444); - for i in 0..len2444 { - let base = base2444.add(i * 1); - let e2444 = { - let l2443 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2443 as u8) - }; - result2444.push(e2444); - } - _rt::cabi_dealloc(base2444, len2444 * 1, 1); - result2444 - }; - V2477::FlagsValue(e2477) - } - 4 => { - let e2477 = { - let l2445 = *base.add(8).cast::<*mut u8>(); - let l2446 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2447 = l2446; - _rt::Vec::from_raw_parts(l2445.cast(), len2447, len2447) - }; - V2477::TupleValue(e2477) - } - 5 => { - let e2477 = { - let l2448 = *base.add(8).cast::<*mut u8>(); - let l2449 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2450 = l2449; - _rt::Vec::from_raw_parts(l2448.cast(), len2450, len2450) - }; - V2477::ListValue(e2477) - } - 6 => { - let e2477 = { - let l2451 = i32::from(*base.add(8).cast::()); - match l2451 { - 0 => None, - 1 => { - let e = { - let l2452 = *base.add(12).cast::(); - l2452 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2477::OptionValue(e2477) - } - 7 => { - let e2477 = { - let l2453 = i32::from(*base.add(8).cast::()); - match l2453 { - 0 => { - let e = { - let l2454 = i32::from(*base.add(12).cast::()); - match l2454 { - 0 => None, - 1 => { - let e = { - let l2455 = *base.add(16).cast::(); - l2455 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2456 = i32::from(*base.add(12).cast::()); - match l2456 { - 0 => None, - 1 => { - let e = { - let l2457 = *base.add(16).cast::(); - l2457 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2477::ResultValue(e2477) - } - 8 => { - let e2477 = { - let l2458 = i32::from(*base.add(8).cast::()); - l2458 as u8 - }; - V2477::PrimU8(e2477) - } - 9 => { - let e2477 = { - let l2459 = i32::from(*base.add(8).cast::()); - l2459 as u16 - }; - V2477::PrimU16(e2477) - } - 10 => { - let e2477 = { - let l2460 = *base.add(8).cast::(); - l2460 as u32 - }; - V2477::PrimU32(e2477) - } - 11 => { - let e2477 = { - let l2461 = *base.add(8).cast::(); - l2461 as u64 - }; - V2477::PrimU64(e2477) - } - 12 => { - let e2477 = { - let l2462 = i32::from(*base.add(8).cast::()); - l2462 as i8 - }; - V2477::PrimS8(e2477) - } - 13 => { - let e2477 = { - let l2463 = i32::from(*base.add(8).cast::()); - l2463 as i16 - }; - V2477::PrimS16(e2477) - } - 14 => { - let e2477 = { - let l2464 = *base.add(8).cast::(); - l2464 - }; - V2477::PrimS32(e2477) - } - 15 => { - let e2477 = { - let l2465 = *base.add(8).cast::(); - l2465 - }; - V2477::PrimS64(e2477) - } - 16 => { - let e2477 = { - let l2466 = *base.add(8).cast::(); - l2466 - }; - V2477::PrimFloat32(e2477) - } - 17 => { - let e2477 = { - let l2467 = *base.add(8).cast::(); - l2467 - }; - V2477::PrimFloat64(e2477) - } - 18 => { - let e2477 = { - let l2468 = *base.add(8).cast::(); - _rt::char_lift(l2468 as u32) - }; - V2477::PrimChar(e2477) - } - 19 => { - let e2477 = { - let l2469 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2469 as u8) - }; - V2477::PrimBool(e2477) - } - 20 => { - let e2477 = { - let l2470 = *base.add(8).cast::<*mut u8>(); - let l2471 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2472 = l2471; - let bytes2472 = _rt::Vec::from_raw_parts( - l2470.cast(), - len2472, - len2472, - ); - _rt::string_lift(bytes2472) - }; - V2477::PrimString(e2477) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2477 = { - let l2473 = *base.add(8).cast::<*mut u8>(); - let l2474 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2475 = l2474; - let bytes2475 = _rt::Vec::from_raw_parts( - l2473.cast(), - len2475, - len2475, - ); - let l2476 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2475), - }, - l2476 as u64, - ) - }; - V2477::Handle(e2477) - } - }; - v2477 - }; - result2478.push(e2478); - } - _rt::cabi_dealloc( - base2478, - len2478 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2478, - } - }; - V2502::ComponentModel(e2502) - } - 1 => { - let e2502 = { - let l2479 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2490; - let v2490 = match l2479 { - 0 => { - let e2490 = { - let l2480 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2481 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2482 = l2481; - let bytes2482 = _rt::Vec::from_raw_parts( - l2480.cast(), - len2482, - len2482, - ); - _rt::string_lift(bytes2482) - }; - V2490::Url(e2490) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2490 = { - let l2483 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2484 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2485 = l2484; - let bytes2485 = _rt::Vec::from_raw_parts( - l2483.cast(), - len2485, - len2485, - ); - let l2486 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2485), - text_type: match l2486 { - 0 => None, - 1 => { - let e = { - let l2487 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2488 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2489 = l2488; - let bytes2489 = _rt::Vec::from_raw_parts( - l2487.cast(), - len2489, - len2489, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2489), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2490::Inline(e2490) - } - }; - v2490 - }; - V2502::UnstructuredText(e2502) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2502 = { - let l2491 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2501; - let v2501 = match l2491 { - 0 => { - let e2501 = { - let l2492 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2493 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2494 = l2493; - let bytes2494 = _rt::Vec::from_raw_parts( - l2492.cast(), - len2494, - len2494, - ); - _rt::string_lift(bytes2494) - }; - V2501::Url(e2501) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2501 = { - let l2495 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2496 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2497 = l2496; - let l2498 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2499 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2500 = l2499; - let bytes2500 = _rt::Vec::from_raw_parts( - l2498.cast(), - len2500, - len2500, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2495.cast(), - len2497, - len2497, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2500), - }, - } - }; - V2501::Inline(e2501) - } - }; - v2501 - }; - V2502::UnstructuredBinary(e2502) - } - }; - (_rt::string_lift(bytes2429), v2502) - }; - result2503.push(e2503); - } - _rt::cabi_dealloc( - base2503, - len2503 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2503 - }; - V2504::Multimodal(e2504) - } - }; - let l2505 = i32::from( - *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2652; - let v2652 = match l2505 { - 0 => { - let e2652 = { - let l2506 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2507 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2578 = l2506; - let len2578 = l2507; - let mut result2578 = _rt::Vec::with_capacity(len2578); - for i in 0..len2578 { - let base = base2578 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2578 = { - let l2508 = *base.add(0).cast::<*mut u8>(); - let l2509 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2510 = l2509; - let bytes2510 = _rt::Vec::from_raw_parts( - l2508.cast(), - len2510, - len2510, - ); - let l2511 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2577; - let v2577 = match l2511 { - 0 => { - let e2577 = { - let l2512 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2513 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2562 = l2512; - let len2562 = l2513; - let mut result2562 = _rt::Vec::with_capacity(len2562); - for i in 0..len2562 { - let base = base2562 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2562 = { - let l2514 = i32::from(*base.add(0).cast::()); - let l2518 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2522 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2561; - let v2561 = match l2522 { - 0 => { - let e2561 = { - let l2523 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2524 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2529 = l2523; - let len2529 = l2524; - let mut result2529 = _rt::Vec::with_capacity(len2529); - for i in 0..len2529 { - let base = base2529 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2529 = { - let l2525 = *base.add(0).cast::<*mut u8>(); - let l2526 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2527 = l2526; - let bytes2527 = _rt::Vec::from_raw_parts( - l2525.cast(), - len2527, - len2527, - ); - let l2528 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2527), l2528) - }; - result2529.push(e2529); - } - _rt::cabi_dealloc( - base2529, - len2529 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2529 - }; - V2561::RecordType(e2561) - } - 1 => { - let e2561 = { - let l2530 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2531 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2537 = l2530; - let len2537 = l2531; - let mut result2537 = _rt::Vec::with_capacity(len2537); - for i in 0..len2537 { - let base = base2537 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2537 = { - let l2532 = *base.add(0).cast::<*mut u8>(); - let l2533 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2534 = l2533; - let bytes2534 = _rt::Vec::from_raw_parts( - l2532.cast(), - len2534, - len2534, - ); - let l2535 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2534), - match l2535 { - 0 => None, - 1 => { - let e = { - let l2536 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2536 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2537.push(e2537); - } - _rt::cabi_dealloc( - base2537, - len2537 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2537 - }; - V2561::VariantType(e2561) - } - 2 => { - let e2561 = { - let l2538 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2539 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2543 = l2538; - let len2543 = l2539; - let mut result2543 = _rt::Vec::with_capacity(len2543); - for i in 0..len2543 { - let base = base2543 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2543 = { - let l2540 = *base.add(0).cast::<*mut u8>(); - let l2541 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2542 = l2541; - let bytes2542 = _rt::Vec::from_raw_parts( - l2540.cast(), - len2542, - len2542, - ); - _rt::string_lift(bytes2542) - }; - result2543.push(e2543); - } - _rt::cabi_dealloc( - base2543, - len2543 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2543 - }; - V2561::EnumType(e2561) - } - 3 => { - let e2561 = { - let l2544 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2545 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2549 = l2544; - let len2549 = l2545; - let mut result2549 = _rt::Vec::with_capacity(len2549); - for i in 0..len2549 { - let base = base2549 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2549 = { - let l2546 = *base.add(0).cast::<*mut u8>(); - let l2547 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2548 = l2547; - let bytes2548 = _rt::Vec::from_raw_parts( - l2546.cast(), - len2548, - len2548, - ); - _rt::string_lift(bytes2548) - }; - result2549.push(e2549); - } - _rt::cabi_dealloc( - base2549, - len2549 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2549 - }; - V2561::FlagsType(e2561) - } - 4 => { - let e2561 = { - let l2550 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2551 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2552 = l2551; - _rt::Vec::from_raw_parts(l2550.cast(), len2552, len2552) - }; - V2561::TupleType(e2561) - } - 5 => { - let e2561 = { - let l2553 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2553 - }; - V2561::ListType(e2561) - } - 6 => { - let e2561 = { - let l2554 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2554 - }; - V2561::OptionType(e2561) - } - 7 => { - let e2561 = { - let l2555 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2557 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2555 { - 0 => None, - 1 => { - let e = { - let l2556 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2556 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2557 { - 0 => None, - 1 => { - let e = { - let l2558 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2558 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2561::ResultType(e2561) - } - 8 => V2561::PrimU8Type, - 9 => V2561::PrimU16Type, - 10 => V2561::PrimU32Type, - 11 => V2561::PrimU64Type, - 12 => V2561::PrimS8Type, - 13 => V2561::PrimS16Type, - 14 => V2561::PrimS32Type, - 15 => V2561::PrimS64Type, - 16 => V2561::PrimF32Type, - 17 => V2561::PrimF64Type, - 18 => V2561::PrimCharType, - 19 => V2561::PrimBoolType, - 20 => V2561::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2561 = { - let l2559 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2560 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2559 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2560 as u8, - ), - ) - }; - V2561::HandleType(e2561) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2514 { - 0 => None, - 1 => { - let e = { - let l2515 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2516 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2517 = l2516; - let bytes2517 = _rt::Vec::from_raw_parts( - l2515.cast(), - len2517, - len2517, - ); - _rt::string_lift(bytes2517) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2518 { - 0 => None, - 1 => { - let e = { - let l2519 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2520 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2521 = l2520; - let bytes2521 = _rt::Vec::from_raw_parts( - l2519.cast(), - len2521, - len2521, - ); - _rt::string_lift(bytes2521) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2561, - } - }; - result2562.push(e2562); - } - _rt::cabi_dealloc( - base2562, - len2562 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2562, - } - }; - V2577::ComponentModel(e2577) - } - 1 => { - let e2577 = { - let l2563 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2563 { - 0 => None, - 1 => { - let e = { - let l2564 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2565 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2569 = l2564; - let len2569 = l2565; - let mut result2569 = _rt::Vec::with_capacity(len2569); - for i in 0..len2569 { - let base = base2569 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2569 = { - let l2566 = *base.add(0).cast::<*mut u8>(); - let l2567 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2568 = l2567; - let bytes2568 = _rt::Vec::from_raw_parts( - l2566.cast(), - len2568, - len2568, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2568), - } - }; - result2569.push(e2569); - } - _rt::cabi_dealloc( - base2569, - len2569 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2569 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2577::UnstructuredText(e2577) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2577 = { - let l2570 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2570 { - 0 => None, - 1 => { - let e = { - let l2571 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2572 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2576 = l2571; - let len2576 = l2572; - let mut result2576 = _rt::Vec::with_capacity(len2576); - for i in 0..len2576 { - let base = base2576 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2576 = { - let l2573 = *base.add(0).cast::<*mut u8>(); - let l2574 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2575 = l2574; - let bytes2575 = _rt::Vec::from_raw_parts( - l2573.cast(), - len2575, - len2575, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2575), - } - }; - result2576.push(e2576); - } - _rt::cabi_dealloc( - base2576, - len2576 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2576 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2577::UnstructuredBinary(e2577) - } - }; - (_rt::string_lift(bytes2510), v2577) - }; - result2578.push(e2578); - } - _rt::cabi_dealloc( - base2578, - len2578 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2578 - }; - V2652::Tuple(e2652) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2652 = { - let l2579 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2580 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2651 = l2579; - let len2651 = l2580; - let mut result2651 = _rt::Vec::with_capacity(len2651); - for i in 0..len2651 { - let base = base2651 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2651 = { - let l2581 = *base.add(0).cast::<*mut u8>(); - let l2582 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2583 = l2582; - let bytes2583 = _rt::Vec::from_raw_parts( - l2581.cast(), - len2583, - len2583, - ); - let l2584 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2650; - let v2650 = match l2584 { - 0 => { - let e2650 = { - let l2585 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2586 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2635 = l2585; - let len2635 = l2586; - let mut result2635 = _rt::Vec::with_capacity(len2635); - for i in 0..len2635 { - let base = base2635 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2635 = { - let l2587 = i32::from(*base.add(0).cast::()); - let l2591 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2595 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2634; - let v2634 = match l2595 { - 0 => { - let e2634 = { - let l2596 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2597 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2602 = l2596; - let len2602 = l2597; - let mut result2602 = _rt::Vec::with_capacity(len2602); - for i in 0..len2602 { - let base = base2602 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2602 = { - let l2598 = *base.add(0).cast::<*mut u8>(); - let l2599 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2600 = l2599; - let bytes2600 = _rt::Vec::from_raw_parts( - l2598.cast(), - len2600, - len2600, - ); - let l2601 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2600), l2601) - }; - result2602.push(e2602); - } - _rt::cabi_dealloc( - base2602, - len2602 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2602 - }; - V2634::RecordType(e2634) - } - 1 => { - let e2634 = { - let l2603 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2604 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2610 = l2603; - let len2610 = l2604; - let mut result2610 = _rt::Vec::with_capacity(len2610); - for i in 0..len2610 { - let base = base2610 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2610 = { - let l2605 = *base.add(0).cast::<*mut u8>(); - let l2606 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2607 = l2606; - let bytes2607 = _rt::Vec::from_raw_parts( - l2605.cast(), - len2607, - len2607, - ); - let l2608 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2607), - match l2608 { - 0 => None, - 1 => { - let e = { - let l2609 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2609 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2610.push(e2610); - } - _rt::cabi_dealloc( - base2610, - len2610 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2610 - }; - V2634::VariantType(e2634) - } - 2 => { - let e2634 = { - let l2611 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2612 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2616 = l2611; - let len2616 = l2612; - let mut result2616 = _rt::Vec::with_capacity(len2616); - for i in 0..len2616 { - let base = base2616 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2616 = { - let l2613 = *base.add(0).cast::<*mut u8>(); - let l2614 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2615 = l2614; - let bytes2615 = _rt::Vec::from_raw_parts( - l2613.cast(), - len2615, - len2615, - ); - _rt::string_lift(bytes2615) - }; - result2616.push(e2616); - } - _rt::cabi_dealloc( - base2616, - len2616 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2616 - }; - V2634::EnumType(e2634) - } - 3 => { - let e2634 = { - let l2617 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2618 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2622 = l2617; - let len2622 = l2618; - let mut result2622 = _rt::Vec::with_capacity(len2622); - for i in 0..len2622 { - let base = base2622 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2622 = { - let l2619 = *base.add(0).cast::<*mut u8>(); - let l2620 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2621 = l2620; - let bytes2621 = _rt::Vec::from_raw_parts( - l2619.cast(), - len2621, - len2621, - ); - _rt::string_lift(bytes2621) - }; - result2622.push(e2622); - } - _rt::cabi_dealloc( - base2622, - len2622 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2622 - }; - V2634::FlagsType(e2634) - } - 4 => { - let e2634 = { - let l2623 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2624 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2625 = l2624; - _rt::Vec::from_raw_parts(l2623.cast(), len2625, len2625) - }; - V2634::TupleType(e2634) - } - 5 => { - let e2634 = { - let l2626 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2626 - }; - V2634::ListType(e2634) - } - 6 => { - let e2634 = { - let l2627 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2627 - }; - V2634::OptionType(e2634) - } - 7 => { - let e2634 = { - let l2628 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2630 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2628 { - 0 => None, - 1 => { - let e = { - let l2629 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2629 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2630 { - 0 => None, - 1 => { - let e = { - let l2631 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2631 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2634::ResultType(e2634) - } - 8 => V2634::PrimU8Type, - 9 => V2634::PrimU16Type, - 10 => V2634::PrimU32Type, - 11 => V2634::PrimU64Type, - 12 => V2634::PrimS8Type, - 13 => V2634::PrimS16Type, - 14 => V2634::PrimS32Type, - 15 => V2634::PrimS64Type, - 16 => V2634::PrimF32Type, - 17 => V2634::PrimF64Type, - 18 => V2634::PrimCharType, - 19 => V2634::PrimBoolType, - 20 => V2634::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2634 = { - let l2632 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2633 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2632 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2633 as u8, - ), - ) - }; - V2634::HandleType(e2634) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2587 { - 0 => None, - 1 => { - let e = { - let l2588 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2589 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2590 = l2589; - let bytes2590 = _rt::Vec::from_raw_parts( - l2588.cast(), - len2590, - len2590, - ); - _rt::string_lift(bytes2590) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2591 { - 0 => None, - 1 => { - let e = { - let l2592 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2593 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2594 = l2593; - let bytes2594 = _rt::Vec::from_raw_parts( - l2592.cast(), - len2594, - len2594, - ); - _rt::string_lift(bytes2594) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2634, - } - }; - result2635.push(e2635); - } - _rt::cabi_dealloc( - base2635, - len2635 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2635, - } - }; - V2650::ComponentModel(e2650) - } - 1 => { - let e2650 = { - let l2636 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2636 { - 0 => None, - 1 => { - let e = { - let l2637 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2638 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2642 = l2637; - let len2642 = l2638; - let mut result2642 = _rt::Vec::with_capacity(len2642); - for i in 0..len2642 { - let base = base2642 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2642 = { - let l2639 = *base.add(0).cast::<*mut u8>(); - let l2640 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2641 = l2640; - let bytes2641 = _rt::Vec::from_raw_parts( - l2639.cast(), - len2641, - len2641, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2641), - } - }; - result2642.push(e2642); - } - _rt::cabi_dealloc( - base2642, - len2642 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2642 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2650::UnstructuredText(e2650) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2650 = { - let l2643 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2643 { - 0 => None, - 1 => { - let e = { - let l2644 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2645 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2649 = l2644; - let len2649 = l2645; - let mut result2649 = _rt::Vec::with_capacity(len2649); - for i in 0..len2649 { - let base = base2649 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2649 = { - let l2646 = *base.add(0).cast::<*mut u8>(); - let l2647 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2648 = l2647; - let bytes2648 = _rt::Vec::from_raw_parts( - l2646.cast(), - len2648, - len2648, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2648), - } - }; - result2649.push(e2649); - } - _rt::cabi_dealloc( - base2649, - len2649 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2649 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2650::UnstructuredBinary(e2650) - } - }; - (_rt::string_lift(bytes2583), v2650) - }; - result2651.push(e2651); - } - _rt::cabi_dealloc( - base2651, - len2651 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2651 - }; - V2652::Multimodal(e2652) - } - }; - let l2653 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2654 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2655 = l2654; - let bytes2655 = _rt::Vec::from_raw_parts( - l2653.cast(), - len2655, - len2655, - ); - let l2656 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2657 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2661 = l2656; - let len2661 = l2657; - let mut result2661 = _rt::Vec::with_capacity(len2661); - for i in 0..len2661 { - let base = base2661 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2661 = { - let l2658 = *base.add(0).cast::<*mut u8>(); - let l2659 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2660 = l2659; - let bytes2660 = _rt::Vec::from_raw_parts( - l2658.cast(), - len2660, - len2660, - ); - _rt::string_lift(bytes2660) - }; - result2661.push(e2661); - } - _rt::cabi_dealloc( - base2661, - len2661 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2662 = *base - .add(32 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2663 = *base - .add(32 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2695 = l2662; - let len2695 = l2663; - let mut result2695 = _rt::Vec::with_capacity(len2695); - for i in 0..len2695 { - let base = base2695 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2695 = { - let l2664 = *base.add(0).cast::<*mut u8>(); - let l2665 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2694 = l2664; - let len2694 = l2665; - let mut result2694 = _rt::Vec::with_capacity(len2694); - for i in 0..len2694 { - let base = base2694 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2694 = { - let l2666 = i32::from(*base.add(0).cast::()); - let v2693 = match l2666 { - 0 => { - let e2693 = { - let l2667 = *base.add(8).cast::<*mut u8>(); - let l2668 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2669 = l2668; - let bytes2669 = _rt::Vec::from_raw_parts( - l2667.cast(), - len2669, - len2669, - ); - let l2670 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2671 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2672 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2676 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2678 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2679 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2688 = l2678; - let len2688 = l2679; - let mut result2688 = _rt::Vec::with_capacity(len2688); - for i in 0..len2688 { - let base = base2688 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2688 = { - let l2680 = *base.add(0).cast::<*mut u8>(); - let l2681 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2682 = l2681; - let bytes2682 = _rt::Vec::from_raw_parts( - l2680.cast(), - len2682, - len2682, - ); - let l2683 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2687; - let v2687 = match l2683 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2687 = { - let l2684 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2685 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2686 = l2685; - let bytes2686 = _rt::Vec::from_raw_parts( - l2684.cast(), - len2686, - len2686, - ); - _rt::string_lift(bytes2686) - }; - V2687::String(e2687) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2682), - value: v2687, - } - }; - result2688.push(e2688); - } - _rt::cabi_dealloc( - base2688, - len2688 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2689 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2669), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2670 as u64, - nanoseconds: l2671 as u32, - }, - parent: match l2672 { - 0 => None, - 1 => { - let e = { - let l2673 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2674 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2675 = l2674; - let bytes2675 = _rt::Vec::from_raw_parts( - l2673.cast(), - len2675, - len2675, - ); - _rt::string_lift(bytes2675) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2676 { - 0 => None, - 1 => { - let e = { - let l2677 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2677 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2688, - inherited: _rt::bool_lift(l2689 as u8), - } - }; - SpanData::LocalSpan(e2693) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2693 = { - let l2690 = *base.add(8).cast::<*mut u8>(); - let l2691 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2692 = l2691; - let bytes2692 = _rt::Vec::from_raw_parts( - l2690.cast(), - len2692, - len2692, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2692), - } - }; - SpanData::ExternalSpan(e2693) - } - }; - v2693 - }; - result2694.push(e2694); - } - _rt::cabi_dealloc( - base2694, - len2694 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2694 - }; - result2695.push(e2695); - } - _rt::cabi_dealloc( - base2695, - len2695 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes2344), - method_name: _rt::string_lift(bytes2347), - function_input: TypedDataValue { - value: v2504, - schema: v2652, - }, - trace_id: _rt::string_lift(bytes2655), - trace_states: result2661, - invocation_context: result2695, - } - }; - AgentInvocation::AgentMethodInvocation(e2706) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e2706 = { - let l2696 = *base.add(32).cast::<*mut u8>(); - let l2697 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2698 = l2697; - let l2699 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2700 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2701 = l2700; - let bytes2701 = _rt::Vec::from_raw_parts( - l2699.cast(), - len2701, - len2701, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2696.cast(), - len2698, - len2698, - ), - mime_type: _rt::string_lift(bytes2701), - }, - } - }; - AgentInvocation::LoadSnapshot(e2706) - } - 4 => { - let e2706 = { - let l2702 = *base.add(32).cast::<*mut u8>(); - let l2703 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2704 = l2703; - let bytes2704 = _rt::Vec::from_raw_parts( - l2702.cast(), - len2704, - len2704, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes2704), - } - }; - AgentInvocation::ProcessOplogEntries(e2706) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e2706 = { - let l2705 = *base.add(32).cast::(); - ManualUpdateParameters { - target_revision: l2705 as u64, - } - }; - AgentInvocation::ManualUpdate(e2706) - } - }; - PendingAgentInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1988 as u64, - nanoseconds: l1989 as u32, - }, - invocation: v2706, - } - }; - PublicOplogEntry::PendingAgentInvocation(e2893) - } - 16 => { - let e2893 = { - let l2707 = *base.add(8).cast::(); - let l2708 = *base.add(16).cast::(); - let l2709 = *base.add(24).cast::(); - let l2710 = i32::from(*base.add(32).cast::()); - let v2717 = match l2710 { - 0 => UpdateDescription::AutoUpdate, - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2717 = { - let l2711 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2712 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2713 = l2712; - let l2714 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2715 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2716 = l2715; - let bytes2716 = _rt::Vec::from_raw_parts( - l2714.cast(), - len2716, - len2716, - ); - super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2711.cast(), - len2713, - len2713, - ), - mime_type: _rt::string_lift(bytes2716), - } - }; - UpdateDescription::SnapshotBased(e2717) - } - }; - PendingUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2707 as u64, - nanoseconds: l2708 as u32, - }, - target_revision: l2709 as u64, - update_description: v2717, - } - }; - PublicOplogEntry::PendingUpdate(e2893) - } - 17 => { - let e2893 = { - let l2718 = *base.add(8).cast::(); - let l2719 = *base.add(16).cast::(); - let l2720 = *base.add(24).cast::(); - let l2721 = *base.add(32).cast::(); - let l2722 = *base.add(40).cast::<*mut u8>(); - let l2723 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2739 = l2722; - let len2739 = l2723; - let mut result2739 = _rt::Vec::with_capacity(len2739); - for i in 0..len2739 { - let base = base2739 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2739 = { - let l2724 = *base.add(0).cast::<*mut u8>(); - let l2725 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2726 = l2725; - let bytes2726 = _rt::Vec::from_raw_parts( - l2724.cast(), - len2726, - len2726, - ); - let l2727 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2728 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2729 = l2728; - let bytes2729 = _rt::Vec::from_raw_parts( - l2727.cast(), - len2729, - len2729, - ); - let l2730 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2731 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2738 = l2730; - let len2738 = l2731; - let mut result2738 = _rt::Vec::with_capacity(len2738); - for i in 0..len2738 { - let base = base2738 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2738 = { - let l2732 = *base.add(0).cast::<*mut u8>(); - let l2733 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2734 = l2733; - let bytes2734 = _rt::Vec::from_raw_parts( - l2732.cast(), - len2734, - len2734, - ); - let l2735 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2736 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2737 = l2736; - let bytes2737 = _rt::Vec::from_raw_parts( - l2735.cast(), - len2737, - len2737, - ); - (_rt::string_lift(bytes2734), _rt::string_lift(bytes2737)) - }; - result2738.push(e2738); - } - _rt::cabi_dealloc( - base2738, - len2738 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes2726), - version: _rt::string_lift(bytes2729), - parameters: result2738, - } - }; - result2739.push(e2739); - } - _rt::cabi_dealloc( - base2739, - len2739 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - SuccessfulUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2718 as u64, - nanoseconds: l2719 as u32, - }, - target_revision: l2720 as u64, - new_component_size: l2721 as u64, - new_active_plugins: result2739, - } - }; - PublicOplogEntry::SuccessfulUpdate(e2893) - } - 18 => { - let e2893 = { - let l2740 = *base.add(8).cast::(); - let l2741 = *base.add(16).cast::(); - let l2742 = *base.add(24).cast::(); - let l2743 = i32::from(*base.add(32).cast::()); - FailedUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2740 as u64, - nanoseconds: l2741 as u32, - }, - target_revision: l2742 as u64, - details: match l2743 { - 0 => None, - 1 => { - let e = { - let l2744 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2745 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2746 = l2745; - let bytes2746 = _rt::Vec::from_raw_parts( - l2744.cast(), - len2746, - len2746, - ); - _rt::string_lift(bytes2746) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - PublicOplogEntry::FailedUpdate(e2893) - } - 19 => { - let e2893 = { - let l2747 = *base.add(8).cast::(); - let l2748 = *base.add(16).cast::(); - let l2749 = *base.add(24).cast::(); - GrowMemoryParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2747 as u64, - nanoseconds: l2748 as u32, - }, - delta: l2749 as u64, - } - }; - PublicOplogEntry::GrowMemory(e2893) - } - 20 => { - let e2893 = { - let l2750 = *base.add(8).cast::(); - let l2751 = *base.add(16).cast::(); - let l2752 = *base.add(24).cast::(); - let l2753 = *base.add(32).cast::<*mut u8>(); - let l2754 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2755 = l2754; - let bytes2755 = _rt::Vec::from_raw_parts( - l2753.cast(), - len2755, - len2755, - ); - let l2756 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2757 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2758 = l2757; - let bytes2758 = _rt::Vec::from_raw_parts( - l2756.cast(), - len2758, - len2758, - ); - CreateResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2750 as u64, - nanoseconds: l2751 as u32, - }, - resource_id: l2752 as u64, - name: _rt::string_lift(bytes2755), - owner: _rt::string_lift(bytes2758), - } - }; - PublicOplogEntry::CreateResource(e2893) - } - 21 => { - let e2893 = { - let l2759 = *base.add(8).cast::(); - let l2760 = *base.add(16).cast::(); - let l2761 = *base.add(24).cast::(); - let l2762 = *base.add(32).cast::<*mut u8>(); - let l2763 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2764 = l2763; - let bytes2764 = _rt::Vec::from_raw_parts( - l2762.cast(), - len2764, - len2764, - ); - let l2765 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2766 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2767 = l2766; - let bytes2767 = _rt::Vec::from_raw_parts( - l2765.cast(), - len2767, - len2767, - ); - DropResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2759 as u64, - nanoseconds: l2760 as u32, - }, - resource_id: l2761 as u64, - name: _rt::string_lift(bytes2764), - owner: _rt::string_lift(bytes2767), - } - }; - PublicOplogEntry::DropResource(e2893) - } - 22 => { - let e2893 = { - let l2768 = *base.add(8).cast::(); - let l2769 = *base.add(16).cast::(); - let l2770 = i32::from(*base.add(24).cast::()); - let l2771 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2772 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2773 = l2772; - let bytes2773 = _rt::Vec::from_raw_parts( - l2771.cast(), - len2773, - len2773, - ); - let l2774 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2775 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2776 = l2775; - let bytes2776 = _rt::Vec::from_raw_parts( - l2774.cast(), - len2776, - len2776, - ); - LogParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2768 as u64, - nanoseconds: l2769 as u32, - }, - level: LogLevel::_lift(l2770 as u8), - context: _rt::string_lift(bytes2773), - message: _rt::string_lift(bytes2776), - } - }; - PublicOplogEntry::Log(e2893) - } - 23 => { - let e2893 = { - let l2777 = *base.add(8).cast::(); - let l2778 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2777 as u64, - nanoseconds: l2778 as u32, - }, - } - }; - PublicOplogEntry::Restart(e2893) - } - 24 => { - let e2893 = { - let l2779 = *base.add(8).cast::(); - let l2780 = *base.add(16).cast::(); - let l2781 = *base.add(24).cast::<*mut u8>(); - let l2782 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2783 = l2782; - let bytes2783 = _rt::Vec::from_raw_parts( - l2781.cast(), - len2783, - len2783, - ); - let l2784 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2785 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2786 = l2785; - let bytes2786 = _rt::Vec::from_raw_parts( - l2784.cast(), - len2786, - len2786, - ); - let l2787 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2788 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2795 = l2787; - let len2795 = l2788; - let mut result2795 = _rt::Vec::with_capacity(len2795); - for i in 0..len2795 { - let base = base2795 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2795 = { - let l2789 = *base.add(0).cast::<*mut u8>(); - let l2790 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2791 = l2790; - let bytes2791 = _rt::Vec::from_raw_parts( - l2789.cast(), - len2791, - len2791, - ); - let l2792 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2793 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2794 = l2793; - let bytes2794 = _rt::Vec::from_raw_parts( - l2792.cast(), - len2794, - len2794, - ); - (_rt::string_lift(bytes2791), _rt::string_lift(bytes2794)) - }; - result2795.push(e2795); - } - _rt::cabi_dealloc( - base2795, - len2795 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - ActivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2779 as u64, - nanoseconds: l2780 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2783), - version: _rt::string_lift(bytes2786), - parameters: result2795, - }, - } - }; - PublicOplogEntry::ActivatePlugin(e2893) - } - 25 => { - let e2893 = { - let l2796 = *base.add(8).cast::(); - let l2797 = *base.add(16).cast::(); - let l2798 = *base.add(24).cast::<*mut u8>(); - let l2799 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2800 = l2799; - let bytes2800 = _rt::Vec::from_raw_parts( - l2798.cast(), - len2800, - len2800, - ); - let l2801 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2802 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2803 = l2802; - let bytes2803 = _rt::Vec::from_raw_parts( - l2801.cast(), - len2803, - len2803, - ); - let l2804 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2805 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2812 = l2804; - let len2812 = l2805; - let mut result2812 = _rt::Vec::with_capacity(len2812); - for i in 0..len2812 { - let base = base2812 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2812 = { - let l2806 = *base.add(0).cast::<*mut u8>(); - let l2807 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2808 = l2807; - let bytes2808 = _rt::Vec::from_raw_parts( - l2806.cast(), - len2808, - len2808, - ); - let l2809 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2810 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2811 = l2810; - let bytes2811 = _rt::Vec::from_raw_parts( - l2809.cast(), - len2811, - len2811, - ); - (_rt::string_lift(bytes2808), _rt::string_lift(bytes2811)) - }; - result2812.push(e2812); - } - _rt::cabi_dealloc( - base2812, - len2812 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - DeactivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2796 as u64, - nanoseconds: l2797 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2800), - version: _rt::string_lift(bytes2803), - parameters: result2812, - }, - } - }; - PublicOplogEntry::DeactivatePlugin(e2893) - } - 26 => { - let e2893 = { - let l2813 = *base.add(8).cast::(); - let l2814 = *base.add(16).cast::(); - let l2815 = *base.add(24).cast::(); - let l2816 = *base.add(32).cast::(); - RevertParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2813 as u64, - nanoseconds: l2814 as u32, - }, - dropped_region: OplogRegion { - start: l2815 as u64, - end: l2816 as u64, - }, - } - }; - PublicOplogEntry::Revert(e2893) - } - 27 => { - let e2893 = { - let l2817 = *base.add(8).cast::(); - let l2818 = *base.add(16).cast::(); - let l2819 = *base.add(24).cast::<*mut u8>(); - let l2820 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2821 = l2820; - let bytes2821 = _rt::Vec::from_raw_parts( - l2819.cast(), - len2821, - len2821, - ); - CancelPendingInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2817 as u64, - nanoseconds: l2818 as u32, - }, - idempotency_key: _rt::string_lift(bytes2821), - } - }; - PublicOplogEntry::CancelPendingInvocation(e2893) - } - 28 => { - let e2893 = { - let l2822 = *base.add(8).cast::(); - let l2823 = *base.add(16).cast::(); - let l2824 = *base.add(24).cast::<*mut u8>(); - let l2825 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2826 = l2825; - let bytes2826 = _rt::Vec::from_raw_parts( - l2824.cast(), - len2826, - len2826, - ); - let l2827 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2831 = i32::from( - *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2835 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2836 = *base - .add(24 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2845 = l2835; - let len2845 = l2836; - let mut result2845 = _rt::Vec::with_capacity(len2845); - for i in 0..len2845 { - let base = base2845 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2845 = { - let l2837 = *base.add(0).cast::<*mut u8>(); - let l2838 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2839 = l2838; - let bytes2839 = _rt::Vec::from_raw_parts( - l2837.cast(), - len2839, - len2839, - ); - let l2840 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2844; - let v2844 = match l2840 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2844 = { - let l2841 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2842 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2843 = l2842; - let bytes2843 = _rt::Vec::from_raw_parts( - l2841.cast(), - len2843, - len2843, - ); - _rt::string_lift(bytes2843) - }; - V2844::String(e2844) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2839), - value: v2844, - } - }; - result2845.push(e2845); - } - _rt::cabi_dealloc( - base2845, - len2845 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - StartSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2822 as u64, - nanoseconds: l2823 as u32, - }, - span_id: _rt::string_lift(bytes2826), - parent: match l2827 { - 0 => None, - 1 => { - let e = { - let l2828 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2829 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2830 = l2829; - let bytes2830 = _rt::Vec::from_raw_parts( - l2828.cast(), - len2830, - len2830, - ); - _rt::string_lift(bytes2830) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context_id: match l2831 { - 0 => None, - 1 => { - let e = { - let l2832 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2833 = *base - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2834 = l2833; - let bytes2834 = _rt::Vec::from_raw_parts( - l2832.cast(), - len2834, - len2834, - ); - _rt::string_lift(bytes2834) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2845, - } - }; - PublicOplogEntry::StartSpan(e2893) - } - 29 => { - let e2893 = { - let l2846 = *base.add(8).cast::(); - let l2847 = *base.add(16).cast::(); - let l2848 = *base.add(24).cast::<*mut u8>(); - let l2849 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2850 = l2849; - let bytes2850 = _rt::Vec::from_raw_parts( - l2848.cast(), - len2850, - len2850, - ); - FinishSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2846 as u64, - nanoseconds: l2847 as u32, - }, - span_id: _rt::string_lift(bytes2850), - } - }; - PublicOplogEntry::FinishSpan(e2893) - } - 30 => { - let e2893 = { - let l2851 = *base.add(8).cast::(); - let l2852 = *base.add(16).cast::(); - let l2853 = *base.add(24).cast::<*mut u8>(); - let l2854 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2855 = l2854; - let bytes2855 = _rt::Vec::from_raw_parts( - l2853.cast(), - len2855, - len2855, - ); - let l2856 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2857 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2858 = l2857; - let bytes2858 = _rt::Vec::from_raw_parts( - l2856.cast(), - len2858, - len2858, - ); - let l2859 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2863; - let v2863 = match l2859 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2863 = { - let l2860 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2861 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2862 = l2861; - let bytes2862 = _rt::Vec::from_raw_parts( - l2860.cast(), - len2862, - len2862, - ); - _rt::string_lift(bytes2862) - }; - V2863::String(e2863) - } - }; - SetSpanAttributeParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2851 as u64, - nanoseconds: l2852 as u32, - }, - span_id: _rt::string_lift(bytes2855), - key: _rt::string_lift(bytes2858), - value: v2863, - } - }; - PublicOplogEntry::SetSpanAttribute(e2893) - } - 31 => { - let e2893 = { - let l2864 = *base.add(8).cast::(); - let l2865 = *base.add(16).cast::(); - let l2866 = i32::from(*base.add(24).cast::()); - use super::super::super::golem::api::host::PersistenceLevel as V2867; - let v2867 = match l2866 { - 0 => V2867::PersistNothing, - 1 => V2867::PersistRemoteSideEffects, - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - V2867::Smart - } - }; - ChangePersistenceLevelParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2864 as u64, - nanoseconds: l2865 as u32, - }, - persistence_level: v2867, - } - }; - PublicOplogEntry::ChangePersistenceLevel(e2893) - } - 32 => { - let e2893 = { - let l2868 = *base.add(8).cast::(); - let l2869 = *base.add(16).cast::(); - let l2870 = *base.add(24).cast::<*mut u8>(); - let l2871 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2872 = l2871; - let bytes2872 = _rt::Vec::from_raw_parts( - l2870.cast(), - len2872, - len2872, - ); - BeginRemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2868 as u64, - nanoseconds: l2869 as u32, - }, - transaction_id: _rt::string_lift(bytes2872), - } - }; - PublicOplogEntry::BeginRemoteTransaction(e2893) - } - 33 => { - let e2893 = { - let l2873 = *base.add(8).cast::(); - let l2874 = *base.add(16).cast::(); - let l2875 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2873 as u64, - nanoseconds: l2874 as u32, - }, - begin_index: l2875 as u64, - } - }; - PublicOplogEntry::PreCommitRemoteTransaction(e2893) - } - 34 => { - let e2893 = { - let l2876 = *base.add(8).cast::(); - let l2877 = *base.add(16).cast::(); - let l2878 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2876 as u64, - nanoseconds: l2877 as u32, - }, - begin_index: l2878 as u64, - } - }; - PublicOplogEntry::PreRollbackRemoteTransaction(e2893) - } - 35 => { - let e2893 = { - let l2879 = *base.add(8).cast::(); - let l2880 = *base.add(16).cast::(); - let l2881 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2879 as u64, - nanoseconds: l2880 as u32, - }, - begin_index: l2881 as u64, - } - }; - PublicOplogEntry::CommittedRemoteTransaction(e2893) - } - 36 => { - let e2893 = { - let l2882 = *base.add(8).cast::(); - let l2883 = *base.add(16).cast::(); - let l2884 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2882 as u64, - nanoseconds: l2883 as u32, - }, - begin_index: l2884 as u64, - } - }; - PublicOplogEntry::RolledBackRemoteTransaction(e2893) - } - n => { - debug_assert_eq!(n, 37, "invalid enum discriminant"); - let e2893 = { - let l2885 = *base.add(8).cast::(); - let l2886 = *base.add(16).cast::(); - let l2887 = *base.add(24).cast::<*mut u8>(); - let l2888 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2889 = l2888; - let l2890 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2891 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2892 = l2891; - let bytes2892 = _rt::Vec::from_raw_parts( - l2890.cast(), - len2892, - len2892, - ); - SnapshotParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2885 as u64, - nanoseconds: l2886 as u32, - }, - data: _rt::Vec::from_raw_parts( - l2887.cast(), - len2889, - len2889, - ), - mime_type: _rt::string_lift(bytes2892), - } - }; - PublicOplogEntry::Snapshot(e2893) - } - }; - v2893 - }; - result2894.push(e2894); - } - _rt::cabi_dealloc( - base2894, - len2894 * (120 + 14 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2894 - }; - Ok(e) - } - 1 => { - let e = { - let l2895 = *ptr218 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2896 = *ptr218 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2897 = l2896; - let bytes2897 = _rt::Vec::from_raw_parts( - l2895.cast(), - len2897, - len2897, - ); - _rt::string_lift(bytes2897) - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - if layout217.size() != 0 { - _rt::alloc::dealloc(result217.cast(), layout217); - } - for (ptr, layout) in cleanup_list { - if layout.size() != 0 { - _rt::alloc::dealloc(ptr.cast(), layout); - } - } - result2898 - } - } - impl GetOplog { - #[allow(unused_unsafe, clippy::all)] - pub fn new(agent_id: &AgentId, start: OplogIndex) -> Self { - unsafe { - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[constructor]get-oplog"] - fn wit_import4( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import4( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: i64, - ) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import4( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - _rt::as_i64(start), - ) - }; - unsafe { GetOplog::from_handle(ret as u32) } - } - } - } - impl GetOplog { - #[allow(unused_unsafe, clippy::all)] - pub fn get_next(&self) -> Option<_rt::Vec> { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]get-oplog.get-next"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let result2677 = match l2 { - 0 => None, - 1 => { - let e = { - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l4 = *ptr0 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2676 = l3; - let len2676 = l4; - let mut result2676 = _rt::Vec::with_capacity(len2676); - for i in 0..len2676 { - let base = base2676 - .add(i * (120 + 14 * ::core::mem::size_of::<*const u8>())); - let e2676 = { - let l5 = i32::from(*base.add(0).cast::()); - let v2675 = match l5 { - 0 => { - let e2675 = { - let l6 = *base.add(8).cast::(); - let l7 = *base.add(16).cast::(); - let l8 = *base.add(24).cast::(); - let l9 = *base.add(32).cast::(); - let l10 = *base.add(40).cast::<*mut u8>(); - let l11 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len12 = l11; - let bytes12 = _rt::Vec::from_raw_parts( - l10.cast(), - len12, - len12, - ); - let l13 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l14 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l15 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base19 = l14; - let len19 = l15; - let mut result19 = _rt::Vec::with_capacity(len19); - for i in 0..len19 { - let base = base19 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e19 = { - let l16 = *base.add(0).cast::<*mut u8>(); - let l17 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len18 = l17; - let bytes18 = _rt::Vec::from_raw_parts( - l16.cast(), - len18, - len18, - ); - _rt::string_lift(bytes18) - }; - result19.push(e19); - } - _rt::cabi_dealloc( - base19, - len19 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l20 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l21 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base28 = l20; - let len28 = l21; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e28 = { - let l22 = *base.add(0).cast::<*mut u8>(); - let l23 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len24 = l23; - let bytes24 = _rt::Vec::from_raw_parts( - l22.cast(), - len24, - len24, - ); - let l25 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l26 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len27 = l26; - let bytes27 = _rt::Vec::from_raw_parts( - l25.cast(), - len27, - len27, - ); - (_rt::string_lift(bytes24), _rt::string_lift(bytes27)) - }; - result28.push(e28); - } - _rt::cabi_dealloc( - base28, - len28 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l29 = *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l30 = *base - .add(56 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l31 = *base - .add(64 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l32 = *base - .add(72 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l33 = i32::from( - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l39 = *base - .add(104 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l40 = *base - .add(112 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l41 = *base - .add(120 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l42 = *base - .add(120 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base58 = l41; - let len58 = l42; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l43 = *base.add(0).cast::<*mut u8>(); - let l44 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len45 = l44; - let bytes45 = _rt::Vec::from_raw_parts( - l43.cast(), - len45, - len45, - ); - let l46 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l47 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len48 = l47; - let bytes48 = _rt::Vec::from_raw_parts( - l46.cast(), - len48, - len48, - ); - let l49 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l50 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base57 = l49; - let len57 = l50; - let mut result57 = _rt::Vec::with_capacity(len57); - for i in 0..len57 { - let base = base57 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e57 = { - let l51 = *base.add(0).cast::<*mut u8>(); - let l52 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len53 = l52; - let bytes53 = _rt::Vec::from_raw_parts( - l51.cast(), - len53, - len53, - ); - let l54 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l55 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len56 = l55; - let bytes56 = _rt::Vec::from_raw_parts( - l54.cast(), - len56, - len56, - ); - (_rt::string_lift(bytes53), _rt::string_lift(bytes56)) - }; - result57.push(e57); - } - _rt::cabi_dealloc( - base57, - len57 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes45), - version: _rt::string_lift(bytes48), - parameters: result57, - } - }; - result58.push(e58); - } - _rt::cabi_dealloc( - base58, - len58 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l59 = *base - .add(120 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l60 = *base - .add(120 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base67 = l59; - let len67 = l60; - let mut result67 = _rt::Vec::with_capacity(len67); - for i in 0..len67 { - let base = base67 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e67 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, - ); - let l64 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l65 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len66 = l65; - let bytes66 = _rt::Vec::from_raw_parts( - l64.cast(), - len66, - len66, - ); - (_rt::string_lift(bytes63), _rt::string_lift(bytes66)) - }; - result67.push(e67); - } - _rt::cabi_dealloc( - base67, - len67 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l68 = *base - .add(120 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l69 = *base - .add(120 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base175 = l68; - let len175 = l69; - let mut result175 = _rt::Vec::with_capacity(len175); - for i in 0..len175 { - let base = base175 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e175 = { - let l70 = *base.add(0).cast::<*mut u8>(); - let l71 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base75 = l70; - let len75 = l71; - let mut result75 = _rt::Vec::with_capacity(len75); - for i in 0..len75 { - let base = base75 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e75 = { - let l72 = *base.add(0).cast::<*mut u8>(); - let l73 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len74 = l73; - let bytes74 = _rt::Vec::from_raw_parts( - l72.cast(), - len74, - len74, - ); - _rt::string_lift(bytes74) - }; - result75.push(e75); - } - _rt::cabi_dealloc( - base75, - len75 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l76 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l77 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base123 = l76; - let len123 = l77; - let mut result123 = _rt::Vec::with_capacity(len123); - for i in 0..len123 { - let base = base123 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e123 = { - let l78 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V122; - let v122 = match l78 { - 0 => { - let e122 = { - let l79 = *base.add(8).cast::<*mut u8>(); - let l80 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len81 = l80; - _rt::Vec::from_raw_parts(l79.cast(), len81, len81) - }; - V122::RecordValue(e122) - } - 1 => { - let e122 = { - let l82 = *base.add(8).cast::(); - let l83 = i32::from(*base.add(12).cast::()); - ( - l82 as u32, - match l83 { - 0 => None, - 1 => { - let e = { - let l84 = *base.add(16).cast::(); - l84 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V122::VariantValue(e122) - } - 2 => { - let e122 = { - let l85 = *base.add(8).cast::(); - l85 as u32 - }; - V122::EnumValue(e122) - } - 3 => { - let e122 = { - let l86 = *base.add(8).cast::<*mut u8>(); - let l87 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base89 = l86; - let len89 = l87; - let mut result89 = _rt::Vec::with_capacity(len89); - for i in 0..len89 { - let base = base89.add(i * 1); - let e89 = { - let l88 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l88 as u8) - }; - result89.push(e89); - } - _rt::cabi_dealloc(base89, len89 * 1, 1); - result89 - }; - V122::FlagsValue(e122) - } - 4 => { - let e122 = { - let l90 = *base.add(8).cast::<*mut u8>(); - let l91 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len92 = l91; - _rt::Vec::from_raw_parts(l90.cast(), len92, len92) - }; - V122::TupleValue(e122) - } - 5 => { - let e122 = { - let l93 = *base.add(8).cast::<*mut u8>(); - let l94 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len95 = l94; - _rt::Vec::from_raw_parts(l93.cast(), len95, len95) - }; - V122::ListValue(e122) - } - 6 => { - let e122 = { - let l96 = i32::from(*base.add(8).cast::()); - match l96 { - 0 => None, - 1 => { - let e = { - let l97 = *base.add(12).cast::(); - l97 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V122::OptionValue(e122) - } - 7 => { - let e122 = { - let l98 = i32::from(*base.add(8).cast::()); - match l98 { - 0 => { - let e = { - let l99 = i32::from(*base.add(12).cast::()); - match l99 { - 0 => None, - 1 => { - let e = { - let l100 = *base.add(16).cast::(); - l100 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l101 = i32::from(*base.add(12).cast::()); - match l101 { - 0 => None, - 1 => { - let e = { - let l102 = *base.add(16).cast::(); - l102 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V122::ResultValue(e122) - } - 8 => { - let e122 = { - let l103 = i32::from(*base.add(8).cast::()); - l103 as u8 - }; - V122::PrimU8(e122) - } - 9 => { - let e122 = { - let l104 = i32::from(*base.add(8).cast::()); - l104 as u16 - }; - V122::PrimU16(e122) - } - 10 => { - let e122 = { - let l105 = *base.add(8).cast::(); - l105 as u32 - }; - V122::PrimU32(e122) - } - 11 => { - let e122 = { - let l106 = *base.add(8).cast::(); - l106 as u64 - }; - V122::PrimU64(e122) - } - 12 => { - let e122 = { - let l107 = i32::from(*base.add(8).cast::()); - l107 as i8 - }; - V122::PrimS8(e122) - } - 13 => { - let e122 = { - let l108 = i32::from(*base.add(8).cast::()); - l108 as i16 - }; - V122::PrimS16(e122) - } - 14 => { - let e122 = { - let l109 = *base.add(8).cast::(); - l109 - }; - V122::PrimS32(e122) - } - 15 => { - let e122 = { - let l110 = *base.add(8).cast::(); - l110 - }; - V122::PrimS64(e122) - } - 16 => { - let e122 = { - let l111 = *base.add(8).cast::(); - l111 - }; - V122::PrimFloat32(e122) - } - 17 => { - let e122 = { - let l112 = *base.add(8).cast::(); - l112 - }; - V122::PrimFloat64(e122) - } - 18 => { - let e122 = { - let l113 = *base.add(8).cast::(); - _rt::char_lift(l113 as u32) - }; - V122::PrimChar(e122) - } - 19 => { - let e122 = { - let l114 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l114 as u8) - }; - V122::PrimBool(e122) - } - 20 => { - let e122 = { - let l115 = *base.add(8).cast::<*mut u8>(); - let l116 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len117 = l116; - let bytes117 = _rt::Vec::from_raw_parts( - l115.cast(), - len117, - len117, - ); - _rt::string_lift(bytes117) - }; - V122::PrimString(e122) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e122 = { - let l118 = *base.add(8).cast::<*mut u8>(); - let l119 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len120 = l119; - let bytes120 = _rt::Vec::from_raw_parts( - l118.cast(), - len120, - len120, - ); - let l121 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes120), - }, - l121 as u64, - ) - }; - V122::Handle(e122) - } - }; - v122 - }; - result123.push(e123); - } - _rt::cabi_dealloc( - base123, - len123 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l124 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l125 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base174 = l124; - let len174 = l125; - let mut result174 = _rt::Vec::with_capacity(len174); - for i in 0..len174 { - let base = base174 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e174 = { - let l126 = i32::from(*base.add(0).cast::()); - let l130 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l134 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V173; - let v173 = match l134 { - 0 => { - let e173 = { - let l135 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l136 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base141 = l135; - let len141 = l136; - let mut result141 = _rt::Vec::with_capacity(len141); - for i in 0..len141 { - let base = base141 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e141 = { - let l137 = *base.add(0).cast::<*mut u8>(); - let l138 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len139 = l138; - let bytes139 = _rt::Vec::from_raw_parts( - l137.cast(), - len139, - len139, - ); - let l140 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes139), l140) - }; - result141.push(e141); - } - _rt::cabi_dealloc( - base141, - len141 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result141 - }; - V173::RecordType(e173) - } - 1 => { - let e173 = { - let l142 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l143 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base149 = l142; - let len149 = l143; - let mut result149 = _rt::Vec::with_capacity(len149); - for i in 0..len149 { - let base = base149 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e149 = { - let l144 = *base.add(0).cast::<*mut u8>(); - let l145 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len146 = l145; - let bytes146 = _rt::Vec::from_raw_parts( - l144.cast(), - len146, - len146, - ); - let l147 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes146), - match l147 { - 0 => None, - 1 => { - let e = { - let l148 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l148 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result149.push(e149); - } - _rt::cabi_dealloc( - base149, - len149 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result149 - }; - V173::VariantType(e173) - } - 2 => { - let e173 = { - let l150 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l151 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base155 = l150; - let len155 = l151; - let mut result155 = _rt::Vec::with_capacity(len155); - for i in 0..len155 { - let base = base155 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e155 = { - let l152 = *base.add(0).cast::<*mut u8>(); - let l153 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len154 = l153; - let bytes154 = _rt::Vec::from_raw_parts( - l152.cast(), - len154, - len154, - ); - _rt::string_lift(bytes154) - }; - result155.push(e155); - } - _rt::cabi_dealloc( - base155, - len155 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result155 - }; - V173::EnumType(e173) - } - 3 => { - let e173 = { - let l156 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l157 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base161 = l156; - let len161 = l157; - let mut result161 = _rt::Vec::with_capacity(len161); - for i in 0..len161 { - let base = base161 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e161 = { - let l158 = *base.add(0).cast::<*mut u8>(); - let l159 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len160 = l159; - let bytes160 = _rt::Vec::from_raw_parts( - l158.cast(), - len160, - len160, - ); - _rt::string_lift(bytes160) - }; - result161.push(e161); - } - _rt::cabi_dealloc( - base161, - len161 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result161 - }; - V173::FlagsType(e173) - } - 4 => { - let e173 = { - let l162 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l163 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len164 = l163; - _rt::Vec::from_raw_parts(l162.cast(), len164, len164) - }; - V173::TupleType(e173) - } - 5 => { - let e173 = { - let l165 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l165 - }; - V173::ListType(e173) - } - 6 => { - let e173 = { - let l166 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l166 - }; - V173::OptionType(e173) - } - 7 => { - let e173 = { - let l167 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l169 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l167 { - 0 => None, - 1 => { - let e = { - let l168 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l168 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l169 { - 0 => None, - 1 => { - let e = { - let l170 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l170 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V173::ResultType(e173) - } - 8 => V173::PrimU8Type, - 9 => V173::PrimU16Type, - 10 => V173::PrimU32Type, - 11 => V173::PrimU64Type, - 12 => V173::PrimS8Type, - 13 => V173::PrimS16Type, - 14 => V173::PrimS32Type, - 15 => V173::PrimS64Type, - 16 => V173::PrimF32Type, - 17 => V173::PrimF64Type, - 18 => V173::PrimCharType, - 19 => V173::PrimBoolType, - 20 => V173::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e173 = { - let l171 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l172 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l171 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l172 as u8, - ), - ) - }; - V173::HandleType(e173) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l126 { - 0 => None, - 1 => { - let e = { - let l127 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l128 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len129 = l128; - let bytes129 = _rt::Vec::from_raw_parts( - l127.cast(), - len129, - len129, - ); - _rt::string_lift(bytes129) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l130 { - 0 => None, - 1 => { - let e = { - let l131 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l132 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len133 = l132; - let bytes133 = _rt::Vec::from_raw_parts( - l131.cast(), - len133, - len133, - ); - _rt::string_lift(bytes133) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v173, - } - }; - result174.push(e174); - } - _rt::cabi_dealloc( - base174, - len174 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - LocalAgentConfigEntry { - path: result75, - value: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result123, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result174, - }, - }, - } - }; - result175.push(e175); - } - _rt::cabi_dealloc( - base175, - len175 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - CreateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l6 as u64, - nanoseconds: l7 as u32, - }, - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l8 as u64, - low_bits: l9 as u64, - }, - }, - agent_id: _rt::string_lift(bytes12), - }, - component_revision: l13 as u64, - args: result19, - env: result28, - created_by: super::super::super::golem::core::types::AccountId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l29 as u64, - low_bits: l30 as u64, - }, - }, - environment_id: super::super::super::golem::api::host::EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l31 as u64, - low_bits: l32 as u64, - }, - }, - parent: match l33 { - 0 => None, - 1 => { - let e = { - let l34 = *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l35 = *base - .add(96 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l36 = *base - .add(104 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l37 = *base - .add(104 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len38 = l37; - let bytes38 = _rt::Vec::from_raw_parts( - l36.cast(), - len38, - len38, - ); - super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l34 as u64, - low_bits: l35 as u64, - }, - }, - agent_id: _rt::string_lift(bytes38), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - component_size: l39 as u64, - initial_total_linear_memory_size: l40 as u64, - initial_active_plugins: result58, - config_vars: result67, - local_agent_config: result175, - } - }; - PublicOplogEntry::Create(e2675) - } - 1 => { - let e2675 = { - let l176 = *base.add(8).cast::(); - let l177 = *base.add(16).cast::(); - let l178 = *base.add(24).cast::<*mut u8>(); - let l179 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len180 = l179; - let bytes180 = _rt::Vec::from_raw_parts( - l178.cast(), - len180, - len180, - ); - let l181 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l182 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base228 = l181; - let len228 = l182; - let mut result228 = _rt::Vec::with_capacity(len228); - for i in 0..len228 { - let base = base228 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e228 = { - let l183 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V227; - let v227 = match l183 { - 0 => { - let e227 = { - let l184 = *base.add(8).cast::<*mut u8>(); - let l185 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len186 = l185; - _rt::Vec::from_raw_parts(l184.cast(), len186, len186) - }; - V227::RecordValue(e227) - } - 1 => { - let e227 = { - let l187 = *base.add(8).cast::(); - let l188 = i32::from(*base.add(12).cast::()); - ( - l187 as u32, - match l188 { - 0 => None, - 1 => { - let e = { - let l189 = *base.add(16).cast::(); - l189 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V227::VariantValue(e227) - } - 2 => { - let e227 = { - let l190 = *base.add(8).cast::(); - l190 as u32 - }; - V227::EnumValue(e227) - } - 3 => { - let e227 = { - let l191 = *base.add(8).cast::<*mut u8>(); - let l192 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base194 = l191; - let len194 = l192; - let mut result194 = _rt::Vec::with_capacity(len194); - for i in 0..len194 { - let base = base194.add(i * 1); - let e194 = { - let l193 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l193 as u8) - }; - result194.push(e194); - } - _rt::cabi_dealloc(base194, len194 * 1, 1); - result194 - }; - V227::FlagsValue(e227) - } - 4 => { - let e227 = { - let l195 = *base.add(8).cast::<*mut u8>(); - let l196 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len197 = l196; - _rt::Vec::from_raw_parts(l195.cast(), len197, len197) - }; - V227::TupleValue(e227) - } - 5 => { - let e227 = { - let l198 = *base.add(8).cast::<*mut u8>(); - let l199 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len200 = l199; - _rt::Vec::from_raw_parts(l198.cast(), len200, len200) - }; - V227::ListValue(e227) - } - 6 => { - let e227 = { - let l201 = i32::from(*base.add(8).cast::()); - match l201 { - 0 => None, - 1 => { - let e = { - let l202 = *base.add(12).cast::(); - l202 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V227::OptionValue(e227) - } - 7 => { - let e227 = { - let l203 = i32::from(*base.add(8).cast::()); - match l203 { - 0 => { - let e = { - let l204 = i32::from(*base.add(12).cast::()); - match l204 { - 0 => None, - 1 => { - let e = { - let l205 = *base.add(16).cast::(); - l205 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l206 = i32::from(*base.add(12).cast::()); - match l206 { - 0 => None, - 1 => { - let e = { - let l207 = *base.add(16).cast::(); - l207 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V227::ResultValue(e227) - } - 8 => { - let e227 = { - let l208 = i32::from(*base.add(8).cast::()); - l208 as u8 - }; - V227::PrimU8(e227) - } - 9 => { - let e227 = { - let l209 = i32::from(*base.add(8).cast::()); - l209 as u16 - }; - V227::PrimU16(e227) - } - 10 => { - let e227 = { - let l210 = *base.add(8).cast::(); - l210 as u32 - }; - V227::PrimU32(e227) - } - 11 => { - let e227 = { - let l211 = *base.add(8).cast::(); - l211 as u64 - }; - V227::PrimU64(e227) - } - 12 => { - let e227 = { - let l212 = i32::from(*base.add(8).cast::()); - l212 as i8 - }; - V227::PrimS8(e227) - } - 13 => { - let e227 = { - let l213 = i32::from(*base.add(8).cast::()); - l213 as i16 - }; - V227::PrimS16(e227) - } - 14 => { - let e227 = { - let l214 = *base.add(8).cast::(); - l214 - }; - V227::PrimS32(e227) - } - 15 => { - let e227 = { - let l215 = *base.add(8).cast::(); - l215 - }; - V227::PrimS64(e227) - } - 16 => { - let e227 = { - let l216 = *base.add(8).cast::(); - l216 - }; - V227::PrimFloat32(e227) - } - 17 => { - let e227 = { - let l217 = *base.add(8).cast::(); - l217 - }; - V227::PrimFloat64(e227) - } - 18 => { - let e227 = { - let l218 = *base.add(8).cast::(); - _rt::char_lift(l218 as u32) - }; - V227::PrimChar(e227) - } - 19 => { - let e227 = { - let l219 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l219 as u8) - }; - V227::PrimBool(e227) - } - 20 => { - let e227 = { - let l220 = *base.add(8).cast::<*mut u8>(); - let l221 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len222 = l221; - let bytes222 = _rt::Vec::from_raw_parts( - l220.cast(), - len222, - len222, - ); - _rt::string_lift(bytes222) - }; - V227::PrimString(e227) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e227 = { - let l223 = *base.add(8).cast::<*mut u8>(); - let l224 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len225 = l224; - let bytes225 = _rt::Vec::from_raw_parts( - l223.cast(), - len225, - len225, - ); - let l226 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes225), - }, - l226 as u64, - ) - }; - V227::Handle(e227) - } - }; - v227 - }; - result228.push(e228); - } - _rt::cabi_dealloc( - base228, - len228 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l229 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l230 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base279 = l229; - let len279 = l230; - let mut result279 = _rt::Vec::with_capacity(len279); - for i in 0..len279 { - let base = base279 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e279 = { - let l231 = i32::from(*base.add(0).cast::()); - let l235 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l239 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V278; - let v278 = match l239 { - 0 => { - let e278 = { - let l240 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l241 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base246 = l240; - let len246 = l241; - let mut result246 = _rt::Vec::with_capacity(len246); - for i in 0..len246 { - let base = base246 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e246 = { - let l242 = *base.add(0).cast::<*mut u8>(); - let l243 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len244 = l243; - let bytes244 = _rt::Vec::from_raw_parts( - l242.cast(), - len244, - len244, - ); - let l245 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes244), l245) - }; - result246.push(e246); - } - _rt::cabi_dealloc( - base246, - len246 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result246 - }; - V278::RecordType(e278) - } - 1 => { - let e278 = { - let l247 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l248 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base254 = l247; - let len254 = l248; - let mut result254 = _rt::Vec::with_capacity(len254); - for i in 0..len254 { - let base = base254 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e254 = { - let l249 = *base.add(0).cast::<*mut u8>(); - let l250 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len251 = l250; - let bytes251 = _rt::Vec::from_raw_parts( - l249.cast(), - len251, - len251, - ); - let l252 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes251), - match l252 { - 0 => None, - 1 => { - let e = { - let l253 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l253 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result254.push(e254); - } - _rt::cabi_dealloc( - base254, - len254 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result254 - }; - V278::VariantType(e278) - } - 2 => { - let e278 = { - let l255 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l256 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base260 = l255; - let len260 = l256; - let mut result260 = _rt::Vec::with_capacity(len260); - for i in 0..len260 { - let base = base260 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e260 = { - let l257 = *base.add(0).cast::<*mut u8>(); - let l258 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len259 = l258; - let bytes259 = _rt::Vec::from_raw_parts( - l257.cast(), - len259, - len259, - ); - _rt::string_lift(bytes259) - }; - result260.push(e260); - } - _rt::cabi_dealloc( - base260, - len260 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result260 - }; - V278::EnumType(e278) - } - 3 => { - let e278 = { - let l261 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l262 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base266 = l261; - let len266 = l262; - let mut result266 = _rt::Vec::with_capacity(len266); - for i in 0..len266 { - let base = base266 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e266 = { - let l263 = *base.add(0).cast::<*mut u8>(); - let l264 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len265 = l264; - let bytes265 = _rt::Vec::from_raw_parts( - l263.cast(), - len265, - len265, - ); - _rt::string_lift(bytes265) - }; - result266.push(e266); - } - _rt::cabi_dealloc( - base266, - len266 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result266 - }; - V278::FlagsType(e278) - } - 4 => { - let e278 = { - let l267 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l268 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len269 = l268; - _rt::Vec::from_raw_parts(l267.cast(), len269, len269) - }; - V278::TupleType(e278) - } - 5 => { - let e278 = { - let l270 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l270 - }; - V278::ListType(e278) - } - 6 => { - let e278 = { - let l271 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l271 - }; - V278::OptionType(e278) - } - 7 => { - let e278 = { - let l272 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l274 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l272 { - 0 => None, - 1 => { - let e = { - let l273 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l273 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l274 { - 0 => None, - 1 => { - let e = { - let l275 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l275 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V278::ResultType(e278) - } - 8 => V278::PrimU8Type, - 9 => V278::PrimU16Type, - 10 => V278::PrimU32Type, - 11 => V278::PrimU64Type, - 12 => V278::PrimS8Type, - 13 => V278::PrimS16Type, - 14 => V278::PrimS32Type, - 15 => V278::PrimS64Type, - 16 => V278::PrimF32Type, - 17 => V278::PrimF64Type, - 18 => V278::PrimCharType, - 19 => V278::PrimBoolType, - 20 => V278::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e278 = { - let l276 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l277 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l276 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l277 as u8, - ), - ) - }; - V278::HandleType(e278) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l231 { - 0 => None, - 1 => { - let e = { - let l232 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l233 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len234 = l233; - let bytes234 = _rt::Vec::from_raw_parts( - l232.cast(), - len234, - len234, - ); - _rt::string_lift(bytes234) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l235 { - 0 => None, - 1 => { - let e = { - let l236 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l237 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len238 = l237; - let bytes238 = _rt::Vec::from_raw_parts( - l236.cast(), - len238, - len238, - ); - _rt::string_lift(bytes238) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v278, - } - }; - result279.push(e279); - } - _rt::cabi_dealloc( - base279, - len279 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l280 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l281 = *base - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base327 = l280; - let len327 = l281; - let mut result327 = _rt::Vec::with_capacity(len327); - for i in 0..len327 { - let base = base327 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e327 = { - let l282 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V326; - let v326 = match l282 { - 0 => { - let e326 = { - let l283 = *base.add(8).cast::<*mut u8>(); - let l284 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len285 = l284; - _rt::Vec::from_raw_parts(l283.cast(), len285, len285) - }; - V326::RecordValue(e326) - } - 1 => { - let e326 = { - let l286 = *base.add(8).cast::(); - let l287 = i32::from(*base.add(12).cast::()); - ( - l286 as u32, - match l287 { - 0 => None, - 1 => { - let e = { - let l288 = *base.add(16).cast::(); - l288 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V326::VariantValue(e326) - } - 2 => { - let e326 = { - let l289 = *base.add(8).cast::(); - l289 as u32 - }; - V326::EnumValue(e326) - } - 3 => { - let e326 = { - let l290 = *base.add(8).cast::<*mut u8>(); - let l291 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base293 = l290; - let len293 = l291; - let mut result293 = _rt::Vec::with_capacity(len293); - for i in 0..len293 { - let base = base293.add(i * 1); - let e293 = { - let l292 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l292 as u8) - }; - result293.push(e293); - } - _rt::cabi_dealloc(base293, len293 * 1, 1); - result293 - }; - V326::FlagsValue(e326) - } - 4 => { - let e326 = { - let l294 = *base.add(8).cast::<*mut u8>(); - let l295 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len296 = l295; - _rt::Vec::from_raw_parts(l294.cast(), len296, len296) - }; - V326::TupleValue(e326) - } - 5 => { - let e326 = { - let l297 = *base.add(8).cast::<*mut u8>(); - let l298 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len299 = l298; - _rt::Vec::from_raw_parts(l297.cast(), len299, len299) - }; - V326::ListValue(e326) - } - 6 => { - let e326 = { - let l300 = i32::from(*base.add(8).cast::()); - match l300 { - 0 => None, - 1 => { - let e = { - let l301 = *base.add(12).cast::(); - l301 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V326::OptionValue(e326) - } - 7 => { - let e326 = { - let l302 = i32::from(*base.add(8).cast::()); - match l302 { - 0 => { - let e = { - let l303 = i32::from(*base.add(12).cast::()); - match l303 { - 0 => None, - 1 => { - let e = { - let l304 = *base.add(16).cast::(); - l304 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l305 = i32::from(*base.add(12).cast::()); - match l305 { - 0 => None, - 1 => { - let e = { - let l306 = *base.add(16).cast::(); - l306 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V326::ResultValue(e326) - } - 8 => { - let e326 = { - let l307 = i32::from(*base.add(8).cast::()); - l307 as u8 - }; - V326::PrimU8(e326) - } - 9 => { - let e326 = { - let l308 = i32::from(*base.add(8).cast::()); - l308 as u16 - }; - V326::PrimU16(e326) - } - 10 => { - let e326 = { - let l309 = *base.add(8).cast::(); - l309 as u32 - }; - V326::PrimU32(e326) - } - 11 => { - let e326 = { - let l310 = *base.add(8).cast::(); - l310 as u64 - }; - V326::PrimU64(e326) - } - 12 => { - let e326 = { - let l311 = i32::from(*base.add(8).cast::()); - l311 as i8 - }; - V326::PrimS8(e326) - } - 13 => { - let e326 = { - let l312 = i32::from(*base.add(8).cast::()); - l312 as i16 - }; - V326::PrimS16(e326) - } - 14 => { - let e326 = { - let l313 = *base.add(8).cast::(); - l313 - }; - V326::PrimS32(e326) - } - 15 => { - let e326 = { - let l314 = *base.add(8).cast::(); - l314 - }; - V326::PrimS64(e326) - } - 16 => { - let e326 = { - let l315 = *base.add(8).cast::(); - l315 - }; - V326::PrimFloat32(e326) - } - 17 => { - let e326 = { - let l316 = *base.add(8).cast::(); - l316 - }; - V326::PrimFloat64(e326) - } - 18 => { - let e326 = { - let l317 = *base.add(8).cast::(); - _rt::char_lift(l317 as u32) - }; - V326::PrimChar(e326) - } - 19 => { - let e326 = { - let l318 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l318 as u8) - }; - V326::PrimBool(e326) - } - 20 => { - let e326 = { - let l319 = *base.add(8).cast::<*mut u8>(); - let l320 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len321 = l320; - let bytes321 = _rt::Vec::from_raw_parts( - l319.cast(), - len321, - len321, - ); - _rt::string_lift(bytes321) - }; - V326::PrimString(e326) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e326 = { - let l322 = *base.add(8).cast::<*mut u8>(); - let l323 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len324 = l323; - let bytes324 = _rt::Vec::from_raw_parts( - l322.cast(), - len324, - len324, - ); - let l325 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes324), - }, - l325 as u64, - ) - }; - V326::Handle(e326) - } - }; - v326 - }; - result327.push(e327); - } - _rt::cabi_dealloc( - base327, - len327 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l328 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l329 = *base - .add(24 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base378 = l328; - let len378 = l329; - let mut result378 = _rt::Vec::with_capacity(len378); - for i in 0..len378 { - let base = base378 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e378 = { - let l330 = i32::from(*base.add(0).cast::()); - let l334 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l338 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V377; - let v377 = match l338 { - 0 => { - let e377 = { - let l339 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l340 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base345 = l339; - let len345 = l340; - let mut result345 = _rt::Vec::with_capacity(len345); - for i in 0..len345 { - let base = base345 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e345 = { - let l341 = *base.add(0).cast::<*mut u8>(); - let l342 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len343 = l342; - let bytes343 = _rt::Vec::from_raw_parts( - l341.cast(), - len343, - len343, - ); - let l344 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes343), l344) - }; - result345.push(e345); - } - _rt::cabi_dealloc( - base345, - len345 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result345 - }; - V377::RecordType(e377) - } - 1 => { - let e377 = { - let l346 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l347 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base353 = l346; - let len353 = l347; - let mut result353 = _rt::Vec::with_capacity(len353); - for i in 0..len353 { - let base = base353 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e353 = { - let l348 = *base.add(0).cast::<*mut u8>(); - let l349 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len350 = l349; - let bytes350 = _rt::Vec::from_raw_parts( - l348.cast(), - len350, - len350, - ); - let l351 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes350), - match l351 { - 0 => None, - 1 => { - let e = { - let l352 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l352 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result353.push(e353); - } - _rt::cabi_dealloc( - base353, - len353 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result353 - }; - V377::VariantType(e377) - } - 2 => { - let e377 = { - let l354 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l355 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base359 = l354; - let len359 = l355; - let mut result359 = _rt::Vec::with_capacity(len359); - for i in 0..len359 { - let base = base359 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e359 = { - let l356 = *base.add(0).cast::<*mut u8>(); - let l357 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len358 = l357; - let bytes358 = _rt::Vec::from_raw_parts( - l356.cast(), - len358, - len358, - ); - _rt::string_lift(bytes358) - }; - result359.push(e359); - } - _rt::cabi_dealloc( - base359, - len359 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result359 - }; - V377::EnumType(e377) - } - 3 => { - let e377 = { - let l360 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l361 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base365 = l360; - let len365 = l361; - let mut result365 = _rt::Vec::with_capacity(len365); - for i in 0..len365 { - let base = base365 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e365 = { - let l362 = *base.add(0).cast::<*mut u8>(); - let l363 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len364 = l363; - let bytes364 = _rt::Vec::from_raw_parts( - l362.cast(), - len364, - len364, - ); - _rt::string_lift(bytes364) - }; - result365.push(e365); - } - _rt::cabi_dealloc( - base365, - len365 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result365 - }; - V377::FlagsType(e377) - } - 4 => { - let e377 = { - let l366 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l367 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len368 = l367; - _rt::Vec::from_raw_parts(l366.cast(), len368, len368) - }; - V377::TupleType(e377) - } - 5 => { - let e377 = { - let l369 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l369 - }; - V377::ListType(e377) - } - 6 => { - let e377 = { - let l370 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l370 - }; - V377::OptionType(e377) - } - 7 => { - let e377 = { - let l371 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l373 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l371 { - 0 => None, - 1 => { - let e = { - let l372 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l372 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l373 { - 0 => None, - 1 => { - let e = { - let l374 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l374 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V377::ResultType(e377) - } - 8 => V377::PrimU8Type, - 9 => V377::PrimU16Type, - 10 => V377::PrimU32Type, - 11 => V377::PrimU64Type, - 12 => V377::PrimS8Type, - 13 => V377::PrimS16Type, - 14 => V377::PrimS32Type, - 15 => V377::PrimS64Type, - 16 => V377::PrimF32Type, - 17 => V377::PrimF64Type, - 18 => V377::PrimCharType, - 19 => V377::PrimBoolType, - 20 => V377::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e377 = { - let l375 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l376 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l375 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l376 as u8, - ), - ) - }; - V377::HandleType(e377) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l330 { - 0 => None, - 1 => { - let e = { - let l331 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l332 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len333 = l332; - let bytes333 = _rt::Vec::from_raw_parts( - l331.cast(), - len333, - len333, - ); - _rt::string_lift(bytes333) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l334 { - 0 => None, - 1 => { - let e = { - let l335 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l336 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len337 = l336; - let bytes337 = _rt::Vec::from_raw_parts( - l335.cast(), - len337, - len337, - ); - _rt::string_lift(bytes337) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v377, - } - }; - result378.push(e378); - } - _rt::cabi_dealloc( - base378, - len378 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l379 = i32::from( - *base - .add(24 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let v384 = match l379 { - 0 => WrappedFunctionType::ReadLocal, - 1 => WrappedFunctionType::WriteLocal, - 2 => WrappedFunctionType::ReadRemote, - 3 => WrappedFunctionType::WriteRemote, - 4 => { - let e384 = { - let l380 = i32::from( - *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l380 { - 0 => None, - 1 => { - let e = { - let l381 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l381 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteBatched(e384) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e384 = { - let l382 = i32::from( - *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l382 { - 0 => None, - 1 => { - let e = { - let l383 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l383 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteTransaction(e384) - } - }; - HostCallParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l176 as u64, - nanoseconds: l177 as u32, - }, - function_name: _rt::string_lift(bytes180), - request: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result228, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result279, - }, - }, - response: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result327, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result378, - }, - }, - wrapped_function_type: v384, - } - }; - PublicOplogEntry::HostCall(e2675) - } - 2 => { - let e2675 = { - let l385 = *base.add(8).cast::(); - let l386 = *base.add(16).cast::(); - let l387 = i32::from(*base.add(24).cast::()); - let v1103 = match l387 { - 0 => { - let e1103 = { - let l388 = *base.add(32).cast::<*mut u8>(); - let l389 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len390 = l389; - let bytes390 = _rt::Vec::from_raw_parts( - l388.cast(), - len390, - len390, - ); - let l391 = i32::from( - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V547; - let v547 = match l391 { - 0 => { - let e547 = { - let l392 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l393 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base467 = l392; - let len467 = l393; - let mut result467 = _rt::Vec::with_capacity(len467); - for i in 0..len467 { - let base = base467 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e467 = { - let l394 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V466; - let v466 = match l394 { - 0 => { - let e466 = { - let l395 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l396 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base442 = l395; - let len442 = l396; - let mut result442 = _rt::Vec::with_capacity(len442); - for i in 0..len442 { - let base = base442 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e442 = { - let l397 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V441; - let v441 = match l397 { - 0 => { - let e441 = { - let l398 = *base.add(8).cast::<*mut u8>(); - let l399 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len400 = l399; - _rt::Vec::from_raw_parts(l398.cast(), len400, len400) - }; - V441::RecordValue(e441) - } - 1 => { - let e441 = { - let l401 = *base.add(8).cast::(); - let l402 = i32::from(*base.add(12).cast::()); - ( - l401 as u32, - match l402 { - 0 => None, - 1 => { - let e = { - let l403 = *base.add(16).cast::(); - l403 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V441::VariantValue(e441) - } - 2 => { - let e441 = { - let l404 = *base.add(8).cast::(); - l404 as u32 - }; - V441::EnumValue(e441) - } - 3 => { - let e441 = { - let l405 = *base.add(8).cast::<*mut u8>(); - let l406 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base408 = l405; - let len408 = l406; - let mut result408 = _rt::Vec::with_capacity(len408); - for i in 0..len408 { - let base = base408.add(i * 1); - let e408 = { - let l407 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l407 as u8) - }; - result408.push(e408); - } - _rt::cabi_dealloc(base408, len408 * 1, 1); - result408 - }; - V441::FlagsValue(e441) - } - 4 => { - let e441 = { - let l409 = *base.add(8).cast::<*mut u8>(); - let l410 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len411 = l410; - _rt::Vec::from_raw_parts(l409.cast(), len411, len411) - }; - V441::TupleValue(e441) - } - 5 => { - let e441 = { - let l412 = *base.add(8).cast::<*mut u8>(); - let l413 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len414 = l413; - _rt::Vec::from_raw_parts(l412.cast(), len414, len414) - }; - V441::ListValue(e441) - } - 6 => { - let e441 = { - let l415 = i32::from(*base.add(8).cast::()); - match l415 { - 0 => None, - 1 => { - let e = { - let l416 = *base.add(12).cast::(); - l416 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V441::OptionValue(e441) - } - 7 => { - let e441 = { - let l417 = i32::from(*base.add(8).cast::()); - match l417 { - 0 => { - let e = { - let l418 = i32::from(*base.add(12).cast::()); - match l418 { - 0 => None, - 1 => { - let e = { - let l419 = *base.add(16).cast::(); - l419 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l420 = i32::from(*base.add(12).cast::()); - match l420 { - 0 => None, - 1 => { - let e = { - let l421 = *base.add(16).cast::(); - l421 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V441::ResultValue(e441) - } - 8 => { - let e441 = { - let l422 = i32::from(*base.add(8).cast::()); - l422 as u8 - }; - V441::PrimU8(e441) - } - 9 => { - let e441 = { - let l423 = i32::from(*base.add(8).cast::()); - l423 as u16 - }; - V441::PrimU16(e441) - } - 10 => { - let e441 = { - let l424 = *base.add(8).cast::(); - l424 as u32 - }; - V441::PrimU32(e441) - } - 11 => { - let e441 = { - let l425 = *base.add(8).cast::(); - l425 as u64 - }; - V441::PrimU64(e441) - } - 12 => { - let e441 = { - let l426 = i32::from(*base.add(8).cast::()); - l426 as i8 - }; - V441::PrimS8(e441) - } - 13 => { - let e441 = { - let l427 = i32::from(*base.add(8).cast::()); - l427 as i16 - }; - V441::PrimS16(e441) - } - 14 => { - let e441 = { - let l428 = *base.add(8).cast::(); - l428 - }; - V441::PrimS32(e441) - } - 15 => { - let e441 = { - let l429 = *base.add(8).cast::(); - l429 - }; - V441::PrimS64(e441) - } - 16 => { - let e441 = { - let l430 = *base.add(8).cast::(); - l430 - }; - V441::PrimFloat32(e441) - } - 17 => { - let e441 = { - let l431 = *base.add(8).cast::(); - l431 - }; - V441::PrimFloat64(e441) - } - 18 => { - let e441 = { - let l432 = *base.add(8).cast::(); - _rt::char_lift(l432 as u32) - }; - V441::PrimChar(e441) - } - 19 => { - let e441 = { - let l433 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l433 as u8) - }; - V441::PrimBool(e441) - } - 20 => { - let e441 = { - let l434 = *base.add(8).cast::<*mut u8>(); - let l435 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len436 = l435; - let bytes436 = _rt::Vec::from_raw_parts( - l434.cast(), - len436, - len436, - ); - _rt::string_lift(bytes436) - }; - V441::PrimString(e441) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e441 = { - let l437 = *base.add(8).cast::<*mut u8>(); - let l438 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len439 = l438; - let bytes439 = _rt::Vec::from_raw_parts( - l437.cast(), - len439, - len439, - ); - let l440 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes439), - }, - l440 as u64, - ) - }; - V441::Handle(e441) - } - }; - v441 - }; - result442.push(e442); - } - _rt::cabi_dealloc( - base442, - len442 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result442, - } - }; - V466::ComponentModel(e466) - } - 1 => { - let e466 = { - let l443 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V454; - let v454 = match l443 { - 0 => { - let e454 = { - let l444 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l445 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len446 = l445; - let bytes446 = _rt::Vec::from_raw_parts( - l444.cast(), - len446, - len446, - ); - _rt::string_lift(bytes446) - }; - V454::Url(e454) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e454 = { - let l447 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l448 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len449 = l448; - let bytes449 = _rt::Vec::from_raw_parts( - l447.cast(), - len449, - len449, - ); - let l450 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes449), - text_type: match l450 { - 0 => None, - 1 => { - let e = { - let l451 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l452 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len453 = l452; - let bytes453 = _rt::Vec::from_raw_parts( - l451.cast(), - len453, - len453, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes453), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V454::Inline(e454) - } - }; - v454 - }; - V466::UnstructuredText(e466) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e466 = { - let l455 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V465; - let v465 = match l455 { - 0 => { - let e465 = { - let l456 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l457 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len458 = l457; - let bytes458 = _rt::Vec::from_raw_parts( - l456.cast(), - len458, - len458, - ); - _rt::string_lift(bytes458) - }; - V465::Url(e465) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e465 = { - let l459 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l460 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len461 = l460; - let l462 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l463 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len464 = l463; - let bytes464 = _rt::Vec::from_raw_parts( - l462.cast(), - len464, - len464, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l459.cast(), len461, len461), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes464), - }, - } - }; - V465::Inline(e465) - } - }; - v465 - }; - V466::UnstructuredBinary(e466) - } - }; - v466 - }; - result467.push(e467); - } - _rt::cabi_dealloc( - base467, - len467 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result467 - }; - V547::Tuple(e547) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e547 = { - let l468 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l469 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base546 = l468; - let len546 = l469; - let mut result546 = _rt::Vec::with_capacity(len546); - for i in 0..len546 { - let base = base546 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e546 = { - let l470 = *base.add(0).cast::<*mut u8>(); - let l471 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len472 = l471; - let bytes472 = _rt::Vec::from_raw_parts( - l470.cast(), - len472, - len472, - ); - let l473 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V545; - let v545 = match l473 { - 0 => { - let e545 = { - let l474 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l475 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base521 = l474; - let len521 = l475; - let mut result521 = _rt::Vec::with_capacity(len521); - for i in 0..len521 { - let base = base521 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e521 = { - let l476 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V520; - let v520 = match l476 { - 0 => { - let e520 = { - let l477 = *base.add(8).cast::<*mut u8>(); - let l478 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len479 = l478; - _rt::Vec::from_raw_parts(l477.cast(), len479, len479) - }; - V520::RecordValue(e520) - } - 1 => { - let e520 = { - let l480 = *base.add(8).cast::(); - let l481 = i32::from(*base.add(12).cast::()); - ( - l480 as u32, - match l481 { - 0 => None, - 1 => { - let e = { - let l482 = *base.add(16).cast::(); - l482 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V520::VariantValue(e520) - } - 2 => { - let e520 = { - let l483 = *base.add(8).cast::(); - l483 as u32 - }; - V520::EnumValue(e520) - } - 3 => { - let e520 = { - let l484 = *base.add(8).cast::<*mut u8>(); - let l485 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base487 = l484; - let len487 = l485; - let mut result487 = _rt::Vec::with_capacity(len487); - for i in 0..len487 { - let base = base487.add(i * 1); - let e487 = { - let l486 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l486 as u8) - }; - result487.push(e487); - } - _rt::cabi_dealloc(base487, len487 * 1, 1); - result487 - }; - V520::FlagsValue(e520) - } - 4 => { - let e520 = { - let l488 = *base.add(8).cast::<*mut u8>(); - let l489 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len490 = l489; - _rt::Vec::from_raw_parts(l488.cast(), len490, len490) - }; - V520::TupleValue(e520) - } - 5 => { - let e520 = { - let l491 = *base.add(8).cast::<*mut u8>(); - let l492 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len493 = l492; - _rt::Vec::from_raw_parts(l491.cast(), len493, len493) - }; - V520::ListValue(e520) - } - 6 => { - let e520 = { - let l494 = i32::from(*base.add(8).cast::()); - match l494 { - 0 => None, - 1 => { - let e = { - let l495 = *base.add(12).cast::(); - l495 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V520::OptionValue(e520) - } - 7 => { - let e520 = { - let l496 = i32::from(*base.add(8).cast::()); - match l496 { - 0 => { - let e = { - let l497 = i32::from(*base.add(12).cast::()); - match l497 { - 0 => None, - 1 => { - let e = { - let l498 = *base.add(16).cast::(); - l498 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l499 = i32::from(*base.add(12).cast::()); - match l499 { - 0 => None, - 1 => { - let e = { - let l500 = *base.add(16).cast::(); - l500 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V520::ResultValue(e520) - } - 8 => { - let e520 = { - let l501 = i32::from(*base.add(8).cast::()); - l501 as u8 - }; - V520::PrimU8(e520) - } - 9 => { - let e520 = { - let l502 = i32::from(*base.add(8).cast::()); - l502 as u16 - }; - V520::PrimU16(e520) - } - 10 => { - let e520 = { - let l503 = *base.add(8).cast::(); - l503 as u32 - }; - V520::PrimU32(e520) - } - 11 => { - let e520 = { - let l504 = *base.add(8).cast::(); - l504 as u64 - }; - V520::PrimU64(e520) - } - 12 => { - let e520 = { - let l505 = i32::from(*base.add(8).cast::()); - l505 as i8 - }; - V520::PrimS8(e520) - } - 13 => { - let e520 = { - let l506 = i32::from(*base.add(8).cast::()); - l506 as i16 - }; - V520::PrimS16(e520) - } - 14 => { - let e520 = { - let l507 = *base.add(8).cast::(); - l507 - }; - V520::PrimS32(e520) - } - 15 => { - let e520 = { - let l508 = *base.add(8).cast::(); - l508 - }; - V520::PrimS64(e520) - } - 16 => { - let e520 = { - let l509 = *base.add(8).cast::(); - l509 - }; - V520::PrimFloat32(e520) - } - 17 => { - let e520 = { - let l510 = *base.add(8).cast::(); - l510 - }; - V520::PrimFloat64(e520) - } - 18 => { - let e520 = { - let l511 = *base.add(8).cast::(); - _rt::char_lift(l511 as u32) - }; - V520::PrimChar(e520) - } - 19 => { - let e520 = { - let l512 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l512 as u8) - }; - V520::PrimBool(e520) - } - 20 => { - let e520 = { - let l513 = *base.add(8).cast::<*mut u8>(); - let l514 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len515 = l514; - let bytes515 = _rt::Vec::from_raw_parts( - l513.cast(), - len515, - len515, - ); - _rt::string_lift(bytes515) - }; - V520::PrimString(e520) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e520 = { - let l516 = *base.add(8).cast::<*mut u8>(); - let l517 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len518 = l517; - let bytes518 = _rt::Vec::from_raw_parts( - l516.cast(), - len518, - len518, - ); - let l519 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes518), - }, - l519 as u64, - ) - }; - V520::Handle(e520) - } - }; - v520 - }; - result521.push(e521); - } - _rt::cabi_dealloc( - base521, - len521 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result521, - } - }; - V545::ComponentModel(e545) - } - 1 => { - let e545 = { - let l522 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V533; - let v533 = match l522 { - 0 => { - let e533 = { - let l523 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l524 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len525 = l524; - let bytes525 = _rt::Vec::from_raw_parts( - l523.cast(), - len525, - len525, - ); - _rt::string_lift(bytes525) - }; - V533::Url(e533) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e533 = { - let l526 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l527 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len528 = l527; - let bytes528 = _rt::Vec::from_raw_parts( - l526.cast(), - len528, - len528, - ); - let l529 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes528), - text_type: match l529 { - 0 => None, - 1 => { - let e = { - let l530 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l531 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len532 = l531; - let bytes532 = _rt::Vec::from_raw_parts( - l530.cast(), - len532, - len532, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes532), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V533::Inline(e533) - } - }; - v533 - }; - V545::UnstructuredText(e545) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e545 = { - let l534 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V544; - let v544 = match l534 { - 0 => { - let e544 = { - let l535 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l536 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len537 = l536; - let bytes537 = _rt::Vec::from_raw_parts( - l535.cast(), - len537, - len537, - ); - _rt::string_lift(bytes537) - }; - V544::Url(e544) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e544 = { - let l538 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l539 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len540 = l539; - let l541 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l542 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len543 = l542; - let bytes543 = _rt::Vec::from_raw_parts( - l541.cast(), - len543, - len543, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l538.cast(), len540, len540), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes543), - }, - } - }; - V544::Inline(e544) - } - }; - v544 - }; - V545::UnstructuredBinary(e545) - } - }; - (_rt::string_lift(bytes472), v545) - }; - result546.push(e546); - } - _rt::cabi_dealloc( - base546, - len546 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result546 - }; - V547::Multimodal(e547) - } - }; - let l548 = i32::from( - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V695; - let v695 = match l548 { - 0 => { - let e695 = { - let l549 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l550 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base621 = l549; - let len621 = l550; - let mut result621 = _rt::Vec::with_capacity(len621); - for i in 0..len621 { - let base = base621 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e621 = { - let l551 = *base.add(0).cast::<*mut u8>(); - let l552 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len553 = l552; - let bytes553 = _rt::Vec::from_raw_parts( - l551.cast(), - len553, - len553, - ); - let l554 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V620; - let v620 = match l554 { - 0 => { - let e620 = { - let l555 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l556 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base605 = l555; - let len605 = l556; - let mut result605 = _rt::Vec::with_capacity(len605); - for i in 0..len605 { - let base = base605 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e605 = { - let l557 = i32::from(*base.add(0).cast::()); - let l561 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l565 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V604; - let v604 = match l565 { - 0 => { - let e604 = { - let l566 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l567 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base572 = l566; - let len572 = l567; - let mut result572 = _rt::Vec::with_capacity(len572); - for i in 0..len572 { - let base = base572 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e572 = { - let l568 = *base.add(0).cast::<*mut u8>(); - let l569 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len570 = l569; - let bytes570 = _rt::Vec::from_raw_parts( - l568.cast(), - len570, - len570, - ); - let l571 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes570), l571) - }; - result572.push(e572); - } - _rt::cabi_dealloc( - base572, - len572 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result572 - }; - V604::RecordType(e604) - } - 1 => { - let e604 = { - let l573 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l574 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base580 = l573; - let len580 = l574; - let mut result580 = _rt::Vec::with_capacity(len580); - for i in 0..len580 { - let base = base580 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e580 = { - let l575 = *base.add(0).cast::<*mut u8>(); - let l576 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len577 = l576; - let bytes577 = _rt::Vec::from_raw_parts( - l575.cast(), - len577, - len577, - ); - let l578 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes577), - match l578 { - 0 => None, - 1 => { - let e = { - let l579 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l579 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result580.push(e580); - } - _rt::cabi_dealloc( - base580, - len580 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result580 - }; - V604::VariantType(e604) - } - 2 => { - let e604 = { - let l581 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l582 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base586 = l581; - let len586 = l582; - let mut result586 = _rt::Vec::with_capacity(len586); - for i in 0..len586 { - let base = base586 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e586 = { - let l583 = *base.add(0).cast::<*mut u8>(); - let l584 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len585 = l584; - let bytes585 = _rt::Vec::from_raw_parts( - l583.cast(), - len585, - len585, - ); - _rt::string_lift(bytes585) - }; - result586.push(e586); - } - _rt::cabi_dealloc( - base586, - len586 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result586 - }; - V604::EnumType(e604) - } - 3 => { - let e604 = { - let l587 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l588 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base592 = l587; - let len592 = l588; - let mut result592 = _rt::Vec::with_capacity(len592); - for i in 0..len592 { - let base = base592 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e592 = { - let l589 = *base.add(0).cast::<*mut u8>(); - let l590 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len591 = l590; - let bytes591 = _rt::Vec::from_raw_parts( - l589.cast(), - len591, - len591, - ); - _rt::string_lift(bytes591) - }; - result592.push(e592); - } - _rt::cabi_dealloc( - base592, - len592 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result592 - }; - V604::FlagsType(e604) - } - 4 => { - let e604 = { - let l593 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l594 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len595 = l594; - _rt::Vec::from_raw_parts(l593.cast(), len595, len595) - }; - V604::TupleType(e604) - } - 5 => { - let e604 = { - let l596 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l596 - }; - V604::ListType(e604) - } - 6 => { - let e604 = { - let l597 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l597 - }; - V604::OptionType(e604) - } - 7 => { - let e604 = { - let l598 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l600 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l598 { - 0 => None, - 1 => { - let e = { - let l599 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l599 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l600 { - 0 => None, - 1 => { - let e = { - let l601 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l601 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V604::ResultType(e604) - } - 8 => V604::PrimU8Type, - 9 => V604::PrimU16Type, - 10 => V604::PrimU32Type, - 11 => V604::PrimU64Type, - 12 => V604::PrimS8Type, - 13 => V604::PrimS16Type, - 14 => V604::PrimS32Type, - 15 => V604::PrimS64Type, - 16 => V604::PrimF32Type, - 17 => V604::PrimF64Type, - 18 => V604::PrimCharType, - 19 => V604::PrimBoolType, - 20 => V604::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e604 = { - let l602 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l603 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l602 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l603 as u8, - ), - ) - }; - V604::HandleType(e604) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l557 { - 0 => None, - 1 => { - let e = { - let l558 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l559 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len560 = l559; - let bytes560 = _rt::Vec::from_raw_parts( - l558.cast(), - len560, - len560, - ); - _rt::string_lift(bytes560) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l561 { - 0 => None, - 1 => { - let e = { - let l562 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l563 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len564 = l563; - let bytes564 = _rt::Vec::from_raw_parts( - l562.cast(), - len564, - len564, - ); - _rt::string_lift(bytes564) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v604, - } - }; - result605.push(e605); - } - _rt::cabi_dealloc( - base605, - len605 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result605, - } - }; - V620::ComponentModel(e620) - } - 1 => { - let e620 = { - let l606 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l606 { - 0 => None, - 1 => { - let e = { - let l607 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l608 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base612 = l607; - let len612 = l608; - let mut result612 = _rt::Vec::with_capacity(len612); - for i in 0..len612 { - let base = base612 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e612 = { - let l609 = *base.add(0).cast::<*mut u8>(); - let l610 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len611 = l610; - let bytes611 = _rt::Vec::from_raw_parts( - l609.cast(), - len611, - len611, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes611), - } - }; - result612.push(e612); - } - _rt::cabi_dealloc( - base612, - len612 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result612 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V620::UnstructuredText(e620) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e620 = { - let l613 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l613 { - 0 => None, - 1 => { - let e = { - let l614 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l615 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base619 = l614; - let len619 = l615; - let mut result619 = _rt::Vec::with_capacity(len619); - for i in 0..len619 { - let base = base619 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e619 = { - let l616 = *base.add(0).cast::<*mut u8>(); - let l617 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len618 = l617; - let bytes618 = _rt::Vec::from_raw_parts( - l616.cast(), - len618, - len618, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes618), - } - }; - result619.push(e619); - } - _rt::cabi_dealloc( - base619, - len619 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result619 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V620::UnstructuredBinary(e620) - } - }; - (_rt::string_lift(bytes553), v620) - }; - result621.push(e621); - } - _rt::cabi_dealloc( - base621, - len621 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result621 - }; - V695::Tuple(e695) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e695 = { - let l622 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l623 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base694 = l622; - let len694 = l623; - let mut result694 = _rt::Vec::with_capacity(len694); - for i in 0..len694 { - let base = base694 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e694 = { - let l624 = *base.add(0).cast::<*mut u8>(); - let l625 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len626 = l625; - let bytes626 = _rt::Vec::from_raw_parts( - l624.cast(), - len626, - len626, - ); - let l627 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V693; - let v693 = match l627 { - 0 => { - let e693 = { - let l628 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l629 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base678 = l628; - let len678 = l629; - let mut result678 = _rt::Vec::with_capacity(len678); - for i in 0..len678 { - let base = base678 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e678 = { - let l630 = i32::from(*base.add(0).cast::()); - let l634 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l638 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V677; - let v677 = match l638 { - 0 => { - let e677 = { - let l639 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l640 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base645 = l639; - let len645 = l640; - let mut result645 = _rt::Vec::with_capacity(len645); - for i in 0..len645 { - let base = base645 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e645 = { - let l641 = *base.add(0).cast::<*mut u8>(); - let l642 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len643 = l642; - let bytes643 = _rt::Vec::from_raw_parts( - l641.cast(), - len643, - len643, - ); - let l644 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes643), l644) - }; - result645.push(e645); - } - _rt::cabi_dealloc( - base645, - len645 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result645 - }; - V677::RecordType(e677) - } - 1 => { - let e677 = { - let l646 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l647 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base653 = l646; - let len653 = l647; - let mut result653 = _rt::Vec::with_capacity(len653); - for i in 0..len653 { - let base = base653 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e653 = { - let l648 = *base.add(0).cast::<*mut u8>(); - let l649 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len650 = l649; - let bytes650 = _rt::Vec::from_raw_parts( - l648.cast(), - len650, - len650, - ); - let l651 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes650), - match l651 { - 0 => None, - 1 => { - let e = { - let l652 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l652 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result653.push(e653); - } - _rt::cabi_dealloc( - base653, - len653 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result653 - }; - V677::VariantType(e677) - } - 2 => { - let e677 = { - let l654 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l655 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base659 = l654; - let len659 = l655; - let mut result659 = _rt::Vec::with_capacity(len659); - for i in 0..len659 { - let base = base659 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e659 = { - let l656 = *base.add(0).cast::<*mut u8>(); - let l657 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len658 = l657; - let bytes658 = _rt::Vec::from_raw_parts( - l656.cast(), - len658, - len658, - ); - _rt::string_lift(bytes658) - }; - result659.push(e659); - } - _rt::cabi_dealloc( - base659, - len659 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result659 - }; - V677::EnumType(e677) - } - 3 => { - let e677 = { - let l660 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l661 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base665 = l660; - let len665 = l661; - let mut result665 = _rt::Vec::with_capacity(len665); - for i in 0..len665 { - let base = base665 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e665 = { - let l662 = *base.add(0).cast::<*mut u8>(); - let l663 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len664 = l663; - let bytes664 = _rt::Vec::from_raw_parts( - l662.cast(), - len664, - len664, - ); - _rt::string_lift(bytes664) - }; - result665.push(e665); - } - _rt::cabi_dealloc( - base665, - len665 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result665 - }; - V677::FlagsType(e677) - } - 4 => { - let e677 = { - let l666 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l667 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len668 = l667; - _rt::Vec::from_raw_parts(l666.cast(), len668, len668) - }; - V677::TupleType(e677) - } - 5 => { - let e677 = { - let l669 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l669 - }; - V677::ListType(e677) - } - 6 => { - let e677 = { - let l670 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l670 - }; - V677::OptionType(e677) - } - 7 => { - let e677 = { - let l671 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l673 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l671 { - 0 => None, - 1 => { - let e = { - let l672 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l672 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l673 { - 0 => None, - 1 => { - let e = { - let l674 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l674 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V677::ResultType(e677) - } - 8 => V677::PrimU8Type, - 9 => V677::PrimU16Type, - 10 => V677::PrimU32Type, - 11 => V677::PrimU64Type, - 12 => V677::PrimS8Type, - 13 => V677::PrimS16Type, - 14 => V677::PrimS32Type, - 15 => V677::PrimS64Type, - 16 => V677::PrimF32Type, - 17 => V677::PrimF64Type, - 18 => V677::PrimCharType, - 19 => V677::PrimBoolType, - 20 => V677::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e677 = { - let l675 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l676 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l675 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l676 as u8, - ), - ) - }; - V677::HandleType(e677) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l630 { - 0 => None, - 1 => { - let e = { - let l631 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l632 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len633 = l632; - let bytes633 = _rt::Vec::from_raw_parts( - l631.cast(), - len633, - len633, - ); - _rt::string_lift(bytes633) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l634 { - 0 => None, - 1 => { - let e = { - let l635 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l636 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len637 = l636; - let bytes637 = _rt::Vec::from_raw_parts( - l635.cast(), - len637, - len637, - ); - _rt::string_lift(bytes637) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v677, - } - }; - result678.push(e678); - } - _rt::cabi_dealloc( - base678, - len678 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result678, - } - }; - V693::ComponentModel(e693) - } - 1 => { - let e693 = { - let l679 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l679 { - 0 => None, - 1 => { - let e = { - let l680 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l681 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base685 = l680; - let len685 = l681; - let mut result685 = _rt::Vec::with_capacity(len685); - for i in 0..len685 { - let base = base685 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e685 = { - let l682 = *base.add(0).cast::<*mut u8>(); - let l683 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len684 = l683; - let bytes684 = _rt::Vec::from_raw_parts( - l682.cast(), - len684, - len684, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes684), - } - }; - result685.push(e685); - } - _rt::cabi_dealloc( - base685, - len685 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result685 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V693::UnstructuredText(e693) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e693 = { - let l686 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l686 { - 0 => None, - 1 => { - let e = { - let l687 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l688 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base692 = l687; - let len692 = l688; - let mut result692 = _rt::Vec::with_capacity(len692); - for i in 0..len692 { - let base = base692 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e692 = { - let l689 = *base.add(0).cast::<*mut u8>(); - let l690 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len691 = l690; - let bytes691 = _rt::Vec::from_raw_parts( - l689.cast(), - len691, - len691, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes691), - } - }; - result692.push(e692); - } - _rt::cabi_dealloc( - base692, - len692 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result692 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V693::UnstructuredBinary(e693) - } - }; - (_rt::string_lift(bytes626), v693) - }; - result694.push(e694); - } - _rt::cabi_dealloc( - base694, - len694 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result694 - }; - V695::Multimodal(e695) - } - }; - let l696 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l697 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len698 = l697; - let bytes698 = _rt::Vec::from_raw_parts( - l696.cast(), - len698, - len698, - ); - let l699 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l700 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base704 = l699; - let len704 = l700; - let mut result704 = _rt::Vec::with_capacity(len704); - for i in 0..len704 { - let base = base704 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e704 = { - let l701 = *base.add(0).cast::<*mut u8>(); - let l702 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len703 = l702; - let bytes703 = _rt::Vec::from_raw_parts( - l701.cast(), - len703, - len703, - ); - _rt::string_lift(bytes703) - }; - result704.push(e704); - } - _rt::cabi_dealloc( - base704, - len704 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l705 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l706 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base738 = l705; - let len738 = l706; - let mut result738 = _rt::Vec::with_capacity(len738); - for i in 0..len738 { - let base = base738 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e738 = { - let l707 = *base.add(0).cast::<*mut u8>(); - let l708 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base737 = l707; - let len737 = l708; - let mut result737 = _rt::Vec::with_capacity(len737); - for i in 0..len737 { - let base = base737 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e737 = { - let l709 = i32::from(*base.add(0).cast::()); - let v736 = match l709 { - 0 => { - let e736 = { - let l710 = *base.add(8).cast::<*mut u8>(); - let l711 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len712 = l711; - let bytes712 = _rt::Vec::from_raw_parts( - l710.cast(), - len712, - len712, - ); - let l713 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l714 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l715 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l719 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l721 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l722 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base731 = l721; - let len731 = l722; - let mut result731 = _rt::Vec::with_capacity(len731); - for i in 0..len731 { - let base = base731 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e731 = { - let l723 = *base.add(0).cast::<*mut u8>(); - let l724 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len725 = l724; - let bytes725 = _rt::Vec::from_raw_parts( - l723.cast(), - len725, - len725, - ); - let l726 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V730; - let v730 = match l726 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e730 = { - let l727 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l728 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len729 = l728; - let bytes729 = _rt::Vec::from_raw_parts( - l727.cast(), - len729, - len729, - ); - _rt::string_lift(bytes729) - }; - V730::String(e730) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes725), - value: v730, - } - }; - result731.push(e731); - } - _rt::cabi_dealloc( - base731, - len731 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l732 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes712), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l713 as u64, - nanoseconds: l714 as u32, - }, - parent: match l715 { - 0 => None, - 1 => { - let e = { - let l716 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l717 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len718 = l717; - let bytes718 = _rt::Vec::from_raw_parts( - l716.cast(), - len718, - len718, - ); - _rt::string_lift(bytes718) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l719 { - 0 => None, - 1 => { - let e = { - let l720 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l720 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result731, - inherited: _rt::bool_lift(l732 as u8), - } - }; - SpanData::LocalSpan(e736) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e736 = { - let l733 = *base.add(8).cast::<*mut u8>(); - let l734 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len735 = l734; - let bytes735 = _rt::Vec::from_raw_parts( - l733.cast(), - len735, - len735, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes735), - } - }; - SpanData::ExternalSpan(e736) - } - }; - v736 - }; - result737.push(e737); - } - _rt::cabi_dealloc( - base737, - len737 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result737 - }; - result738.push(e738); - } - _rt::cabi_dealloc( - base738, - len738 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes390), - constructor_parameters: TypedDataValue { - value: v547, - schema: v695, - }, - trace_id: _rt::string_lift(bytes698), - trace_states: result704, - invocation_context: result738, - } - }; - AgentInvocation::AgentInitialization(e1103) - } - 1 => { - let e1103 = { - let l739 = *base.add(32).cast::<*mut u8>(); - let l740 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len741 = l740; - let bytes741 = _rt::Vec::from_raw_parts( - l739.cast(), - len741, - len741, - ); - let l742 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l743 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len744 = l743; - let bytes744 = _rt::Vec::from_raw_parts( - l742.cast(), - len744, - len744, - ); - let l745 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V901; - let v901 = match l745 { - 0 => { - let e901 = { - let l746 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l747 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base821 = l746; - let len821 = l747; - let mut result821 = _rt::Vec::with_capacity(len821); - for i in 0..len821 { - let base = base821 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e821 = { - let l748 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V820; - let v820 = match l748 { - 0 => { - let e820 = { - let l749 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l750 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base796 = l749; - let len796 = l750; - let mut result796 = _rt::Vec::with_capacity(len796); - for i in 0..len796 { - let base = base796 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e796 = { - let l751 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V795; - let v795 = match l751 { - 0 => { - let e795 = { - let l752 = *base.add(8).cast::<*mut u8>(); - let l753 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len754 = l753; - _rt::Vec::from_raw_parts(l752.cast(), len754, len754) - }; - V795::RecordValue(e795) - } - 1 => { - let e795 = { - let l755 = *base.add(8).cast::(); - let l756 = i32::from(*base.add(12).cast::()); - ( - l755 as u32, - match l756 { - 0 => None, - 1 => { - let e = { - let l757 = *base.add(16).cast::(); - l757 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V795::VariantValue(e795) - } - 2 => { - let e795 = { - let l758 = *base.add(8).cast::(); - l758 as u32 - }; - V795::EnumValue(e795) - } - 3 => { - let e795 = { - let l759 = *base.add(8).cast::<*mut u8>(); - let l760 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base762 = l759; - let len762 = l760; - let mut result762 = _rt::Vec::with_capacity(len762); - for i in 0..len762 { - let base = base762.add(i * 1); - let e762 = { - let l761 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l761 as u8) - }; - result762.push(e762); - } - _rt::cabi_dealloc(base762, len762 * 1, 1); - result762 - }; - V795::FlagsValue(e795) - } - 4 => { - let e795 = { - let l763 = *base.add(8).cast::<*mut u8>(); - let l764 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len765 = l764; - _rt::Vec::from_raw_parts(l763.cast(), len765, len765) - }; - V795::TupleValue(e795) - } - 5 => { - let e795 = { - let l766 = *base.add(8).cast::<*mut u8>(); - let l767 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len768 = l767; - _rt::Vec::from_raw_parts(l766.cast(), len768, len768) - }; - V795::ListValue(e795) - } - 6 => { - let e795 = { - let l769 = i32::from(*base.add(8).cast::()); - match l769 { - 0 => None, - 1 => { - let e = { - let l770 = *base.add(12).cast::(); - l770 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V795::OptionValue(e795) - } - 7 => { - let e795 = { - let l771 = i32::from(*base.add(8).cast::()); - match l771 { - 0 => { - let e = { - let l772 = i32::from(*base.add(12).cast::()); - match l772 { - 0 => None, - 1 => { - let e = { - let l773 = *base.add(16).cast::(); - l773 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l774 = i32::from(*base.add(12).cast::()); - match l774 { - 0 => None, - 1 => { - let e = { - let l775 = *base.add(16).cast::(); - l775 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V795::ResultValue(e795) - } - 8 => { - let e795 = { - let l776 = i32::from(*base.add(8).cast::()); - l776 as u8 - }; - V795::PrimU8(e795) - } - 9 => { - let e795 = { - let l777 = i32::from(*base.add(8).cast::()); - l777 as u16 - }; - V795::PrimU16(e795) - } - 10 => { - let e795 = { - let l778 = *base.add(8).cast::(); - l778 as u32 - }; - V795::PrimU32(e795) - } - 11 => { - let e795 = { - let l779 = *base.add(8).cast::(); - l779 as u64 - }; - V795::PrimU64(e795) - } - 12 => { - let e795 = { - let l780 = i32::from(*base.add(8).cast::()); - l780 as i8 - }; - V795::PrimS8(e795) - } - 13 => { - let e795 = { - let l781 = i32::from(*base.add(8).cast::()); - l781 as i16 - }; - V795::PrimS16(e795) - } - 14 => { - let e795 = { - let l782 = *base.add(8).cast::(); - l782 - }; - V795::PrimS32(e795) - } - 15 => { - let e795 = { - let l783 = *base.add(8).cast::(); - l783 - }; - V795::PrimS64(e795) - } - 16 => { - let e795 = { - let l784 = *base.add(8).cast::(); - l784 - }; - V795::PrimFloat32(e795) - } - 17 => { - let e795 = { - let l785 = *base.add(8).cast::(); - l785 - }; - V795::PrimFloat64(e795) - } - 18 => { - let e795 = { - let l786 = *base.add(8).cast::(); - _rt::char_lift(l786 as u32) - }; - V795::PrimChar(e795) - } - 19 => { - let e795 = { - let l787 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l787 as u8) - }; - V795::PrimBool(e795) - } - 20 => { - let e795 = { - let l788 = *base.add(8).cast::<*mut u8>(); - let l789 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len790 = l789; - let bytes790 = _rt::Vec::from_raw_parts( - l788.cast(), - len790, - len790, - ); - _rt::string_lift(bytes790) - }; - V795::PrimString(e795) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e795 = { - let l791 = *base.add(8).cast::<*mut u8>(); - let l792 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len793 = l792; - let bytes793 = _rt::Vec::from_raw_parts( - l791.cast(), - len793, - len793, - ); - let l794 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes793), - }, - l794 as u64, - ) - }; - V795::Handle(e795) - } - }; - v795 - }; - result796.push(e796); - } - _rt::cabi_dealloc( - base796, - len796 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result796, - } - }; - V820::ComponentModel(e820) - } - 1 => { - let e820 = { - let l797 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V808; - let v808 = match l797 { - 0 => { - let e808 = { - let l798 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l799 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len800 = l799; - let bytes800 = _rt::Vec::from_raw_parts( - l798.cast(), - len800, - len800, - ); - _rt::string_lift(bytes800) - }; - V808::Url(e808) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e808 = { - let l801 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l802 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len803 = l802; - let bytes803 = _rt::Vec::from_raw_parts( - l801.cast(), - len803, - len803, - ); - let l804 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes803), - text_type: match l804 { - 0 => None, - 1 => { - let e = { - let l805 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l806 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len807 = l806; - let bytes807 = _rt::Vec::from_raw_parts( - l805.cast(), - len807, - len807, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes807), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V808::Inline(e808) - } - }; - v808 - }; - V820::UnstructuredText(e820) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e820 = { - let l809 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V819; - let v819 = match l809 { - 0 => { - let e819 = { - let l810 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l811 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len812 = l811; - let bytes812 = _rt::Vec::from_raw_parts( - l810.cast(), - len812, - len812, - ); - _rt::string_lift(bytes812) - }; - V819::Url(e819) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e819 = { - let l813 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l814 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len815 = l814; - let l816 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l817 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len818 = l817; - let bytes818 = _rt::Vec::from_raw_parts( - l816.cast(), - len818, - len818, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l813.cast(), len815, len815), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes818), - }, - } - }; - V819::Inline(e819) - } - }; - v819 - }; - V820::UnstructuredBinary(e820) - } - }; - v820 - }; - result821.push(e821); - } - _rt::cabi_dealloc( - base821, - len821 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result821 - }; - V901::Tuple(e901) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e901 = { - let l822 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l823 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base900 = l822; - let len900 = l823; - let mut result900 = _rt::Vec::with_capacity(len900); - for i in 0..len900 { - let base = base900 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e900 = { - let l824 = *base.add(0).cast::<*mut u8>(); - let l825 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len826 = l825; - let bytes826 = _rt::Vec::from_raw_parts( - l824.cast(), - len826, - len826, - ); - let l827 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V899; - let v899 = match l827 { - 0 => { - let e899 = { - let l828 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l829 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base875 = l828; - let len875 = l829; - let mut result875 = _rt::Vec::with_capacity(len875); - for i in 0..len875 { - let base = base875 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e875 = { - let l830 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V874; - let v874 = match l830 { - 0 => { - let e874 = { - let l831 = *base.add(8).cast::<*mut u8>(); - let l832 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len833 = l832; - _rt::Vec::from_raw_parts(l831.cast(), len833, len833) - }; - V874::RecordValue(e874) - } - 1 => { - let e874 = { - let l834 = *base.add(8).cast::(); - let l835 = i32::from(*base.add(12).cast::()); - ( - l834 as u32, - match l835 { - 0 => None, - 1 => { - let e = { - let l836 = *base.add(16).cast::(); - l836 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V874::VariantValue(e874) - } - 2 => { - let e874 = { - let l837 = *base.add(8).cast::(); - l837 as u32 - }; - V874::EnumValue(e874) - } - 3 => { - let e874 = { - let l838 = *base.add(8).cast::<*mut u8>(); - let l839 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base841 = l838; - let len841 = l839; - let mut result841 = _rt::Vec::with_capacity(len841); - for i in 0..len841 { - let base = base841.add(i * 1); - let e841 = { - let l840 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l840 as u8) - }; - result841.push(e841); - } - _rt::cabi_dealloc(base841, len841 * 1, 1); - result841 - }; - V874::FlagsValue(e874) - } - 4 => { - let e874 = { - let l842 = *base.add(8).cast::<*mut u8>(); - let l843 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len844 = l843; - _rt::Vec::from_raw_parts(l842.cast(), len844, len844) - }; - V874::TupleValue(e874) - } - 5 => { - let e874 = { - let l845 = *base.add(8).cast::<*mut u8>(); - let l846 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len847 = l846; - _rt::Vec::from_raw_parts(l845.cast(), len847, len847) - }; - V874::ListValue(e874) - } - 6 => { - let e874 = { - let l848 = i32::from(*base.add(8).cast::()); - match l848 { - 0 => None, - 1 => { - let e = { - let l849 = *base.add(12).cast::(); - l849 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V874::OptionValue(e874) - } - 7 => { - let e874 = { - let l850 = i32::from(*base.add(8).cast::()); - match l850 { - 0 => { - let e = { - let l851 = i32::from(*base.add(12).cast::()); - match l851 { - 0 => None, - 1 => { - let e = { - let l852 = *base.add(16).cast::(); - l852 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l853 = i32::from(*base.add(12).cast::()); - match l853 { - 0 => None, - 1 => { - let e = { - let l854 = *base.add(16).cast::(); - l854 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V874::ResultValue(e874) - } - 8 => { - let e874 = { - let l855 = i32::from(*base.add(8).cast::()); - l855 as u8 - }; - V874::PrimU8(e874) - } - 9 => { - let e874 = { - let l856 = i32::from(*base.add(8).cast::()); - l856 as u16 - }; - V874::PrimU16(e874) - } - 10 => { - let e874 = { - let l857 = *base.add(8).cast::(); - l857 as u32 - }; - V874::PrimU32(e874) - } - 11 => { - let e874 = { - let l858 = *base.add(8).cast::(); - l858 as u64 - }; - V874::PrimU64(e874) - } - 12 => { - let e874 = { - let l859 = i32::from(*base.add(8).cast::()); - l859 as i8 - }; - V874::PrimS8(e874) - } - 13 => { - let e874 = { - let l860 = i32::from(*base.add(8).cast::()); - l860 as i16 - }; - V874::PrimS16(e874) - } - 14 => { - let e874 = { - let l861 = *base.add(8).cast::(); - l861 - }; - V874::PrimS32(e874) - } - 15 => { - let e874 = { - let l862 = *base.add(8).cast::(); - l862 - }; - V874::PrimS64(e874) - } - 16 => { - let e874 = { - let l863 = *base.add(8).cast::(); - l863 - }; - V874::PrimFloat32(e874) - } - 17 => { - let e874 = { - let l864 = *base.add(8).cast::(); - l864 - }; - V874::PrimFloat64(e874) - } - 18 => { - let e874 = { - let l865 = *base.add(8).cast::(); - _rt::char_lift(l865 as u32) - }; - V874::PrimChar(e874) - } - 19 => { - let e874 = { - let l866 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l866 as u8) - }; - V874::PrimBool(e874) - } - 20 => { - let e874 = { - let l867 = *base.add(8).cast::<*mut u8>(); - let l868 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len869 = l868; - let bytes869 = _rt::Vec::from_raw_parts( - l867.cast(), - len869, - len869, - ); - _rt::string_lift(bytes869) - }; - V874::PrimString(e874) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e874 = { - let l870 = *base.add(8).cast::<*mut u8>(); - let l871 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len872 = l871; - let bytes872 = _rt::Vec::from_raw_parts( - l870.cast(), - len872, - len872, - ); - let l873 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes872), - }, - l873 as u64, - ) - }; - V874::Handle(e874) - } - }; - v874 - }; - result875.push(e875); - } - _rt::cabi_dealloc( - base875, - len875 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result875, - } - }; - V899::ComponentModel(e899) - } - 1 => { - let e899 = { - let l876 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V887; - let v887 = match l876 { - 0 => { - let e887 = { - let l877 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l878 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len879 = l878; - let bytes879 = _rt::Vec::from_raw_parts( - l877.cast(), - len879, - len879, - ); - _rt::string_lift(bytes879) - }; - V887::Url(e887) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e887 = { - let l880 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l881 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len882 = l881; - let bytes882 = _rt::Vec::from_raw_parts( - l880.cast(), - len882, - len882, - ); - let l883 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes882), - text_type: match l883 { - 0 => None, - 1 => { - let e = { - let l884 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l885 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len886 = l885; - let bytes886 = _rt::Vec::from_raw_parts( - l884.cast(), - len886, - len886, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes886), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V887::Inline(e887) - } - }; - v887 - }; - V899::UnstructuredText(e899) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e899 = { - let l888 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V898; - let v898 = match l888 { - 0 => { - let e898 = { - let l889 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l890 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len891 = l890; - let bytes891 = _rt::Vec::from_raw_parts( - l889.cast(), - len891, - len891, - ); - _rt::string_lift(bytes891) - }; - V898::Url(e898) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e898 = { - let l892 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l893 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len894 = l893; - let l895 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l896 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len897 = l896; - let bytes897 = _rt::Vec::from_raw_parts( - l895.cast(), - len897, - len897, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l892.cast(), len894, len894), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes897), - }, - } - }; - V898::Inline(e898) - } - }; - v898 - }; - V899::UnstructuredBinary(e899) - } - }; - (_rt::string_lift(bytes826), v899) - }; - result900.push(e900); - } - _rt::cabi_dealloc( - base900, - len900 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result900 - }; - V901::Multimodal(e901) - } - }; - let l902 = i32::from( - *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1049; - let v1049 = match l902 { - 0 => { - let e1049 = { - let l903 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l904 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base975 = l903; - let len975 = l904; - let mut result975 = _rt::Vec::with_capacity(len975); - for i in 0..len975 { - let base = base975 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e975 = { - let l905 = *base.add(0).cast::<*mut u8>(); - let l906 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len907 = l906; - let bytes907 = _rt::Vec::from_raw_parts( - l905.cast(), - len907, - len907, - ); - let l908 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V974; - let v974 = match l908 { - 0 => { - let e974 = { - let l909 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l910 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base959 = l909; - let len959 = l910; - let mut result959 = _rt::Vec::with_capacity(len959); - for i in 0..len959 { - let base = base959 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e959 = { - let l911 = i32::from(*base.add(0).cast::()); - let l915 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l919 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V958; - let v958 = match l919 { - 0 => { - let e958 = { - let l920 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l921 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base926 = l920; - let len926 = l921; - let mut result926 = _rt::Vec::with_capacity(len926); - for i in 0..len926 { - let base = base926 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e926 = { - let l922 = *base.add(0).cast::<*mut u8>(); - let l923 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len924 = l923; - let bytes924 = _rt::Vec::from_raw_parts( - l922.cast(), - len924, - len924, - ); - let l925 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes924), l925) - }; - result926.push(e926); - } - _rt::cabi_dealloc( - base926, - len926 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result926 - }; - V958::RecordType(e958) - } - 1 => { - let e958 = { - let l927 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l928 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base934 = l927; - let len934 = l928; - let mut result934 = _rt::Vec::with_capacity(len934); - for i in 0..len934 { - let base = base934 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e934 = { - let l929 = *base.add(0).cast::<*mut u8>(); - let l930 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len931 = l930; - let bytes931 = _rt::Vec::from_raw_parts( - l929.cast(), - len931, - len931, - ); - let l932 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes931), - match l932 { - 0 => None, - 1 => { - let e = { - let l933 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l933 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result934.push(e934); - } - _rt::cabi_dealloc( - base934, - len934 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result934 - }; - V958::VariantType(e958) - } - 2 => { - let e958 = { - let l935 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l936 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base940 = l935; - let len940 = l936; - let mut result940 = _rt::Vec::with_capacity(len940); - for i in 0..len940 { - let base = base940 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e940 = { - let l937 = *base.add(0).cast::<*mut u8>(); - let l938 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len939 = l938; - let bytes939 = _rt::Vec::from_raw_parts( - l937.cast(), - len939, - len939, - ); - _rt::string_lift(bytes939) - }; - result940.push(e940); - } - _rt::cabi_dealloc( - base940, - len940 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result940 - }; - V958::EnumType(e958) - } - 3 => { - let e958 = { - let l941 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l942 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base946 = l941; - let len946 = l942; - let mut result946 = _rt::Vec::with_capacity(len946); - for i in 0..len946 { - let base = base946 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e946 = { - let l943 = *base.add(0).cast::<*mut u8>(); - let l944 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len945 = l944; - let bytes945 = _rt::Vec::from_raw_parts( - l943.cast(), - len945, - len945, - ); - _rt::string_lift(bytes945) - }; - result946.push(e946); - } - _rt::cabi_dealloc( - base946, - len946 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result946 - }; - V958::FlagsType(e958) - } - 4 => { - let e958 = { - let l947 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l948 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len949 = l948; - _rt::Vec::from_raw_parts(l947.cast(), len949, len949) - }; - V958::TupleType(e958) - } - 5 => { - let e958 = { - let l950 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l950 - }; - V958::ListType(e958) - } - 6 => { - let e958 = { - let l951 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l951 - }; - V958::OptionType(e958) - } - 7 => { - let e958 = { - let l952 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l954 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l952 { - 0 => None, - 1 => { - let e = { - let l953 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l953 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l954 { - 0 => None, - 1 => { - let e = { - let l955 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l955 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V958::ResultType(e958) - } - 8 => V958::PrimU8Type, - 9 => V958::PrimU16Type, - 10 => V958::PrimU32Type, - 11 => V958::PrimU64Type, - 12 => V958::PrimS8Type, - 13 => V958::PrimS16Type, - 14 => V958::PrimS32Type, - 15 => V958::PrimS64Type, - 16 => V958::PrimF32Type, - 17 => V958::PrimF64Type, - 18 => V958::PrimCharType, - 19 => V958::PrimBoolType, - 20 => V958::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e958 = { - let l956 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l957 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l956 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l957 as u8, - ), - ) - }; - V958::HandleType(e958) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l911 { - 0 => None, - 1 => { - let e = { - let l912 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l913 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len914 = l913; - let bytes914 = _rt::Vec::from_raw_parts( - l912.cast(), - len914, - len914, - ); - _rt::string_lift(bytes914) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l915 { - 0 => None, - 1 => { - let e = { - let l916 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l917 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len918 = l917; - let bytes918 = _rt::Vec::from_raw_parts( - l916.cast(), - len918, - len918, - ); - _rt::string_lift(bytes918) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v958, - } - }; - result959.push(e959); - } - _rt::cabi_dealloc( - base959, - len959 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result959, - } - }; - V974::ComponentModel(e974) - } - 1 => { - let e974 = { - let l960 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l960 { - 0 => None, - 1 => { - let e = { - let l961 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l962 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base966 = l961; - let len966 = l962; - let mut result966 = _rt::Vec::with_capacity(len966); - for i in 0..len966 { - let base = base966 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e966 = { - let l963 = *base.add(0).cast::<*mut u8>(); - let l964 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len965 = l964; - let bytes965 = _rt::Vec::from_raw_parts( - l963.cast(), - len965, - len965, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes965), - } - }; - result966.push(e966); - } - _rt::cabi_dealloc( - base966, - len966 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result966 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V974::UnstructuredText(e974) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e974 = { - let l967 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l967 { - 0 => None, - 1 => { - let e = { - let l968 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l969 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base973 = l968; - let len973 = l969; - let mut result973 = _rt::Vec::with_capacity(len973); - for i in 0..len973 { - let base = base973 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e973 = { - let l970 = *base.add(0).cast::<*mut u8>(); - let l971 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len972 = l971; - let bytes972 = _rt::Vec::from_raw_parts( - l970.cast(), - len972, - len972, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes972), - } - }; - result973.push(e973); - } - _rt::cabi_dealloc( - base973, - len973 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result973 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V974::UnstructuredBinary(e974) - } - }; - (_rt::string_lift(bytes907), v974) - }; - result975.push(e975); - } - _rt::cabi_dealloc( - base975, - len975 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result975 - }; - V1049::Tuple(e1049) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1049 = { - let l976 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l977 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1048 = l976; - let len1048 = l977; - let mut result1048 = _rt::Vec::with_capacity(len1048); - for i in 0..len1048 { - let base = base1048 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1048 = { - let l978 = *base.add(0).cast::<*mut u8>(); - let l979 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len980 = l979; - let bytes980 = _rt::Vec::from_raw_parts( - l978.cast(), - len980, - len980, - ); - let l981 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1047; - let v1047 = match l981 { - 0 => { - let e1047 = { - let l982 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l983 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1032 = l982; - let len1032 = l983; - let mut result1032 = _rt::Vec::with_capacity(len1032); - for i in 0..len1032 { - let base = base1032 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1032 = { - let l984 = i32::from(*base.add(0).cast::()); - let l988 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l992 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1031; - let v1031 = match l992 { - 0 => { - let e1031 = { - let l993 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l994 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base999 = l993; - let len999 = l994; - let mut result999 = _rt::Vec::with_capacity(len999); - for i in 0..len999 { - let base = base999 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e999 = { - let l995 = *base.add(0).cast::<*mut u8>(); - let l996 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len997 = l996; - let bytes997 = _rt::Vec::from_raw_parts( - l995.cast(), - len997, - len997, - ); - let l998 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes997), l998) - }; - result999.push(e999); - } - _rt::cabi_dealloc( - base999, - len999 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result999 - }; - V1031::RecordType(e1031) - } - 1 => { - let e1031 = { - let l1000 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1001 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1007 = l1000; - let len1007 = l1001; - let mut result1007 = _rt::Vec::with_capacity(len1007); - for i in 0..len1007 { - let base = base1007 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1007 = { - let l1002 = *base.add(0).cast::<*mut u8>(); - let l1003 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1004 = l1003; - let bytes1004 = _rt::Vec::from_raw_parts( - l1002.cast(), - len1004, - len1004, - ); - let l1005 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1004), - match l1005 { - 0 => None, - 1 => { - let e = { - let l1006 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1006 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1007.push(e1007); - } - _rt::cabi_dealloc( - base1007, - len1007 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1007 - }; - V1031::VariantType(e1031) - } - 2 => { - let e1031 = { - let l1008 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1009 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1013 = l1008; - let len1013 = l1009; - let mut result1013 = _rt::Vec::with_capacity(len1013); - for i in 0..len1013 { - let base = base1013 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1013 = { - let l1010 = *base.add(0).cast::<*mut u8>(); - let l1011 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1012 = l1011; - let bytes1012 = _rt::Vec::from_raw_parts( - l1010.cast(), - len1012, - len1012, - ); - _rt::string_lift(bytes1012) - }; - result1013.push(e1013); - } - _rt::cabi_dealloc( - base1013, - len1013 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1013 - }; - V1031::EnumType(e1031) - } - 3 => { - let e1031 = { - let l1014 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1015 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1019 = l1014; - let len1019 = l1015; - let mut result1019 = _rt::Vec::with_capacity(len1019); - for i in 0..len1019 { - let base = base1019 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1019 = { - let l1016 = *base.add(0).cast::<*mut u8>(); - let l1017 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1018 = l1017; - let bytes1018 = _rt::Vec::from_raw_parts( - l1016.cast(), - len1018, - len1018, - ); - _rt::string_lift(bytes1018) - }; - result1019.push(e1019); - } - _rt::cabi_dealloc( - base1019, - len1019 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1019 - }; - V1031::FlagsType(e1031) - } - 4 => { - let e1031 = { - let l1020 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1021 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1022 = l1021; - _rt::Vec::from_raw_parts(l1020.cast(), len1022, len1022) - }; - V1031::TupleType(e1031) - } - 5 => { - let e1031 = { - let l1023 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1023 - }; - V1031::ListType(e1031) - } - 6 => { - let e1031 = { - let l1024 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1024 - }; - V1031::OptionType(e1031) - } - 7 => { - let e1031 = { - let l1025 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1027 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1025 { - 0 => None, - 1 => { - let e = { - let l1026 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1026 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1027 { - 0 => None, - 1 => { - let e = { - let l1028 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1028 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1031::ResultType(e1031) - } - 8 => V1031::PrimU8Type, - 9 => V1031::PrimU16Type, - 10 => V1031::PrimU32Type, - 11 => V1031::PrimU64Type, - 12 => V1031::PrimS8Type, - 13 => V1031::PrimS16Type, - 14 => V1031::PrimS32Type, - 15 => V1031::PrimS64Type, - 16 => V1031::PrimF32Type, - 17 => V1031::PrimF64Type, - 18 => V1031::PrimCharType, - 19 => V1031::PrimBoolType, - 20 => V1031::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1031 = { - let l1029 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1030 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1029 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1030 as u8, - ), - ) - }; - V1031::HandleType(e1031) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l984 { - 0 => None, - 1 => { - let e = { - let l985 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l986 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len987 = l986; - let bytes987 = _rt::Vec::from_raw_parts( - l985.cast(), - len987, - len987, - ); - _rt::string_lift(bytes987) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l988 { - 0 => None, - 1 => { - let e = { - let l989 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l990 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len991 = l990; - let bytes991 = _rt::Vec::from_raw_parts( - l989.cast(), - len991, - len991, - ); - _rt::string_lift(bytes991) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1031, - } - }; - result1032.push(e1032); - } - _rt::cabi_dealloc( - base1032, - len1032 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1032, - } - }; - V1047::ComponentModel(e1047) - } - 1 => { - let e1047 = { - let l1033 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1033 { - 0 => None, - 1 => { - let e = { - let l1034 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1035 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1039 = l1034; - let len1039 = l1035; - let mut result1039 = _rt::Vec::with_capacity(len1039); - for i in 0..len1039 { - let base = base1039 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1039 = { - let l1036 = *base.add(0).cast::<*mut u8>(); - let l1037 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1038 = l1037; - let bytes1038 = _rt::Vec::from_raw_parts( - l1036.cast(), - len1038, - len1038, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1038), - } - }; - result1039.push(e1039); - } - _rt::cabi_dealloc( - base1039, - len1039 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1039 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1047::UnstructuredText(e1047) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1047 = { - let l1040 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1040 { - 0 => None, - 1 => { - let e = { - let l1041 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1042 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1046 = l1041; - let len1046 = l1042; - let mut result1046 = _rt::Vec::with_capacity(len1046); - for i in 0..len1046 { - let base = base1046 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1046 = { - let l1043 = *base.add(0).cast::<*mut u8>(); - let l1044 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1045 = l1044; - let bytes1045 = _rt::Vec::from_raw_parts( - l1043.cast(), - len1045, - len1045, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1045), - } - }; - result1046.push(e1046); - } - _rt::cabi_dealloc( - base1046, - len1046 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1046 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1047::UnstructuredBinary(e1047) - } - }; - (_rt::string_lift(bytes980), v1047) - }; - result1048.push(e1048); - } - _rt::cabi_dealloc( - base1048, - len1048 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1048 - }; - V1049::Multimodal(e1049) - } - }; - let l1050 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1051 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1052 = l1051; - let bytes1052 = _rt::Vec::from_raw_parts( - l1050.cast(), - len1052, - len1052, - ); - let l1053 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1054 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1058 = l1053; - let len1058 = l1054; - let mut result1058 = _rt::Vec::with_capacity(len1058); - for i in 0..len1058 { - let base = base1058 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1058 = { - let l1055 = *base.add(0).cast::<*mut u8>(); - let l1056 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1057 = l1056; - let bytes1057 = _rt::Vec::from_raw_parts( - l1055.cast(), - len1057, - len1057, - ); - _rt::string_lift(bytes1057) - }; - result1058.push(e1058); - } - _rt::cabi_dealloc( - base1058, - len1058 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1059 = *base - .add(32 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1060 = *base - .add(32 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1092 = l1059; - let len1092 = l1060; - let mut result1092 = _rt::Vec::with_capacity(len1092); - for i in 0..len1092 { - let base = base1092 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1092 = { - let l1061 = *base.add(0).cast::<*mut u8>(); - let l1062 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base1091 = l1061; - let len1091 = l1062; - let mut result1091 = _rt::Vec::with_capacity(len1091); - for i in 0..len1091 { - let base = base1091 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e1091 = { - let l1063 = i32::from(*base.add(0).cast::()); - let v1090 = match l1063 { - 0 => { - let e1090 = { - let l1064 = *base.add(8).cast::<*mut u8>(); - let l1065 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1066 = l1065; - let bytes1066 = _rt::Vec::from_raw_parts( - l1064.cast(), - len1066, - len1066, - ); - let l1067 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1068 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1069 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1073 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1075 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1076 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1085 = l1075; - let len1085 = l1076; - let mut result1085 = _rt::Vec::with_capacity(len1085); - for i in 0..len1085 { - let base = base1085 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e1085 = { - let l1077 = *base.add(0).cast::<*mut u8>(); - let l1078 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1079 = l1078; - let bytes1079 = _rt::Vec::from_raw_parts( - l1077.cast(), - len1079, - len1079, - ); - let l1080 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V1084; - let v1084 = match l1080 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e1084 = { - let l1081 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1082 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1083 = l1082; - let bytes1083 = _rt::Vec::from_raw_parts( - l1081.cast(), - len1083, - len1083, - ); - _rt::string_lift(bytes1083) - }; - V1084::String(e1084) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes1079), - value: v1084, - } - }; - result1085.push(e1085); - } - _rt::cabi_dealloc( - base1085, - len1085 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1086 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes1066), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1067 as u64, - nanoseconds: l1068 as u32, - }, - parent: match l1069 { - 0 => None, - 1 => { - let e = { - let l1070 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1071 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1072 = l1071; - let bytes1072 = _rt::Vec::from_raw_parts( - l1070.cast(), - len1072, - len1072, - ); - _rt::string_lift(bytes1072) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l1073 { - 0 => None, - 1 => { - let e = { - let l1074 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1074 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result1085, - inherited: _rt::bool_lift(l1086 as u8), - } - }; - SpanData::LocalSpan(e1090) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1090 = { - let l1087 = *base.add(8).cast::<*mut u8>(); - let l1088 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1089 = l1088; - let bytes1089 = _rt::Vec::from_raw_parts( - l1087.cast(), - len1089, - len1089, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes1089), - } - }; - SpanData::ExternalSpan(e1090) - } - }; - v1090 - }; - result1091.push(e1091); - } - _rt::cabi_dealloc( - base1091, - len1091 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result1091 - }; - result1092.push(e1092); - } - _rt::cabi_dealloc( - base1092, - len1092 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes741), - method_name: _rt::string_lift(bytes744), - function_input: TypedDataValue { - value: v901, - schema: v1049, - }, - trace_id: _rt::string_lift(bytes1052), - trace_states: result1058, - invocation_context: result1092, - } - }; - AgentInvocation::AgentMethodInvocation(e1103) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e1103 = { - let l1093 = *base.add(32).cast::<*mut u8>(); - let l1094 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1095 = l1094; - let l1096 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1097 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1098 = l1097; - let bytes1098 = _rt::Vec::from_raw_parts( - l1096.cast(), - len1098, - len1098, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1093.cast(), - len1095, - len1095, - ), - mime_type: _rt::string_lift(bytes1098), - }, - } - }; - AgentInvocation::LoadSnapshot(e1103) - } - 4 => { - let e1103 = { - let l1099 = *base.add(32).cast::<*mut u8>(); - let l1100 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1101 = l1100; - let bytes1101 = _rt::Vec::from_raw_parts( - l1099.cast(), - len1101, - len1101, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes1101), - } - }; - AgentInvocation::ProcessOplogEntries(e1103) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1103 = { - let l1102 = *base.add(32).cast::(); - ManualUpdateParameters { - target_revision: l1102 as u64, - } - }; - AgentInvocation::ManualUpdate(e1103) - } - }; - AgentInvocationStartedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l385 as u64, - nanoseconds: l386 as u32, - }, - invocation: v1103, - } - }; - PublicOplogEntry::AgentInvocationStarted(e2675) - } - 3 => { - let e2675 = { - let l1104 = *base.add(8).cast::(); - let l1105 = *base.add(16).cast::(); - let l1106 = i32::from(*base.add(24).cast::()); - let v1731 = match l1106 { - 0 => { - let e1731 = { - let l1107 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1263; - let v1263 = match l1107 { - 0 => { - let e1263 = { - let l1108 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1109 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1183 = l1108; - let len1183 = l1109; - let mut result1183 = _rt::Vec::with_capacity(len1183); - for i in 0..len1183 { - let base = base1183 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1183 = { - let l1110 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1182; - let v1182 = match l1110 { - 0 => { - let e1182 = { - let l1111 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1112 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1158 = l1111; - let len1158 = l1112; - let mut result1158 = _rt::Vec::with_capacity(len1158); - for i in 0..len1158 { - let base = base1158 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1158 = { - let l1113 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1157; - let v1157 = match l1113 { - 0 => { - let e1157 = { - let l1114 = *base.add(8).cast::<*mut u8>(); - let l1115 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1116 = l1115; - _rt::Vec::from_raw_parts(l1114.cast(), len1116, len1116) - }; - V1157::RecordValue(e1157) - } - 1 => { - let e1157 = { - let l1117 = *base.add(8).cast::(); - let l1118 = i32::from(*base.add(12).cast::()); - ( - l1117 as u32, - match l1118 { - 0 => None, - 1 => { - let e = { - let l1119 = *base.add(16).cast::(); - l1119 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1157::VariantValue(e1157) - } - 2 => { - let e1157 = { - let l1120 = *base.add(8).cast::(); - l1120 as u32 - }; - V1157::EnumValue(e1157) - } - 3 => { - let e1157 = { - let l1121 = *base.add(8).cast::<*mut u8>(); - let l1122 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1124 = l1121; - let len1124 = l1122; - let mut result1124 = _rt::Vec::with_capacity(len1124); - for i in 0..len1124 { - let base = base1124.add(i * 1); - let e1124 = { - let l1123 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1123 as u8) - }; - result1124.push(e1124); - } - _rt::cabi_dealloc(base1124, len1124 * 1, 1); - result1124 - }; - V1157::FlagsValue(e1157) - } - 4 => { - let e1157 = { - let l1125 = *base.add(8).cast::<*mut u8>(); - let l1126 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1127 = l1126; - _rt::Vec::from_raw_parts(l1125.cast(), len1127, len1127) - }; - V1157::TupleValue(e1157) - } - 5 => { - let e1157 = { - let l1128 = *base.add(8).cast::<*mut u8>(); - let l1129 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1130 = l1129; - _rt::Vec::from_raw_parts(l1128.cast(), len1130, len1130) - }; - V1157::ListValue(e1157) - } - 6 => { - let e1157 = { - let l1131 = i32::from(*base.add(8).cast::()); - match l1131 { - 0 => None, - 1 => { - let e = { - let l1132 = *base.add(12).cast::(); - l1132 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1157::OptionValue(e1157) - } - 7 => { - let e1157 = { - let l1133 = i32::from(*base.add(8).cast::()); - match l1133 { - 0 => { - let e = { - let l1134 = i32::from(*base.add(12).cast::()); - match l1134 { - 0 => None, - 1 => { - let e = { - let l1135 = *base.add(16).cast::(); - l1135 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1136 = i32::from(*base.add(12).cast::()); - match l1136 { - 0 => None, - 1 => { - let e = { - let l1137 = *base.add(16).cast::(); - l1137 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1157::ResultValue(e1157) - } - 8 => { - let e1157 = { - let l1138 = i32::from(*base.add(8).cast::()); - l1138 as u8 - }; - V1157::PrimU8(e1157) - } - 9 => { - let e1157 = { - let l1139 = i32::from(*base.add(8).cast::()); - l1139 as u16 - }; - V1157::PrimU16(e1157) - } - 10 => { - let e1157 = { - let l1140 = *base.add(8).cast::(); - l1140 as u32 - }; - V1157::PrimU32(e1157) - } - 11 => { - let e1157 = { - let l1141 = *base.add(8).cast::(); - l1141 as u64 - }; - V1157::PrimU64(e1157) - } - 12 => { - let e1157 = { - let l1142 = i32::from(*base.add(8).cast::()); - l1142 as i8 - }; - V1157::PrimS8(e1157) - } - 13 => { - let e1157 = { - let l1143 = i32::from(*base.add(8).cast::()); - l1143 as i16 - }; - V1157::PrimS16(e1157) - } - 14 => { - let e1157 = { - let l1144 = *base.add(8).cast::(); - l1144 - }; - V1157::PrimS32(e1157) - } - 15 => { - let e1157 = { - let l1145 = *base.add(8).cast::(); - l1145 - }; - V1157::PrimS64(e1157) - } - 16 => { - let e1157 = { - let l1146 = *base.add(8).cast::(); - l1146 - }; - V1157::PrimFloat32(e1157) - } - 17 => { - let e1157 = { - let l1147 = *base.add(8).cast::(); - l1147 - }; - V1157::PrimFloat64(e1157) - } - 18 => { - let e1157 = { - let l1148 = *base.add(8).cast::(); - _rt::char_lift(l1148 as u32) - }; - V1157::PrimChar(e1157) - } - 19 => { - let e1157 = { - let l1149 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1149 as u8) - }; - V1157::PrimBool(e1157) - } - 20 => { - let e1157 = { - let l1150 = *base.add(8).cast::<*mut u8>(); - let l1151 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1152 = l1151; - let bytes1152 = _rt::Vec::from_raw_parts( - l1150.cast(), - len1152, - len1152, - ); - _rt::string_lift(bytes1152) - }; - V1157::PrimString(e1157) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1157 = { - let l1153 = *base.add(8).cast::<*mut u8>(); - let l1154 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1155 = l1154; - let bytes1155 = _rt::Vec::from_raw_parts( - l1153.cast(), - len1155, - len1155, - ); - let l1156 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1155), - }, - l1156 as u64, - ) - }; - V1157::Handle(e1157) - } - }; - v1157 - }; - result1158.push(e1158); - } - _rt::cabi_dealloc( - base1158, - len1158 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1158, - } - }; - V1182::ComponentModel(e1182) - } - 1 => { - let e1182 = { - let l1159 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1170; - let v1170 = match l1159 { - 0 => { - let e1170 = { - let l1160 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1161 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1162 = l1161; - let bytes1162 = _rt::Vec::from_raw_parts( - l1160.cast(), - len1162, - len1162, - ); - _rt::string_lift(bytes1162) - }; - V1170::Url(e1170) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1170 = { - let l1163 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1164 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1165 = l1164; - let bytes1165 = _rt::Vec::from_raw_parts( - l1163.cast(), - len1165, - len1165, - ); - let l1166 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1165), - text_type: match l1166 { - 0 => None, - 1 => { - let e = { - let l1167 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1168 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1169 = l1168; - let bytes1169 = _rt::Vec::from_raw_parts( - l1167.cast(), - len1169, - len1169, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1169), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1170::Inline(e1170) - } - }; - v1170 - }; - V1182::UnstructuredText(e1182) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1182 = { - let l1171 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1181; - let v1181 = match l1171 { - 0 => { - let e1181 = { - let l1172 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1173 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1174 = l1173; - let bytes1174 = _rt::Vec::from_raw_parts( - l1172.cast(), - len1174, - len1174, - ); - _rt::string_lift(bytes1174) - }; - V1181::Url(e1181) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1181 = { - let l1175 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1176 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1177 = l1176; - let l1178 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1179 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1180 = l1179; - let bytes1180 = _rt::Vec::from_raw_parts( - l1178.cast(), - len1180, - len1180, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1175.cast(), - len1177, - len1177, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1180), - }, - } - }; - V1181::Inline(e1181) - } - }; - v1181 - }; - V1182::UnstructuredBinary(e1182) - } - }; - v1182 - }; - result1183.push(e1183); - } - _rt::cabi_dealloc( - base1183, - len1183 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1183 - }; - V1263::Tuple(e1263) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1263 = { - let l1184 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1185 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1262 = l1184; - let len1262 = l1185; - let mut result1262 = _rt::Vec::with_capacity(len1262); - for i in 0..len1262 { - let base = base1262 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1262 = { - let l1186 = *base.add(0).cast::<*mut u8>(); - let l1187 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1188 = l1187; - let bytes1188 = _rt::Vec::from_raw_parts( - l1186.cast(), - len1188, - len1188, - ); - let l1189 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1261; - let v1261 = match l1189 { - 0 => { - let e1261 = { - let l1190 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1191 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1237 = l1190; - let len1237 = l1191; - let mut result1237 = _rt::Vec::with_capacity(len1237); - for i in 0..len1237 { - let base = base1237 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1237 = { - let l1192 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1236; - let v1236 = match l1192 { - 0 => { - let e1236 = { - let l1193 = *base.add(8).cast::<*mut u8>(); - let l1194 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1195 = l1194; - _rt::Vec::from_raw_parts(l1193.cast(), len1195, len1195) - }; - V1236::RecordValue(e1236) - } - 1 => { - let e1236 = { - let l1196 = *base.add(8).cast::(); - let l1197 = i32::from(*base.add(12).cast::()); - ( - l1196 as u32, - match l1197 { - 0 => None, - 1 => { - let e = { - let l1198 = *base.add(16).cast::(); - l1198 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1236::VariantValue(e1236) - } - 2 => { - let e1236 = { - let l1199 = *base.add(8).cast::(); - l1199 as u32 - }; - V1236::EnumValue(e1236) - } - 3 => { - let e1236 = { - let l1200 = *base.add(8).cast::<*mut u8>(); - let l1201 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1203 = l1200; - let len1203 = l1201; - let mut result1203 = _rt::Vec::with_capacity(len1203); - for i in 0..len1203 { - let base = base1203.add(i * 1); - let e1203 = { - let l1202 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1202 as u8) - }; - result1203.push(e1203); - } - _rt::cabi_dealloc(base1203, len1203 * 1, 1); - result1203 - }; - V1236::FlagsValue(e1236) - } - 4 => { - let e1236 = { - let l1204 = *base.add(8).cast::<*mut u8>(); - let l1205 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1206 = l1205; - _rt::Vec::from_raw_parts(l1204.cast(), len1206, len1206) - }; - V1236::TupleValue(e1236) - } - 5 => { - let e1236 = { - let l1207 = *base.add(8).cast::<*mut u8>(); - let l1208 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1209 = l1208; - _rt::Vec::from_raw_parts(l1207.cast(), len1209, len1209) - }; - V1236::ListValue(e1236) - } - 6 => { - let e1236 = { - let l1210 = i32::from(*base.add(8).cast::()); - match l1210 { - 0 => None, - 1 => { - let e = { - let l1211 = *base.add(12).cast::(); - l1211 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1236::OptionValue(e1236) - } - 7 => { - let e1236 = { - let l1212 = i32::from(*base.add(8).cast::()); - match l1212 { - 0 => { - let e = { - let l1213 = i32::from(*base.add(12).cast::()); - match l1213 { - 0 => None, - 1 => { - let e = { - let l1214 = *base.add(16).cast::(); - l1214 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1215 = i32::from(*base.add(12).cast::()); - match l1215 { - 0 => None, - 1 => { - let e = { - let l1216 = *base.add(16).cast::(); - l1216 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1236::ResultValue(e1236) - } - 8 => { - let e1236 = { - let l1217 = i32::from(*base.add(8).cast::()); - l1217 as u8 - }; - V1236::PrimU8(e1236) - } - 9 => { - let e1236 = { - let l1218 = i32::from(*base.add(8).cast::()); - l1218 as u16 - }; - V1236::PrimU16(e1236) - } - 10 => { - let e1236 = { - let l1219 = *base.add(8).cast::(); - l1219 as u32 - }; - V1236::PrimU32(e1236) - } - 11 => { - let e1236 = { - let l1220 = *base.add(8).cast::(); - l1220 as u64 - }; - V1236::PrimU64(e1236) - } - 12 => { - let e1236 = { - let l1221 = i32::from(*base.add(8).cast::()); - l1221 as i8 - }; - V1236::PrimS8(e1236) - } - 13 => { - let e1236 = { - let l1222 = i32::from(*base.add(8).cast::()); - l1222 as i16 - }; - V1236::PrimS16(e1236) - } - 14 => { - let e1236 = { - let l1223 = *base.add(8).cast::(); - l1223 - }; - V1236::PrimS32(e1236) - } - 15 => { - let e1236 = { - let l1224 = *base.add(8).cast::(); - l1224 - }; - V1236::PrimS64(e1236) - } - 16 => { - let e1236 = { - let l1225 = *base.add(8).cast::(); - l1225 - }; - V1236::PrimFloat32(e1236) - } - 17 => { - let e1236 = { - let l1226 = *base.add(8).cast::(); - l1226 - }; - V1236::PrimFloat64(e1236) - } - 18 => { - let e1236 = { - let l1227 = *base.add(8).cast::(); - _rt::char_lift(l1227 as u32) - }; - V1236::PrimChar(e1236) - } - 19 => { - let e1236 = { - let l1228 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1228 as u8) - }; - V1236::PrimBool(e1236) - } - 20 => { - let e1236 = { - let l1229 = *base.add(8).cast::<*mut u8>(); - let l1230 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1231 = l1230; - let bytes1231 = _rt::Vec::from_raw_parts( - l1229.cast(), - len1231, - len1231, - ); - _rt::string_lift(bytes1231) - }; - V1236::PrimString(e1236) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1236 = { - let l1232 = *base.add(8).cast::<*mut u8>(); - let l1233 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1234 = l1233; - let bytes1234 = _rt::Vec::from_raw_parts( - l1232.cast(), - len1234, - len1234, - ); - let l1235 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1234), - }, - l1235 as u64, - ) - }; - V1236::Handle(e1236) - } - }; - v1236 - }; - result1237.push(e1237); - } - _rt::cabi_dealloc( - base1237, - len1237 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1237, - } - }; - V1261::ComponentModel(e1261) - } - 1 => { - let e1261 = { - let l1238 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1249; - let v1249 = match l1238 { - 0 => { - let e1249 = { - let l1239 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1240 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1241 = l1240; - let bytes1241 = _rt::Vec::from_raw_parts( - l1239.cast(), - len1241, - len1241, - ); - _rt::string_lift(bytes1241) - }; - V1249::Url(e1249) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1249 = { - let l1242 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1243 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1244 = l1243; - let bytes1244 = _rt::Vec::from_raw_parts( - l1242.cast(), - len1244, - len1244, - ); - let l1245 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1244), - text_type: match l1245 { - 0 => None, - 1 => { - let e = { - let l1246 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1247 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1248 = l1247; - let bytes1248 = _rt::Vec::from_raw_parts( - l1246.cast(), - len1248, - len1248, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1248), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1249::Inline(e1249) - } - }; - v1249 - }; - V1261::UnstructuredText(e1261) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1261 = { - let l1250 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1260; - let v1260 = match l1250 { - 0 => { - let e1260 = { - let l1251 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1252 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1253 = l1252; - let bytes1253 = _rt::Vec::from_raw_parts( - l1251.cast(), - len1253, - len1253, - ); - _rt::string_lift(bytes1253) - }; - V1260::Url(e1260) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1260 = { - let l1254 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1255 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1256 = l1255; - let l1257 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1258 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1259 = l1258; - let bytes1259 = _rt::Vec::from_raw_parts( - l1257.cast(), - len1259, - len1259, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1254.cast(), - len1256, - len1256, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1259), - }, - } - }; - V1260::Inline(e1260) - } - }; - v1260 - }; - V1261::UnstructuredBinary(e1261) - } - }; - (_rt::string_lift(bytes1188), v1261) - }; - result1262.push(e1262); - } - _rt::cabi_dealloc( - base1262, - len1262 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1262 - }; - V1263::Multimodal(e1263) - } - }; - let l1264 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1411; - let v1411 = match l1264 { - 0 => { - let e1411 = { - let l1265 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1266 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1337 = l1265; - let len1337 = l1266; - let mut result1337 = _rt::Vec::with_capacity(len1337); - for i in 0..len1337 { - let base = base1337 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1337 = { - let l1267 = *base.add(0).cast::<*mut u8>(); - let l1268 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1269 = l1268; - let bytes1269 = _rt::Vec::from_raw_parts( - l1267.cast(), - len1269, - len1269, - ); - let l1270 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1336; - let v1336 = match l1270 { - 0 => { - let e1336 = { - let l1271 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1272 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1321 = l1271; - let len1321 = l1272; - let mut result1321 = _rt::Vec::with_capacity(len1321); - for i in 0..len1321 { - let base = base1321 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1321 = { - let l1273 = i32::from(*base.add(0).cast::()); - let l1277 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1281 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1320; - let v1320 = match l1281 { - 0 => { - let e1320 = { - let l1282 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1283 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1288 = l1282; - let len1288 = l1283; - let mut result1288 = _rt::Vec::with_capacity(len1288); - for i in 0..len1288 { - let base = base1288 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1288 = { - let l1284 = *base.add(0).cast::<*mut u8>(); - let l1285 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1286 = l1285; - let bytes1286 = _rt::Vec::from_raw_parts( - l1284.cast(), - len1286, - len1286, - ); - let l1287 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1286), l1287) - }; - result1288.push(e1288); - } - _rt::cabi_dealloc( - base1288, - len1288 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1288 - }; - V1320::RecordType(e1320) - } - 1 => { - let e1320 = { - let l1289 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1290 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1296 = l1289; - let len1296 = l1290; - let mut result1296 = _rt::Vec::with_capacity(len1296); - for i in 0..len1296 { - let base = base1296 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1296 = { - let l1291 = *base.add(0).cast::<*mut u8>(); - let l1292 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1293 = l1292; - let bytes1293 = _rt::Vec::from_raw_parts( - l1291.cast(), - len1293, - len1293, - ); - let l1294 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1293), - match l1294 { - 0 => None, - 1 => { - let e = { - let l1295 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1295 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1296.push(e1296); - } - _rt::cabi_dealloc( - base1296, - len1296 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1296 - }; - V1320::VariantType(e1320) - } - 2 => { - let e1320 = { - let l1297 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1298 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1302 = l1297; - let len1302 = l1298; - let mut result1302 = _rt::Vec::with_capacity(len1302); - for i in 0..len1302 { - let base = base1302 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1302 = { - let l1299 = *base.add(0).cast::<*mut u8>(); - let l1300 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1301 = l1300; - let bytes1301 = _rt::Vec::from_raw_parts( - l1299.cast(), - len1301, - len1301, - ); - _rt::string_lift(bytes1301) - }; - result1302.push(e1302); - } - _rt::cabi_dealloc( - base1302, - len1302 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1302 - }; - V1320::EnumType(e1320) - } - 3 => { - let e1320 = { - let l1303 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1304 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1308 = l1303; - let len1308 = l1304; - let mut result1308 = _rt::Vec::with_capacity(len1308); - for i in 0..len1308 { - let base = base1308 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1308 = { - let l1305 = *base.add(0).cast::<*mut u8>(); - let l1306 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1307 = l1306; - let bytes1307 = _rt::Vec::from_raw_parts( - l1305.cast(), - len1307, - len1307, - ); - _rt::string_lift(bytes1307) - }; - result1308.push(e1308); - } - _rt::cabi_dealloc( - base1308, - len1308 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1308 - }; - V1320::FlagsType(e1320) - } - 4 => { - let e1320 = { - let l1309 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1310 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1311 = l1310; - _rt::Vec::from_raw_parts(l1309.cast(), len1311, len1311) - }; - V1320::TupleType(e1320) - } - 5 => { - let e1320 = { - let l1312 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1312 - }; - V1320::ListType(e1320) - } - 6 => { - let e1320 = { - let l1313 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1313 - }; - V1320::OptionType(e1320) - } - 7 => { - let e1320 = { - let l1314 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1316 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1314 { - 0 => None, - 1 => { - let e = { - let l1315 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1315 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1316 { - 0 => None, - 1 => { - let e = { - let l1317 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1317 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1320::ResultType(e1320) - } - 8 => V1320::PrimU8Type, - 9 => V1320::PrimU16Type, - 10 => V1320::PrimU32Type, - 11 => V1320::PrimU64Type, - 12 => V1320::PrimS8Type, - 13 => V1320::PrimS16Type, - 14 => V1320::PrimS32Type, - 15 => V1320::PrimS64Type, - 16 => V1320::PrimF32Type, - 17 => V1320::PrimF64Type, - 18 => V1320::PrimCharType, - 19 => V1320::PrimBoolType, - 20 => V1320::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1320 = { - let l1318 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1319 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1318 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1319 as u8, - ), - ) - }; - V1320::HandleType(e1320) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1273 { - 0 => None, - 1 => { - let e = { - let l1274 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1275 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1276 = l1275; - let bytes1276 = _rt::Vec::from_raw_parts( - l1274.cast(), - len1276, - len1276, - ); - _rt::string_lift(bytes1276) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1277 { - 0 => None, - 1 => { - let e = { - let l1278 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1279 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1280 = l1279; - let bytes1280 = _rt::Vec::from_raw_parts( - l1278.cast(), - len1280, - len1280, - ); - _rt::string_lift(bytes1280) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1320, - } - }; - result1321.push(e1321); - } - _rt::cabi_dealloc( - base1321, - len1321 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1321, - } - }; - V1336::ComponentModel(e1336) - } - 1 => { - let e1336 = { - let l1322 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1322 { - 0 => None, - 1 => { - let e = { - let l1323 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1324 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1328 = l1323; - let len1328 = l1324; - let mut result1328 = _rt::Vec::with_capacity(len1328); - for i in 0..len1328 { - let base = base1328 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1328 = { - let l1325 = *base.add(0).cast::<*mut u8>(); - let l1326 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1327 = l1326; - let bytes1327 = _rt::Vec::from_raw_parts( - l1325.cast(), - len1327, - len1327, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1327), - } - }; - result1328.push(e1328); - } - _rt::cabi_dealloc( - base1328, - len1328 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1328 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1336::UnstructuredText(e1336) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1336 = { - let l1329 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1329 { - 0 => None, - 1 => { - let e = { - let l1330 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1331 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1335 = l1330; - let len1335 = l1331; - let mut result1335 = _rt::Vec::with_capacity(len1335); - for i in 0..len1335 { - let base = base1335 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1335 = { - let l1332 = *base.add(0).cast::<*mut u8>(); - let l1333 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1334 = l1333; - let bytes1334 = _rt::Vec::from_raw_parts( - l1332.cast(), - len1334, - len1334, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1334), - } - }; - result1335.push(e1335); - } - _rt::cabi_dealloc( - base1335, - len1335 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1335 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1336::UnstructuredBinary(e1336) - } - }; - (_rt::string_lift(bytes1269), v1336) - }; - result1337.push(e1337); - } - _rt::cabi_dealloc( - base1337, - len1337 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1337 - }; - V1411::Tuple(e1411) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1411 = { - let l1338 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1339 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1410 = l1338; - let len1410 = l1339; - let mut result1410 = _rt::Vec::with_capacity(len1410); - for i in 0..len1410 { - let base = base1410 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1410 = { - let l1340 = *base.add(0).cast::<*mut u8>(); - let l1341 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1342 = l1341; - let bytes1342 = _rt::Vec::from_raw_parts( - l1340.cast(), - len1342, - len1342, - ); - let l1343 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1409; - let v1409 = match l1343 { - 0 => { - let e1409 = { - let l1344 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1345 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1394 = l1344; - let len1394 = l1345; - let mut result1394 = _rt::Vec::with_capacity(len1394); - for i in 0..len1394 { - let base = base1394 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1394 = { - let l1346 = i32::from(*base.add(0).cast::()); - let l1350 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1354 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1393; - let v1393 = match l1354 { - 0 => { - let e1393 = { - let l1355 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1356 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1361 = l1355; - let len1361 = l1356; - let mut result1361 = _rt::Vec::with_capacity(len1361); - for i in 0..len1361 { - let base = base1361 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1361 = { - let l1357 = *base.add(0).cast::<*mut u8>(); - let l1358 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1359 = l1358; - let bytes1359 = _rt::Vec::from_raw_parts( - l1357.cast(), - len1359, - len1359, - ); - let l1360 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1359), l1360) - }; - result1361.push(e1361); - } - _rt::cabi_dealloc( - base1361, - len1361 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1361 - }; - V1393::RecordType(e1393) - } - 1 => { - let e1393 = { - let l1362 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1363 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1369 = l1362; - let len1369 = l1363; - let mut result1369 = _rt::Vec::with_capacity(len1369); - for i in 0..len1369 { - let base = base1369 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1369 = { - let l1364 = *base.add(0).cast::<*mut u8>(); - let l1365 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1366 = l1365; - let bytes1366 = _rt::Vec::from_raw_parts( - l1364.cast(), - len1366, - len1366, - ); - let l1367 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1366), - match l1367 { - 0 => None, - 1 => { - let e = { - let l1368 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1368 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1369.push(e1369); - } - _rt::cabi_dealloc( - base1369, - len1369 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1369 - }; - V1393::VariantType(e1393) - } - 2 => { - let e1393 = { - let l1370 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1371 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1375 = l1370; - let len1375 = l1371; - let mut result1375 = _rt::Vec::with_capacity(len1375); - for i in 0..len1375 { - let base = base1375 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1375 = { - let l1372 = *base.add(0).cast::<*mut u8>(); - let l1373 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1374 = l1373; - let bytes1374 = _rt::Vec::from_raw_parts( - l1372.cast(), - len1374, - len1374, - ); - _rt::string_lift(bytes1374) - }; - result1375.push(e1375); - } - _rt::cabi_dealloc( - base1375, - len1375 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1375 - }; - V1393::EnumType(e1393) - } - 3 => { - let e1393 = { - let l1376 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1377 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1381 = l1376; - let len1381 = l1377; - let mut result1381 = _rt::Vec::with_capacity(len1381); - for i in 0..len1381 { - let base = base1381 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1381 = { - let l1378 = *base.add(0).cast::<*mut u8>(); - let l1379 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1380 = l1379; - let bytes1380 = _rt::Vec::from_raw_parts( - l1378.cast(), - len1380, - len1380, - ); - _rt::string_lift(bytes1380) - }; - result1381.push(e1381); - } - _rt::cabi_dealloc( - base1381, - len1381 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1381 - }; - V1393::FlagsType(e1393) - } - 4 => { - let e1393 = { - let l1382 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1383 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1384 = l1383; - _rt::Vec::from_raw_parts(l1382.cast(), len1384, len1384) - }; - V1393::TupleType(e1393) - } - 5 => { - let e1393 = { - let l1385 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1385 - }; - V1393::ListType(e1393) - } - 6 => { - let e1393 = { - let l1386 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1386 - }; - V1393::OptionType(e1393) - } - 7 => { - let e1393 = { - let l1387 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1389 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1387 { - 0 => None, - 1 => { - let e = { - let l1388 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1388 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1389 { - 0 => None, - 1 => { - let e = { - let l1390 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1390 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1393::ResultType(e1393) - } - 8 => V1393::PrimU8Type, - 9 => V1393::PrimU16Type, - 10 => V1393::PrimU32Type, - 11 => V1393::PrimU64Type, - 12 => V1393::PrimS8Type, - 13 => V1393::PrimS16Type, - 14 => V1393::PrimS32Type, - 15 => V1393::PrimS64Type, - 16 => V1393::PrimF32Type, - 17 => V1393::PrimF64Type, - 18 => V1393::PrimCharType, - 19 => V1393::PrimBoolType, - 20 => V1393::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1393 = { - let l1391 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1392 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1391 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1392 as u8, - ), - ) - }; - V1393::HandleType(e1393) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1346 { - 0 => None, - 1 => { - let e = { - let l1347 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1348 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1349 = l1348; - let bytes1349 = _rt::Vec::from_raw_parts( - l1347.cast(), - len1349, - len1349, - ); - _rt::string_lift(bytes1349) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1350 { - 0 => None, - 1 => { - let e = { - let l1351 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1352 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1353 = l1352; - let bytes1353 = _rt::Vec::from_raw_parts( - l1351.cast(), - len1353, - len1353, - ); - _rt::string_lift(bytes1353) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1393, - } - }; - result1394.push(e1394); - } - _rt::cabi_dealloc( - base1394, - len1394 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1394, - } - }; - V1409::ComponentModel(e1409) - } - 1 => { - let e1409 = { - let l1395 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1395 { - 0 => None, - 1 => { - let e = { - let l1396 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1397 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1401 = l1396; - let len1401 = l1397; - let mut result1401 = _rt::Vec::with_capacity(len1401); - for i in 0..len1401 { - let base = base1401 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1401 = { - let l1398 = *base.add(0).cast::<*mut u8>(); - let l1399 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1400 = l1399; - let bytes1400 = _rt::Vec::from_raw_parts( - l1398.cast(), - len1400, - len1400, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1400), - } - }; - result1401.push(e1401); - } - _rt::cabi_dealloc( - base1401, - len1401 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1401 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1409::UnstructuredText(e1409) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1409 = { - let l1402 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1402 { - 0 => None, - 1 => { - let e = { - let l1403 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1404 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1408 = l1403; - let len1408 = l1404; - let mut result1408 = _rt::Vec::with_capacity(len1408); - for i in 0..len1408 { - let base = base1408 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1408 = { - let l1405 = *base.add(0).cast::<*mut u8>(); - let l1406 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1407 = l1406; - let bytes1407 = _rt::Vec::from_raw_parts( - l1405.cast(), - len1407, - len1407, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1407), - } - }; - result1408.push(e1408); - } - _rt::cabi_dealloc( - base1408, - len1408 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1408 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1409::UnstructuredBinary(e1409) - } - }; - (_rt::string_lift(bytes1342), v1409) - }; - result1410.push(e1410); - } - _rt::cabi_dealloc( - base1410, - len1410 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1410 - }; - V1411::Multimodal(e1411) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1263, - schema: v1411, - }, - } - }; - AgentInvocationResult::AgentInitialization(e1731) - } - 1 => { - let e1731 = { - let l1412 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1568; - let v1568 = match l1412 { - 0 => { - let e1568 = { - let l1413 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1414 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1488 = l1413; - let len1488 = l1414; - let mut result1488 = _rt::Vec::with_capacity(len1488); - for i in 0..len1488 { - let base = base1488 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1488 = { - let l1415 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1487; - let v1487 = match l1415 { - 0 => { - let e1487 = { - let l1416 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1417 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1463 = l1416; - let len1463 = l1417; - let mut result1463 = _rt::Vec::with_capacity(len1463); - for i in 0..len1463 { - let base = base1463 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1463 = { - let l1418 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1462; - let v1462 = match l1418 { - 0 => { - let e1462 = { - let l1419 = *base.add(8).cast::<*mut u8>(); - let l1420 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1421 = l1420; - _rt::Vec::from_raw_parts(l1419.cast(), len1421, len1421) - }; - V1462::RecordValue(e1462) - } - 1 => { - let e1462 = { - let l1422 = *base.add(8).cast::(); - let l1423 = i32::from(*base.add(12).cast::()); - ( - l1422 as u32, - match l1423 { - 0 => None, - 1 => { - let e = { - let l1424 = *base.add(16).cast::(); - l1424 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1462::VariantValue(e1462) - } - 2 => { - let e1462 = { - let l1425 = *base.add(8).cast::(); - l1425 as u32 - }; - V1462::EnumValue(e1462) - } - 3 => { - let e1462 = { - let l1426 = *base.add(8).cast::<*mut u8>(); - let l1427 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1429 = l1426; - let len1429 = l1427; - let mut result1429 = _rt::Vec::with_capacity(len1429); - for i in 0..len1429 { - let base = base1429.add(i * 1); - let e1429 = { - let l1428 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1428 as u8) - }; - result1429.push(e1429); - } - _rt::cabi_dealloc(base1429, len1429 * 1, 1); - result1429 - }; - V1462::FlagsValue(e1462) - } - 4 => { - let e1462 = { - let l1430 = *base.add(8).cast::<*mut u8>(); - let l1431 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1432 = l1431; - _rt::Vec::from_raw_parts(l1430.cast(), len1432, len1432) - }; - V1462::TupleValue(e1462) - } - 5 => { - let e1462 = { - let l1433 = *base.add(8).cast::<*mut u8>(); - let l1434 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1435 = l1434; - _rt::Vec::from_raw_parts(l1433.cast(), len1435, len1435) - }; - V1462::ListValue(e1462) - } - 6 => { - let e1462 = { - let l1436 = i32::from(*base.add(8).cast::()); - match l1436 { - 0 => None, - 1 => { - let e = { - let l1437 = *base.add(12).cast::(); - l1437 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1462::OptionValue(e1462) - } - 7 => { - let e1462 = { - let l1438 = i32::from(*base.add(8).cast::()); - match l1438 { - 0 => { - let e = { - let l1439 = i32::from(*base.add(12).cast::()); - match l1439 { - 0 => None, - 1 => { - let e = { - let l1440 = *base.add(16).cast::(); - l1440 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1441 = i32::from(*base.add(12).cast::()); - match l1441 { - 0 => None, - 1 => { - let e = { - let l1442 = *base.add(16).cast::(); - l1442 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1462::ResultValue(e1462) - } - 8 => { - let e1462 = { - let l1443 = i32::from(*base.add(8).cast::()); - l1443 as u8 - }; - V1462::PrimU8(e1462) - } - 9 => { - let e1462 = { - let l1444 = i32::from(*base.add(8).cast::()); - l1444 as u16 - }; - V1462::PrimU16(e1462) - } - 10 => { - let e1462 = { - let l1445 = *base.add(8).cast::(); - l1445 as u32 - }; - V1462::PrimU32(e1462) - } - 11 => { - let e1462 = { - let l1446 = *base.add(8).cast::(); - l1446 as u64 - }; - V1462::PrimU64(e1462) - } - 12 => { - let e1462 = { - let l1447 = i32::from(*base.add(8).cast::()); - l1447 as i8 - }; - V1462::PrimS8(e1462) - } - 13 => { - let e1462 = { - let l1448 = i32::from(*base.add(8).cast::()); - l1448 as i16 - }; - V1462::PrimS16(e1462) - } - 14 => { - let e1462 = { - let l1449 = *base.add(8).cast::(); - l1449 - }; - V1462::PrimS32(e1462) - } - 15 => { - let e1462 = { - let l1450 = *base.add(8).cast::(); - l1450 - }; - V1462::PrimS64(e1462) - } - 16 => { - let e1462 = { - let l1451 = *base.add(8).cast::(); - l1451 - }; - V1462::PrimFloat32(e1462) - } - 17 => { - let e1462 = { - let l1452 = *base.add(8).cast::(); - l1452 - }; - V1462::PrimFloat64(e1462) - } - 18 => { - let e1462 = { - let l1453 = *base.add(8).cast::(); - _rt::char_lift(l1453 as u32) - }; - V1462::PrimChar(e1462) - } - 19 => { - let e1462 = { - let l1454 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1454 as u8) - }; - V1462::PrimBool(e1462) - } - 20 => { - let e1462 = { - let l1455 = *base.add(8).cast::<*mut u8>(); - let l1456 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1457 = l1456; - let bytes1457 = _rt::Vec::from_raw_parts( - l1455.cast(), - len1457, - len1457, - ); - _rt::string_lift(bytes1457) - }; - V1462::PrimString(e1462) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1462 = { - let l1458 = *base.add(8).cast::<*mut u8>(); - let l1459 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1460 = l1459; - let bytes1460 = _rt::Vec::from_raw_parts( - l1458.cast(), - len1460, - len1460, - ); - let l1461 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1460), - }, - l1461 as u64, - ) - }; - V1462::Handle(e1462) - } - }; - v1462 - }; - result1463.push(e1463); - } - _rt::cabi_dealloc( - base1463, - len1463 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1463, - } - }; - V1487::ComponentModel(e1487) - } - 1 => { - let e1487 = { - let l1464 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1475; - let v1475 = match l1464 { - 0 => { - let e1475 = { - let l1465 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1466 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1467 = l1466; - let bytes1467 = _rt::Vec::from_raw_parts( - l1465.cast(), - len1467, - len1467, - ); - _rt::string_lift(bytes1467) - }; - V1475::Url(e1475) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1475 = { - let l1468 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1469 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1470 = l1469; - let bytes1470 = _rt::Vec::from_raw_parts( - l1468.cast(), - len1470, - len1470, - ); - let l1471 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1470), - text_type: match l1471 { - 0 => None, - 1 => { - let e = { - let l1472 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1473 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1474 = l1473; - let bytes1474 = _rt::Vec::from_raw_parts( - l1472.cast(), - len1474, - len1474, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1474), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1475::Inline(e1475) - } - }; - v1475 - }; - V1487::UnstructuredText(e1487) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1487 = { - let l1476 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1486; - let v1486 = match l1476 { - 0 => { - let e1486 = { - let l1477 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1478 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1479 = l1478; - let bytes1479 = _rt::Vec::from_raw_parts( - l1477.cast(), - len1479, - len1479, - ); - _rt::string_lift(bytes1479) - }; - V1486::Url(e1486) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1486 = { - let l1480 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1481 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1482 = l1481; - let l1483 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1484 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1485 = l1484; - let bytes1485 = _rt::Vec::from_raw_parts( - l1483.cast(), - len1485, - len1485, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1480.cast(), - len1482, - len1482, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1485), - }, - } - }; - V1486::Inline(e1486) - } - }; - v1486 - }; - V1487::UnstructuredBinary(e1487) - } - }; - v1487 - }; - result1488.push(e1488); - } - _rt::cabi_dealloc( - base1488, - len1488 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1488 - }; - V1568::Tuple(e1568) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1568 = { - let l1489 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1490 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1567 = l1489; - let len1567 = l1490; - let mut result1567 = _rt::Vec::with_capacity(len1567); - for i in 0..len1567 { - let base = base1567 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1567 = { - let l1491 = *base.add(0).cast::<*mut u8>(); - let l1492 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1493 = l1492; - let bytes1493 = _rt::Vec::from_raw_parts( - l1491.cast(), - len1493, - len1493, - ); - let l1494 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1566; - let v1566 = match l1494 { - 0 => { - let e1566 = { - let l1495 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1496 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1542 = l1495; - let len1542 = l1496; - let mut result1542 = _rt::Vec::with_capacity(len1542); - for i in 0..len1542 { - let base = base1542 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1542 = { - let l1497 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1541; - let v1541 = match l1497 { - 0 => { - let e1541 = { - let l1498 = *base.add(8).cast::<*mut u8>(); - let l1499 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1500 = l1499; - _rt::Vec::from_raw_parts(l1498.cast(), len1500, len1500) - }; - V1541::RecordValue(e1541) - } - 1 => { - let e1541 = { - let l1501 = *base.add(8).cast::(); - let l1502 = i32::from(*base.add(12).cast::()); - ( - l1501 as u32, - match l1502 { - 0 => None, - 1 => { - let e = { - let l1503 = *base.add(16).cast::(); - l1503 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1541::VariantValue(e1541) - } - 2 => { - let e1541 = { - let l1504 = *base.add(8).cast::(); - l1504 as u32 - }; - V1541::EnumValue(e1541) - } - 3 => { - let e1541 = { - let l1505 = *base.add(8).cast::<*mut u8>(); - let l1506 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1508 = l1505; - let len1508 = l1506; - let mut result1508 = _rt::Vec::with_capacity(len1508); - for i in 0..len1508 { - let base = base1508.add(i * 1); - let e1508 = { - let l1507 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1507 as u8) - }; - result1508.push(e1508); - } - _rt::cabi_dealloc(base1508, len1508 * 1, 1); - result1508 - }; - V1541::FlagsValue(e1541) - } - 4 => { - let e1541 = { - let l1509 = *base.add(8).cast::<*mut u8>(); - let l1510 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1511 = l1510; - _rt::Vec::from_raw_parts(l1509.cast(), len1511, len1511) - }; - V1541::TupleValue(e1541) - } - 5 => { - let e1541 = { - let l1512 = *base.add(8).cast::<*mut u8>(); - let l1513 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1514 = l1513; - _rt::Vec::from_raw_parts(l1512.cast(), len1514, len1514) - }; - V1541::ListValue(e1541) - } - 6 => { - let e1541 = { - let l1515 = i32::from(*base.add(8).cast::()); - match l1515 { - 0 => None, - 1 => { - let e = { - let l1516 = *base.add(12).cast::(); - l1516 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1541::OptionValue(e1541) - } - 7 => { - let e1541 = { - let l1517 = i32::from(*base.add(8).cast::()); - match l1517 { - 0 => { - let e = { - let l1518 = i32::from(*base.add(12).cast::()); - match l1518 { - 0 => None, - 1 => { - let e = { - let l1519 = *base.add(16).cast::(); - l1519 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1520 = i32::from(*base.add(12).cast::()); - match l1520 { - 0 => None, - 1 => { - let e = { - let l1521 = *base.add(16).cast::(); - l1521 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1541::ResultValue(e1541) - } - 8 => { - let e1541 = { - let l1522 = i32::from(*base.add(8).cast::()); - l1522 as u8 - }; - V1541::PrimU8(e1541) - } - 9 => { - let e1541 = { - let l1523 = i32::from(*base.add(8).cast::()); - l1523 as u16 - }; - V1541::PrimU16(e1541) - } - 10 => { - let e1541 = { - let l1524 = *base.add(8).cast::(); - l1524 as u32 - }; - V1541::PrimU32(e1541) - } - 11 => { - let e1541 = { - let l1525 = *base.add(8).cast::(); - l1525 as u64 - }; - V1541::PrimU64(e1541) - } - 12 => { - let e1541 = { - let l1526 = i32::from(*base.add(8).cast::()); - l1526 as i8 - }; - V1541::PrimS8(e1541) - } - 13 => { - let e1541 = { - let l1527 = i32::from(*base.add(8).cast::()); - l1527 as i16 - }; - V1541::PrimS16(e1541) - } - 14 => { - let e1541 = { - let l1528 = *base.add(8).cast::(); - l1528 - }; - V1541::PrimS32(e1541) - } - 15 => { - let e1541 = { - let l1529 = *base.add(8).cast::(); - l1529 - }; - V1541::PrimS64(e1541) - } - 16 => { - let e1541 = { - let l1530 = *base.add(8).cast::(); - l1530 - }; - V1541::PrimFloat32(e1541) - } - 17 => { - let e1541 = { - let l1531 = *base.add(8).cast::(); - l1531 - }; - V1541::PrimFloat64(e1541) - } - 18 => { - let e1541 = { - let l1532 = *base.add(8).cast::(); - _rt::char_lift(l1532 as u32) - }; - V1541::PrimChar(e1541) - } - 19 => { - let e1541 = { - let l1533 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1533 as u8) - }; - V1541::PrimBool(e1541) - } - 20 => { - let e1541 = { - let l1534 = *base.add(8).cast::<*mut u8>(); - let l1535 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1536 = l1535; - let bytes1536 = _rt::Vec::from_raw_parts( - l1534.cast(), - len1536, - len1536, - ); - _rt::string_lift(bytes1536) - }; - V1541::PrimString(e1541) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1541 = { - let l1537 = *base.add(8).cast::<*mut u8>(); - let l1538 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1539 = l1538; - let bytes1539 = _rt::Vec::from_raw_parts( - l1537.cast(), - len1539, - len1539, - ); - let l1540 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1539), - }, - l1540 as u64, - ) - }; - V1541::Handle(e1541) - } - }; - v1541 - }; - result1542.push(e1542); - } - _rt::cabi_dealloc( - base1542, - len1542 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1542, - } - }; - V1566::ComponentModel(e1566) - } - 1 => { - let e1566 = { - let l1543 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1554; - let v1554 = match l1543 { - 0 => { - let e1554 = { - let l1544 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1545 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1546 = l1545; - let bytes1546 = _rt::Vec::from_raw_parts( - l1544.cast(), - len1546, - len1546, - ); - _rt::string_lift(bytes1546) - }; - V1554::Url(e1554) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1554 = { - let l1547 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1548 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1549 = l1548; - let bytes1549 = _rt::Vec::from_raw_parts( - l1547.cast(), - len1549, - len1549, - ); - let l1550 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1549), - text_type: match l1550 { - 0 => None, - 1 => { - let e = { - let l1551 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1552 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1553 = l1552; - let bytes1553 = _rt::Vec::from_raw_parts( - l1551.cast(), - len1553, - len1553, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1553), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1554::Inline(e1554) - } - }; - v1554 - }; - V1566::UnstructuredText(e1566) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1566 = { - let l1555 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1565; - let v1565 = match l1555 { - 0 => { - let e1565 = { - let l1556 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1557 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1558 = l1557; - let bytes1558 = _rt::Vec::from_raw_parts( - l1556.cast(), - len1558, - len1558, - ); - _rt::string_lift(bytes1558) - }; - V1565::Url(e1565) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1565 = { - let l1559 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1560 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1561 = l1560; - let l1562 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1563 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1564 = l1563; - let bytes1564 = _rt::Vec::from_raw_parts( - l1562.cast(), - len1564, - len1564, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1559.cast(), - len1561, - len1561, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1564), - }, - } - }; - V1565::Inline(e1565) - } - }; - v1565 - }; - V1566::UnstructuredBinary(e1566) - } - }; - (_rt::string_lift(bytes1493), v1566) - }; - result1567.push(e1567); - } - _rt::cabi_dealloc( - base1567, - len1567 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1567 - }; - V1568::Multimodal(e1568) - } - }; - let l1569 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1716; - let v1716 = match l1569 { - 0 => { - let e1716 = { - let l1570 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1571 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1642 = l1570; - let len1642 = l1571; - let mut result1642 = _rt::Vec::with_capacity(len1642); - for i in 0..len1642 { - let base = base1642 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1642 = { - let l1572 = *base.add(0).cast::<*mut u8>(); - let l1573 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1574 = l1573; - let bytes1574 = _rt::Vec::from_raw_parts( - l1572.cast(), - len1574, - len1574, - ); - let l1575 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1641; - let v1641 = match l1575 { - 0 => { - let e1641 = { - let l1576 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1577 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1626 = l1576; - let len1626 = l1577; - let mut result1626 = _rt::Vec::with_capacity(len1626); - for i in 0..len1626 { - let base = base1626 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1626 = { - let l1578 = i32::from(*base.add(0).cast::()); - let l1582 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1586 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1625; - let v1625 = match l1586 { - 0 => { - let e1625 = { - let l1587 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1588 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1593 = l1587; - let len1593 = l1588; - let mut result1593 = _rt::Vec::with_capacity(len1593); - for i in 0..len1593 { - let base = base1593 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1593 = { - let l1589 = *base.add(0).cast::<*mut u8>(); - let l1590 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1591 = l1590; - let bytes1591 = _rt::Vec::from_raw_parts( - l1589.cast(), - len1591, - len1591, - ); - let l1592 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1591), l1592) - }; - result1593.push(e1593); - } - _rt::cabi_dealloc( - base1593, - len1593 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1593 - }; - V1625::RecordType(e1625) - } - 1 => { - let e1625 = { - let l1594 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1595 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1601 = l1594; - let len1601 = l1595; - let mut result1601 = _rt::Vec::with_capacity(len1601); - for i in 0..len1601 { - let base = base1601 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1601 = { - let l1596 = *base.add(0).cast::<*mut u8>(); - let l1597 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1598 = l1597; - let bytes1598 = _rt::Vec::from_raw_parts( - l1596.cast(), - len1598, - len1598, - ); - let l1599 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1598), - match l1599 { - 0 => None, - 1 => { - let e = { - let l1600 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1600 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1601.push(e1601); - } - _rt::cabi_dealloc( - base1601, - len1601 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1601 - }; - V1625::VariantType(e1625) - } - 2 => { - let e1625 = { - let l1602 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1603 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1607 = l1602; - let len1607 = l1603; - let mut result1607 = _rt::Vec::with_capacity(len1607); - for i in 0..len1607 { - let base = base1607 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1607 = { - let l1604 = *base.add(0).cast::<*mut u8>(); - let l1605 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1606 = l1605; - let bytes1606 = _rt::Vec::from_raw_parts( - l1604.cast(), - len1606, - len1606, - ); - _rt::string_lift(bytes1606) - }; - result1607.push(e1607); - } - _rt::cabi_dealloc( - base1607, - len1607 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1607 - }; - V1625::EnumType(e1625) - } - 3 => { - let e1625 = { - let l1608 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1609 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1613 = l1608; - let len1613 = l1609; - let mut result1613 = _rt::Vec::with_capacity(len1613); - for i in 0..len1613 { - let base = base1613 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1613 = { - let l1610 = *base.add(0).cast::<*mut u8>(); - let l1611 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1612 = l1611; - let bytes1612 = _rt::Vec::from_raw_parts( - l1610.cast(), - len1612, - len1612, - ); - _rt::string_lift(bytes1612) - }; - result1613.push(e1613); - } - _rt::cabi_dealloc( - base1613, - len1613 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1613 - }; - V1625::FlagsType(e1625) - } - 4 => { - let e1625 = { - let l1614 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1615 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1616 = l1615; - _rt::Vec::from_raw_parts(l1614.cast(), len1616, len1616) - }; - V1625::TupleType(e1625) - } - 5 => { - let e1625 = { - let l1617 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1617 - }; - V1625::ListType(e1625) - } - 6 => { - let e1625 = { - let l1618 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1618 - }; - V1625::OptionType(e1625) - } - 7 => { - let e1625 = { - let l1619 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1621 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1619 { - 0 => None, - 1 => { - let e = { - let l1620 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1620 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1621 { - 0 => None, - 1 => { - let e = { - let l1622 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1622 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1625::ResultType(e1625) - } - 8 => V1625::PrimU8Type, - 9 => V1625::PrimU16Type, - 10 => V1625::PrimU32Type, - 11 => V1625::PrimU64Type, - 12 => V1625::PrimS8Type, - 13 => V1625::PrimS16Type, - 14 => V1625::PrimS32Type, - 15 => V1625::PrimS64Type, - 16 => V1625::PrimF32Type, - 17 => V1625::PrimF64Type, - 18 => V1625::PrimCharType, - 19 => V1625::PrimBoolType, - 20 => V1625::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1625 = { - let l1623 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1624 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1623 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1624 as u8, - ), - ) - }; - V1625::HandleType(e1625) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1578 { - 0 => None, - 1 => { - let e = { - let l1579 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1580 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1581 = l1580; - let bytes1581 = _rt::Vec::from_raw_parts( - l1579.cast(), - len1581, - len1581, - ); - _rt::string_lift(bytes1581) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1582 { - 0 => None, - 1 => { - let e = { - let l1583 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1584 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1585 = l1584; - let bytes1585 = _rt::Vec::from_raw_parts( - l1583.cast(), - len1585, - len1585, - ); - _rt::string_lift(bytes1585) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1625, - } - }; - result1626.push(e1626); - } - _rt::cabi_dealloc( - base1626, - len1626 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1626, - } - }; - V1641::ComponentModel(e1641) - } - 1 => { - let e1641 = { - let l1627 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1627 { - 0 => None, - 1 => { - let e = { - let l1628 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1629 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1633 = l1628; - let len1633 = l1629; - let mut result1633 = _rt::Vec::with_capacity(len1633); - for i in 0..len1633 { - let base = base1633 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1633 = { - let l1630 = *base.add(0).cast::<*mut u8>(); - let l1631 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1632 = l1631; - let bytes1632 = _rt::Vec::from_raw_parts( - l1630.cast(), - len1632, - len1632, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1632), - } - }; - result1633.push(e1633); - } - _rt::cabi_dealloc( - base1633, - len1633 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1633 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1641::UnstructuredText(e1641) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1641 = { - let l1634 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1634 { - 0 => None, - 1 => { - let e = { - let l1635 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1636 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1640 = l1635; - let len1640 = l1636; - let mut result1640 = _rt::Vec::with_capacity(len1640); - for i in 0..len1640 { - let base = base1640 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1640 = { - let l1637 = *base.add(0).cast::<*mut u8>(); - let l1638 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1639 = l1638; - let bytes1639 = _rt::Vec::from_raw_parts( - l1637.cast(), - len1639, - len1639, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1639), - } - }; - result1640.push(e1640); - } - _rt::cabi_dealloc( - base1640, - len1640 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1640 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1641::UnstructuredBinary(e1641) - } - }; - (_rt::string_lift(bytes1574), v1641) - }; - result1642.push(e1642); - } - _rt::cabi_dealloc( - base1642, - len1642 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1642 - }; - V1716::Tuple(e1716) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1716 = { - let l1643 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1644 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1715 = l1643; - let len1715 = l1644; - let mut result1715 = _rt::Vec::with_capacity(len1715); - for i in 0..len1715 { - let base = base1715 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1715 = { - let l1645 = *base.add(0).cast::<*mut u8>(); - let l1646 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1647 = l1646; - let bytes1647 = _rt::Vec::from_raw_parts( - l1645.cast(), - len1647, - len1647, - ); - let l1648 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1714; - let v1714 = match l1648 { - 0 => { - let e1714 = { - let l1649 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1650 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1699 = l1649; - let len1699 = l1650; - let mut result1699 = _rt::Vec::with_capacity(len1699); - for i in 0..len1699 { - let base = base1699 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1699 = { - let l1651 = i32::from(*base.add(0).cast::()); - let l1655 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1659 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1698; - let v1698 = match l1659 { - 0 => { - let e1698 = { - let l1660 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1661 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1666 = l1660; - let len1666 = l1661; - let mut result1666 = _rt::Vec::with_capacity(len1666); - for i in 0..len1666 { - let base = base1666 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1666 = { - let l1662 = *base.add(0).cast::<*mut u8>(); - let l1663 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1664 = l1663; - let bytes1664 = _rt::Vec::from_raw_parts( - l1662.cast(), - len1664, - len1664, - ); - let l1665 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1664), l1665) - }; - result1666.push(e1666); - } - _rt::cabi_dealloc( - base1666, - len1666 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1666 - }; - V1698::RecordType(e1698) - } - 1 => { - let e1698 = { - let l1667 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1668 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1674 = l1667; - let len1674 = l1668; - let mut result1674 = _rt::Vec::with_capacity(len1674); - for i in 0..len1674 { - let base = base1674 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1674 = { - let l1669 = *base.add(0).cast::<*mut u8>(); - let l1670 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1671 = l1670; - let bytes1671 = _rt::Vec::from_raw_parts( - l1669.cast(), - len1671, - len1671, - ); - let l1672 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1671), - match l1672 { - 0 => None, - 1 => { - let e = { - let l1673 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1673 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1674.push(e1674); - } - _rt::cabi_dealloc( - base1674, - len1674 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1674 - }; - V1698::VariantType(e1698) - } - 2 => { - let e1698 = { - let l1675 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1676 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1680 = l1675; - let len1680 = l1676; - let mut result1680 = _rt::Vec::with_capacity(len1680); - for i in 0..len1680 { - let base = base1680 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1680 = { - let l1677 = *base.add(0).cast::<*mut u8>(); - let l1678 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1679 = l1678; - let bytes1679 = _rt::Vec::from_raw_parts( - l1677.cast(), - len1679, - len1679, - ); - _rt::string_lift(bytes1679) - }; - result1680.push(e1680); - } - _rt::cabi_dealloc( - base1680, - len1680 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1680 - }; - V1698::EnumType(e1698) - } - 3 => { - let e1698 = { - let l1681 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1682 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1686 = l1681; - let len1686 = l1682; - let mut result1686 = _rt::Vec::with_capacity(len1686); - for i in 0..len1686 { - let base = base1686 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1686 = { - let l1683 = *base.add(0).cast::<*mut u8>(); - let l1684 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1685 = l1684; - let bytes1685 = _rt::Vec::from_raw_parts( - l1683.cast(), - len1685, - len1685, - ); - _rt::string_lift(bytes1685) - }; - result1686.push(e1686); - } - _rt::cabi_dealloc( - base1686, - len1686 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1686 - }; - V1698::FlagsType(e1698) - } - 4 => { - let e1698 = { - let l1687 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1688 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1689 = l1688; - _rt::Vec::from_raw_parts(l1687.cast(), len1689, len1689) - }; - V1698::TupleType(e1698) - } - 5 => { - let e1698 = { - let l1690 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1690 - }; - V1698::ListType(e1698) - } - 6 => { - let e1698 = { - let l1691 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1691 - }; - V1698::OptionType(e1698) - } - 7 => { - let e1698 = { - let l1692 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1694 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1692 { - 0 => None, - 1 => { - let e = { - let l1693 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1693 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1694 { - 0 => None, - 1 => { - let e = { - let l1695 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1695 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1698::ResultType(e1698) - } - 8 => V1698::PrimU8Type, - 9 => V1698::PrimU16Type, - 10 => V1698::PrimU32Type, - 11 => V1698::PrimU64Type, - 12 => V1698::PrimS8Type, - 13 => V1698::PrimS16Type, - 14 => V1698::PrimS32Type, - 15 => V1698::PrimS64Type, - 16 => V1698::PrimF32Type, - 17 => V1698::PrimF64Type, - 18 => V1698::PrimCharType, - 19 => V1698::PrimBoolType, - 20 => V1698::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1698 = { - let l1696 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1697 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1696 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1697 as u8, - ), - ) - }; - V1698::HandleType(e1698) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1651 { - 0 => None, - 1 => { - let e = { - let l1652 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1653 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1654 = l1653; - let bytes1654 = _rt::Vec::from_raw_parts( - l1652.cast(), - len1654, - len1654, - ); - _rt::string_lift(bytes1654) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1655 { - 0 => None, - 1 => { - let e = { - let l1656 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1657 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1658 = l1657; - let bytes1658 = _rt::Vec::from_raw_parts( - l1656.cast(), - len1658, - len1658, - ); - _rt::string_lift(bytes1658) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1698, - } - }; - result1699.push(e1699); - } - _rt::cabi_dealloc( - base1699, - len1699 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1699, - } - }; - V1714::ComponentModel(e1714) - } - 1 => { - let e1714 = { - let l1700 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1700 { - 0 => None, - 1 => { - let e = { - let l1701 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1702 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1706 = l1701; - let len1706 = l1702; - let mut result1706 = _rt::Vec::with_capacity(len1706); - for i in 0..len1706 { - let base = base1706 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1706 = { - let l1703 = *base.add(0).cast::<*mut u8>(); - let l1704 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1705 = l1704; - let bytes1705 = _rt::Vec::from_raw_parts( - l1703.cast(), - len1705, - len1705, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1705), - } - }; - result1706.push(e1706); - } - _rt::cabi_dealloc( - base1706, - len1706 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1706 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1714::UnstructuredText(e1714) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1714 = { - let l1707 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1707 { - 0 => None, - 1 => { - let e = { - let l1708 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1709 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1713 = l1708; - let len1713 = l1709; - let mut result1713 = _rt::Vec::with_capacity(len1713); - for i in 0..len1713 { - let base = base1713 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1713 = { - let l1710 = *base.add(0).cast::<*mut u8>(); - let l1711 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1712 = l1711; - let bytes1712 = _rt::Vec::from_raw_parts( - l1710.cast(), - len1712, - len1712, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1712), - } - }; - result1713.push(e1713); - } - _rt::cabi_dealloc( - base1713, - len1713 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1713 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1714::UnstructuredBinary(e1714) - } - }; - (_rt::string_lift(bytes1647), v1714) - }; - result1715.push(e1715); - } - _rt::cabi_dealloc( - base1715, - len1715 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1715 - }; - V1716::Multimodal(e1716) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1568, - schema: v1716, - }, - } - }; - AgentInvocationResult::AgentMethod(e1731) - } - 2 => AgentInvocationResult::ManualUpdate, - 3 => { - let e1731 = { - let l1717 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1717 { - 0 => None, - 1 => { - let e = { - let l1718 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1719 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1720 = l1719; - let bytes1720 = _rt::Vec::from_raw_parts( - l1718.cast(), - len1720, - len1720, - ); - _rt::string_lift(bytes1720) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::LoadSnapshot(e1731) - } - 4 => { - let e1731 = { - let l1721 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1722 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1723 = l1722; - let l1724 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1725 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1726 = l1725; - let bytes1726 = _rt::Vec::from_raw_parts( - l1724.cast(), - len1726, - len1726, - ); - SaveSnapshotResultParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1721.cast(), - len1723, - len1723, - ), - mime_type: _rt::string_lift(bytes1726), - }, - } - }; - AgentInvocationResult::SaveSnapshot(e1731) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1731 = { - let l1727 = i32::from( - *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1727 { - 0 => None, - 1 => { - let e = { - let l1728 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1729 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1730 = l1729; - let bytes1730 = _rt::Vec::from_raw_parts( - l1728.cast(), - len1730, - len1730, - ); - _rt::string_lift(bytes1730) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::ProcessOplogEntries(e1731) - } - }; - let l1732 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1733 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - AgentInvocationFinishedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1104 as u64, - nanoseconds: l1105 as u32, - }, - invocation_result: v1731, - consumed_fuel: l1732, - component_revision: l1733 as u64, - } - }; - PublicOplogEntry::AgentInvocationFinished(e2675) - } - 4 => { - let e2675 = { - let l1734 = *base.add(8).cast::(); - let l1735 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1734 as u64, - nanoseconds: l1735 as u32, - }, - } - }; - PublicOplogEntry::Suspend(e2675) - } - 5 => { - let e2675 = { - let l1736 = *base.add(8).cast::(); - let l1737 = *base.add(16).cast::(); - let l1738 = *base.add(24).cast::<*mut u8>(); - let l1739 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1740 = l1739; - let bytes1740 = _rt::Vec::from_raw_parts( - l1738.cast(), - len1740, - len1740, - ); - let l1741 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ErrorParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1736 as u64, - nanoseconds: l1737 as u32, - }, - error: _rt::string_lift(bytes1740), - retry_from: l1741 as u64, - } - }; - PublicOplogEntry::Error(e2675) - } - 6 => { - let e2675 = { - let l1742 = *base.add(8).cast::(); - let l1743 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1742 as u64, - nanoseconds: l1743 as u32, - }, - } - }; - PublicOplogEntry::NoOp(e2675) - } - 7 => { - let e2675 = { - let l1744 = *base.add(8).cast::(); - let l1745 = *base.add(16).cast::(); - let l1746 = *base.add(24).cast::(); - let l1747 = *base.add(32).cast::(); - JumpParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1744 as u64, - nanoseconds: l1745 as u32, - }, - jump: OplogRegion { - start: l1746 as u64, - end: l1747 as u64, - }, - } - }; - PublicOplogEntry::Jump(e2675) - } - 8 => { - let e2675 = { - let l1748 = *base.add(8).cast::(); - let l1749 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1748 as u64, - nanoseconds: l1749 as u32, - }, - } - }; - PublicOplogEntry::Interrupted(e2675) - } - 9 => { - let e2675 = { - let l1750 = *base.add(8).cast::(); - let l1751 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1750 as u64, - nanoseconds: l1751 as u32, - }, - } - }; - PublicOplogEntry::Exited(e2675) - } - 10 => { - let e2675 = { - let l1752 = *base.add(8).cast::(); - let l1753 = *base.add(16).cast::(); - let l1754 = *base.add(24).cast::(); - let l1755 = *base.add(32).cast::(); - let l1756 = *base.add(40).cast::(); - let l1757 = *base.add(48).cast::(); - let l1758 = i32::from(*base.add(56).cast::()); - ChangeRetryPolicyParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1752 as u64, - nanoseconds: l1753 as u32, - }, - new_policy: super::super::super::golem::api::host::RetryPolicy { - max_attempts: l1754 as u32, - min_delay: l1755 as u64, - max_delay: l1756 as u64, - multiplier: l1757, - max_jitter_factor: match l1758 { - 0 => None, - 1 => { - let e = { - let l1759 = *base.add(64).cast::(); - l1759 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - }, - } - }; - PublicOplogEntry::ChangeRetryPolicy(e2675) - } - 11 => { - let e2675 = { - let l1760 = *base.add(8).cast::(); - let l1761 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1760 as u64, - nanoseconds: l1761 as u32, - }, - } - }; - PublicOplogEntry::BeginAtomicRegion(e2675) - } - 12 => { - let e2675 = { - let l1762 = *base.add(8).cast::(); - let l1763 = *base.add(16).cast::(); - let l1764 = *base.add(24).cast::(); - EndAtomicRegionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1762 as u64, - nanoseconds: l1763 as u32, - }, - begin_index: l1764 as u64, - } - }; - PublicOplogEntry::EndAtomicRegion(e2675) - } - 13 => { - let e2675 = { - let l1765 = *base.add(8).cast::(); - let l1766 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1765 as u64, - nanoseconds: l1766 as u32, - }, - } - }; - PublicOplogEntry::BeginRemoteWrite(e2675) - } - 14 => { - let e2675 = { - let l1767 = *base.add(8).cast::(); - let l1768 = *base.add(16).cast::(); - let l1769 = *base.add(24).cast::(); - EndRemoteWriteParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1767 as u64, - nanoseconds: l1768 as u32, - }, - begin_index: l1769 as u64, - } - }; - PublicOplogEntry::EndRemoteWrite(e2675) - } - 15 => { - let e2675 = { - let l1770 = *base.add(8).cast::(); - let l1771 = *base.add(16).cast::(); - let l1772 = i32::from(*base.add(24).cast::()); - let v2488 = match l1772 { - 0 => { - let e2488 = { - let l1773 = *base.add(32).cast::<*mut u8>(); - let l1774 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1775 = l1774; - let bytes1775 = _rt::Vec::from_raw_parts( - l1773.cast(), - len1775, - len1775, - ); - let l1776 = i32::from( - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1932; - let v1932 = match l1776 { - 0 => { - let e1932 = { - let l1777 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1778 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1852 = l1777; - let len1852 = l1778; - let mut result1852 = _rt::Vec::with_capacity(len1852); - for i in 0..len1852 { - let base = base1852 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1852 = { - let l1779 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1851; - let v1851 = match l1779 { - 0 => { - let e1851 = { - let l1780 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1781 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1827 = l1780; - let len1827 = l1781; - let mut result1827 = _rt::Vec::with_capacity(len1827); - for i in 0..len1827 { - let base = base1827 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1827 = { - let l1782 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1826; - let v1826 = match l1782 { - 0 => { - let e1826 = { - let l1783 = *base.add(8).cast::<*mut u8>(); - let l1784 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1785 = l1784; - _rt::Vec::from_raw_parts(l1783.cast(), len1785, len1785) - }; - V1826::RecordValue(e1826) - } - 1 => { - let e1826 = { - let l1786 = *base.add(8).cast::(); - let l1787 = i32::from(*base.add(12).cast::()); - ( - l1786 as u32, - match l1787 { - 0 => None, - 1 => { - let e = { - let l1788 = *base.add(16).cast::(); - l1788 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1826::VariantValue(e1826) - } - 2 => { - let e1826 = { - let l1789 = *base.add(8).cast::(); - l1789 as u32 - }; - V1826::EnumValue(e1826) - } - 3 => { - let e1826 = { - let l1790 = *base.add(8).cast::<*mut u8>(); - let l1791 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1793 = l1790; - let len1793 = l1791; - let mut result1793 = _rt::Vec::with_capacity(len1793); - for i in 0..len1793 { - let base = base1793.add(i * 1); - let e1793 = { - let l1792 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1792 as u8) - }; - result1793.push(e1793); - } - _rt::cabi_dealloc(base1793, len1793 * 1, 1); - result1793 - }; - V1826::FlagsValue(e1826) - } - 4 => { - let e1826 = { - let l1794 = *base.add(8).cast::<*mut u8>(); - let l1795 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1796 = l1795; - _rt::Vec::from_raw_parts(l1794.cast(), len1796, len1796) - }; - V1826::TupleValue(e1826) - } - 5 => { - let e1826 = { - let l1797 = *base.add(8).cast::<*mut u8>(); - let l1798 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1799 = l1798; - _rt::Vec::from_raw_parts(l1797.cast(), len1799, len1799) - }; - V1826::ListValue(e1826) - } - 6 => { - let e1826 = { - let l1800 = i32::from(*base.add(8).cast::()); - match l1800 { - 0 => None, - 1 => { - let e = { - let l1801 = *base.add(12).cast::(); - l1801 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1826::OptionValue(e1826) - } - 7 => { - let e1826 = { - let l1802 = i32::from(*base.add(8).cast::()); - match l1802 { - 0 => { - let e = { - let l1803 = i32::from(*base.add(12).cast::()); - match l1803 { - 0 => None, - 1 => { - let e = { - let l1804 = *base.add(16).cast::(); - l1804 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1805 = i32::from(*base.add(12).cast::()); - match l1805 { - 0 => None, - 1 => { - let e = { - let l1806 = *base.add(16).cast::(); - l1806 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1826::ResultValue(e1826) - } - 8 => { - let e1826 = { - let l1807 = i32::from(*base.add(8).cast::()); - l1807 as u8 - }; - V1826::PrimU8(e1826) - } - 9 => { - let e1826 = { - let l1808 = i32::from(*base.add(8).cast::()); - l1808 as u16 - }; - V1826::PrimU16(e1826) - } - 10 => { - let e1826 = { - let l1809 = *base.add(8).cast::(); - l1809 as u32 - }; - V1826::PrimU32(e1826) - } - 11 => { - let e1826 = { - let l1810 = *base.add(8).cast::(); - l1810 as u64 - }; - V1826::PrimU64(e1826) - } - 12 => { - let e1826 = { - let l1811 = i32::from(*base.add(8).cast::()); - l1811 as i8 - }; - V1826::PrimS8(e1826) - } - 13 => { - let e1826 = { - let l1812 = i32::from(*base.add(8).cast::()); - l1812 as i16 - }; - V1826::PrimS16(e1826) - } - 14 => { - let e1826 = { - let l1813 = *base.add(8).cast::(); - l1813 - }; - V1826::PrimS32(e1826) - } - 15 => { - let e1826 = { - let l1814 = *base.add(8).cast::(); - l1814 - }; - V1826::PrimS64(e1826) - } - 16 => { - let e1826 = { - let l1815 = *base.add(8).cast::(); - l1815 - }; - V1826::PrimFloat32(e1826) - } - 17 => { - let e1826 = { - let l1816 = *base.add(8).cast::(); - l1816 - }; - V1826::PrimFloat64(e1826) - } - 18 => { - let e1826 = { - let l1817 = *base.add(8).cast::(); - _rt::char_lift(l1817 as u32) - }; - V1826::PrimChar(e1826) - } - 19 => { - let e1826 = { - let l1818 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1818 as u8) - }; - V1826::PrimBool(e1826) - } - 20 => { - let e1826 = { - let l1819 = *base.add(8).cast::<*mut u8>(); - let l1820 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1821 = l1820; - let bytes1821 = _rt::Vec::from_raw_parts( - l1819.cast(), - len1821, - len1821, - ); - _rt::string_lift(bytes1821) - }; - V1826::PrimString(e1826) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1826 = { - let l1822 = *base.add(8).cast::<*mut u8>(); - let l1823 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1824 = l1823; - let bytes1824 = _rt::Vec::from_raw_parts( - l1822.cast(), - len1824, - len1824, - ); - let l1825 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1824), - }, - l1825 as u64, - ) - }; - V1826::Handle(e1826) - } - }; - v1826 - }; - result1827.push(e1827); - } - _rt::cabi_dealloc( - base1827, - len1827 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1827, - } - }; - V1851::ComponentModel(e1851) - } - 1 => { - let e1851 = { - let l1828 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1839; - let v1839 = match l1828 { - 0 => { - let e1839 = { - let l1829 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1830 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1831 = l1830; - let bytes1831 = _rt::Vec::from_raw_parts( - l1829.cast(), - len1831, - len1831, - ); - _rt::string_lift(bytes1831) - }; - V1839::Url(e1839) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1839 = { - let l1832 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1833 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1834 = l1833; - let bytes1834 = _rt::Vec::from_raw_parts( - l1832.cast(), - len1834, - len1834, - ); - let l1835 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1834), - text_type: match l1835 { - 0 => None, - 1 => { - let e = { - let l1836 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1837 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1838 = l1837; - let bytes1838 = _rt::Vec::from_raw_parts( - l1836.cast(), - len1838, - len1838, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1838), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1839::Inline(e1839) - } - }; - v1839 - }; - V1851::UnstructuredText(e1851) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1851 = { - let l1840 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1850; - let v1850 = match l1840 { - 0 => { - let e1850 = { - let l1841 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1842 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1843 = l1842; - let bytes1843 = _rt::Vec::from_raw_parts( - l1841.cast(), - len1843, - len1843, - ); - _rt::string_lift(bytes1843) - }; - V1850::Url(e1850) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1850 = { - let l1844 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1845 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1846 = l1845; - let l1847 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1848 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1849 = l1848; - let bytes1849 = _rt::Vec::from_raw_parts( - l1847.cast(), - len1849, - len1849, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1844.cast(), - len1846, - len1846, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1849), - }, - } - }; - V1850::Inline(e1850) - } - }; - v1850 - }; - V1851::UnstructuredBinary(e1851) - } - }; - v1851 - }; - result1852.push(e1852); - } - _rt::cabi_dealloc( - base1852, - len1852 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1852 - }; - V1932::Tuple(e1932) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1932 = { - let l1853 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1854 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1931 = l1853; - let len1931 = l1854; - let mut result1931 = _rt::Vec::with_capacity(len1931); - for i in 0..len1931 { - let base = base1931 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1931 = { - let l1855 = *base.add(0).cast::<*mut u8>(); - let l1856 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1857 = l1856; - let bytes1857 = _rt::Vec::from_raw_parts( - l1855.cast(), - len1857, - len1857, - ); - let l1858 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1930; - let v1930 = match l1858 { - 0 => { - let e1930 = { - let l1859 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1860 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1906 = l1859; - let len1906 = l1860; - let mut result1906 = _rt::Vec::with_capacity(len1906); - for i in 0..len1906 { - let base = base1906 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1906 = { - let l1861 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1905; - let v1905 = match l1861 { - 0 => { - let e1905 = { - let l1862 = *base.add(8).cast::<*mut u8>(); - let l1863 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1864 = l1863; - _rt::Vec::from_raw_parts(l1862.cast(), len1864, len1864) - }; - V1905::RecordValue(e1905) - } - 1 => { - let e1905 = { - let l1865 = *base.add(8).cast::(); - let l1866 = i32::from(*base.add(12).cast::()); - ( - l1865 as u32, - match l1866 { - 0 => None, - 1 => { - let e = { - let l1867 = *base.add(16).cast::(); - l1867 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1905::VariantValue(e1905) - } - 2 => { - let e1905 = { - let l1868 = *base.add(8).cast::(); - l1868 as u32 - }; - V1905::EnumValue(e1905) - } - 3 => { - let e1905 = { - let l1869 = *base.add(8).cast::<*mut u8>(); - let l1870 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1872 = l1869; - let len1872 = l1870; - let mut result1872 = _rt::Vec::with_capacity(len1872); - for i in 0..len1872 { - let base = base1872.add(i * 1); - let e1872 = { - let l1871 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1871 as u8) - }; - result1872.push(e1872); - } - _rt::cabi_dealloc(base1872, len1872 * 1, 1); - result1872 - }; - V1905::FlagsValue(e1905) - } - 4 => { - let e1905 = { - let l1873 = *base.add(8).cast::<*mut u8>(); - let l1874 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1875 = l1874; - _rt::Vec::from_raw_parts(l1873.cast(), len1875, len1875) - }; - V1905::TupleValue(e1905) - } - 5 => { - let e1905 = { - let l1876 = *base.add(8).cast::<*mut u8>(); - let l1877 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1878 = l1877; - _rt::Vec::from_raw_parts(l1876.cast(), len1878, len1878) - }; - V1905::ListValue(e1905) - } - 6 => { - let e1905 = { - let l1879 = i32::from(*base.add(8).cast::()); - match l1879 { - 0 => None, - 1 => { - let e = { - let l1880 = *base.add(12).cast::(); - l1880 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1905::OptionValue(e1905) - } - 7 => { - let e1905 = { - let l1881 = i32::from(*base.add(8).cast::()); - match l1881 { - 0 => { - let e = { - let l1882 = i32::from(*base.add(12).cast::()); - match l1882 { - 0 => None, - 1 => { - let e = { - let l1883 = *base.add(16).cast::(); - l1883 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1884 = i32::from(*base.add(12).cast::()); - match l1884 { - 0 => None, - 1 => { - let e = { - let l1885 = *base.add(16).cast::(); - l1885 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1905::ResultValue(e1905) - } - 8 => { - let e1905 = { - let l1886 = i32::from(*base.add(8).cast::()); - l1886 as u8 - }; - V1905::PrimU8(e1905) - } - 9 => { - let e1905 = { - let l1887 = i32::from(*base.add(8).cast::()); - l1887 as u16 - }; - V1905::PrimU16(e1905) - } - 10 => { - let e1905 = { - let l1888 = *base.add(8).cast::(); - l1888 as u32 - }; - V1905::PrimU32(e1905) - } - 11 => { - let e1905 = { - let l1889 = *base.add(8).cast::(); - l1889 as u64 - }; - V1905::PrimU64(e1905) - } - 12 => { - let e1905 = { - let l1890 = i32::from(*base.add(8).cast::()); - l1890 as i8 - }; - V1905::PrimS8(e1905) - } - 13 => { - let e1905 = { - let l1891 = i32::from(*base.add(8).cast::()); - l1891 as i16 - }; - V1905::PrimS16(e1905) - } - 14 => { - let e1905 = { - let l1892 = *base.add(8).cast::(); - l1892 - }; - V1905::PrimS32(e1905) - } - 15 => { - let e1905 = { - let l1893 = *base.add(8).cast::(); - l1893 - }; - V1905::PrimS64(e1905) - } - 16 => { - let e1905 = { - let l1894 = *base.add(8).cast::(); - l1894 - }; - V1905::PrimFloat32(e1905) - } - 17 => { - let e1905 = { - let l1895 = *base.add(8).cast::(); - l1895 - }; - V1905::PrimFloat64(e1905) - } - 18 => { - let e1905 = { - let l1896 = *base.add(8).cast::(); - _rt::char_lift(l1896 as u32) - }; - V1905::PrimChar(e1905) - } - 19 => { - let e1905 = { - let l1897 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1897 as u8) - }; - V1905::PrimBool(e1905) - } - 20 => { - let e1905 = { - let l1898 = *base.add(8).cast::<*mut u8>(); - let l1899 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1900 = l1899; - let bytes1900 = _rt::Vec::from_raw_parts( - l1898.cast(), - len1900, - len1900, - ); - _rt::string_lift(bytes1900) - }; - V1905::PrimString(e1905) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1905 = { - let l1901 = *base.add(8).cast::<*mut u8>(); - let l1902 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1903 = l1902; - let bytes1903 = _rt::Vec::from_raw_parts( - l1901.cast(), - len1903, - len1903, - ); - let l1904 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1903), - }, - l1904 as u64, - ) - }; - V1905::Handle(e1905) - } - }; - v1905 - }; - result1906.push(e1906); - } - _rt::cabi_dealloc( - base1906, - len1906 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1906, - } - }; - V1930::ComponentModel(e1930) - } - 1 => { - let e1930 = { - let l1907 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1918; - let v1918 = match l1907 { - 0 => { - let e1918 = { - let l1908 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1909 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1910 = l1909; - let bytes1910 = _rt::Vec::from_raw_parts( - l1908.cast(), - len1910, - len1910, - ); - _rt::string_lift(bytes1910) - }; - V1918::Url(e1918) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1918 = { - let l1911 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1912 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1913 = l1912; - let bytes1913 = _rt::Vec::from_raw_parts( - l1911.cast(), - len1913, - len1913, - ); - let l1914 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1913), - text_type: match l1914 { - 0 => None, - 1 => { - let e = { - let l1915 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1916 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1917 = l1916; - let bytes1917 = _rt::Vec::from_raw_parts( - l1915.cast(), - len1917, - len1917, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1917), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1918::Inline(e1918) - } - }; - v1918 - }; - V1930::UnstructuredText(e1930) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1930 = { - let l1919 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1929; - let v1929 = match l1919 { - 0 => { - let e1929 = { - let l1920 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1921 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1922 = l1921; - let bytes1922 = _rt::Vec::from_raw_parts( - l1920.cast(), - len1922, - len1922, - ); - _rt::string_lift(bytes1922) - }; - V1929::Url(e1929) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1929 = { - let l1923 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1924 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1925 = l1924; - let l1926 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1927 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1928 = l1927; - let bytes1928 = _rt::Vec::from_raw_parts( - l1926.cast(), - len1928, - len1928, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1923.cast(), - len1925, - len1925, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1928), - }, - } - }; - V1929::Inline(e1929) - } - }; - v1929 - }; - V1930::UnstructuredBinary(e1930) - } - }; - (_rt::string_lift(bytes1857), v1930) - }; - result1931.push(e1931); - } - _rt::cabi_dealloc( - base1931, - len1931 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1931 - }; - V1932::Multimodal(e1932) - } - }; - let l1933 = i32::from( - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2080; - let v2080 = match l1933 { - 0 => { - let e2080 = { - let l1934 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1935 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2006 = l1934; - let len2006 = l1935; - let mut result2006 = _rt::Vec::with_capacity(len2006); - for i in 0..len2006 { - let base = base2006 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2006 = { - let l1936 = *base.add(0).cast::<*mut u8>(); - let l1937 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1938 = l1937; - let bytes1938 = _rt::Vec::from_raw_parts( - l1936.cast(), - len1938, - len1938, - ); - let l1939 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2005; - let v2005 = match l1939 { - 0 => { - let e2005 = { - let l1940 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1941 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1990 = l1940; - let len1990 = l1941; - let mut result1990 = _rt::Vec::with_capacity(len1990); - for i in 0..len1990 { - let base = base1990 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1990 = { - let l1942 = i32::from(*base.add(0).cast::()); - let l1946 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1950 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1989; - let v1989 = match l1950 { - 0 => { - let e1989 = { - let l1951 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1952 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1957 = l1951; - let len1957 = l1952; - let mut result1957 = _rt::Vec::with_capacity(len1957); - for i in 0..len1957 { - let base = base1957 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1957 = { - let l1953 = *base.add(0).cast::<*mut u8>(); - let l1954 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1955 = l1954; - let bytes1955 = _rt::Vec::from_raw_parts( - l1953.cast(), - len1955, - len1955, - ); - let l1956 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1955), l1956) - }; - result1957.push(e1957); - } - _rt::cabi_dealloc( - base1957, - len1957 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1957 - }; - V1989::RecordType(e1989) - } - 1 => { - let e1989 = { - let l1958 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1959 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1965 = l1958; - let len1965 = l1959; - let mut result1965 = _rt::Vec::with_capacity(len1965); - for i in 0..len1965 { - let base = base1965 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1965 = { - let l1960 = *base.add(0).cast::<*mut u8>(); - let l1961 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1962 = l1961; - let bytes1962 = _rt::Vec::from_raw_parts( - l1960.cast(), - len1962, - len1962, - ); - let l1963 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1962), - match l1963 { - 0 => None, - 1 => { - let e = { - let l1964 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1964 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1965.push(e1965); - } - _rt::cabi_dealloc( - base1965, - len1965 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1965 - }; - V1989::VariantType(e1989) - } - 2 => { - let e1989 = { - let l1966 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1967 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1971 = l1966; - let len1971 = l1967; - let mut result1971 = _rt::Vec::with_capacity(len1971); - for i in 0..len1971 { - let base = base1971 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1971 = { - let l1968 = *base.add(0).cast::<*mut u8>(); - let l1969 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1970 = l1969; - let bytes1970 = _rt::Vec::from_raw_parts( - l1968.cast(), - len1970, - len1970, - ); - _rt::string_lift(bytes1970) - }; - result1971.push(e1971); - } - _rt::cabi_dealloc( - base1971, - len1971 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1971 - }; - V1989::EnumType(e1989) - } - 3 => { - let e1989 = { - let l1972 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1973 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1977 = l1972; - let len1977 = l1973; - let mut result1977 = _rt::Vec::with_capacity(len1977); - for i in 0..len1977 { - let base = base1977 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1977 = { - let l1974 = *base.add(0).cast::<*mut u8>(); - let l1975 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1976 = l1975; - let bytes1976 = _rt::Vec::from_raw_parts( - l1974.cast(), - len1976, - len1976, - ); - _rt::string_lift(bytes1976) - }; - result1977.push(e1977); - } - _rt::cabi_dealloc( - base1977, - len1977 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1977 - }; - V1989::FlagsType(e1989) - } - 4 => { - let e1989 = { - let l1978 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1979 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1980 = l1979; - _rt::Vec::from_raw_parts(l1978.cast(), len1980, len1980) - }; - V1989::TupleType(e1989) - } - 5 => { - let e1989 = { - let l1981 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1981 - }; - V1989::ListType(e1989) - } - 6 => { - let e1989 = { - let l1982 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1982 - }; - V1989::OptionType(e1989) - } - 7 => { - let e1989 = { - let l1983 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1985 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1983 { - 0 => None, - 1 => { - let e = { - let l1984 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1984 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1985 { - 0 => None, - 1 => { - let e = { - let l1986 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1986 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1989::ResultType(e1989) - } - 8 => V1989::PrimU8Type, - 9 => V1989::PrimU16Type, - 10 => V1989::PrimU32Type, - 11 => V1989::PrimU64Type, - 12 => V1989::PrimS8Type, - 13 => V1989::PrimS16Type, - 14 => V1989::PrimS32Type, - 15 => V1989::PrimS64Type, - 16 => V1989::PrimF32Type, - 17 => V1989::PrimF64Type, - 18 => V1989::PrimCharType, - 19 => V1989::PrimBoolType, - 20 => V1989::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1989 = { - let l1987 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1988 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1987 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1988 as u8, - ), - ) - }; - V1989::HandleType(e1989) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1942 { - 0 => None, - 1 => { - let e = { - let l1943 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1944 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1945 = l1944; - let bytes1945 = _rt::Vec::from_raw_parts( - l1943.cast(), - len1945, - len1945, - ); - _rt::string_lift(bytes1945) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1946 { - 0 => None, - 1 => { - let e = { - let l1947 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1948 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1949 = l1948; - let bytes1949 = _rt::Vec::from_raw_parts( - l1947.cast(), - len1949, - len1949, - ); - _rt::string_lift(bytes1949) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1989, - } - }; - result1990.push(e1990); - } - _rt::cabi_dealloc( - base1990, - len1990 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1990, - } - }; - V2005::ComponentModel(e2005) - } - 1 => { - let e2005 = { - let l1991 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1991 { - 0 => None, - 1 => { - let e = { - let l1992 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1993 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1997 = l1992; - let len1997 = l1993; - let mut result1997 = _rt::Vec::with_capacity(len1997); - for i in 0..len1997 { - let base = base1997 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1997 = { - let l1994 = *base.add(0).cast::<*mut u8>(); - let l1995 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1996 = l1995; - let bytes1996 = _rt::Vec::from_raw_parts( - l1994.cast(), - len1996, - len1996, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1996), - } - }; - result1997.push(e1997); - } - _rt::cabi_dealloc( - base1997, - len1997 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1997 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2005::UnstructuredText(e2005) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2005 = { - let l1998 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1998 { - 0 => None, - 1 => { - let e = { - let l1999 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2000 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2004 = l1999; - let len2004 = l2000; - let mut result2004 = _rt::Vec::with_capacity(len2004); - for i in 0..len2004 { - let base = base2004 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2004 = { - let l2001 = *base.add(0).cast::<*mut u8>(); - let l2002 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2003 = l2002; - let bytes2003 = _rt::Vec::from_raw_parts( - l2001.cast(), - len2003, - len2003, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2003), - } - }; - result2004.push(e2004); - } - _rt::cabi_dealloc( - base2004, - len2004 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2004 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2005::UnstructuredBinary(e2005) - } - }; - (_rt::string_lift(bytes1938), v2005) - }; - result2006.push(e2006); - } - _rt::cabi_dealloc( - base2006, - len2006 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2006 - }; - V2080::Tuple(e2080) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2080 = { - let l2007 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2008 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2079 = l2007; - let len2079 = l2008; - let mut result2079 = _rt::Vec::with_capacity(len2079); - for i in 0..len2079 { - let base = base2079 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2079 = { - let l2009 = *base.add(0).cast::<*mut u8>(); - let l2010 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2011 = l2010; - let bytes2011 = _rt::Vec::from_raw_parts( - l2009.cast(), - len2011, - len2011, - ); - let l2012 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2078; - let v2078 = match l2012 { - 0 => { - let e2078 = { - let l2013 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2014 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2063 = l2013; - let len2063 = l2014; - let mut result2063 = _rt::Vec::with_capacity(len2063); - for i in 0..len2063 { - let base = base2063 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2063 = { - let l2015 = i32::from(*base.add(0).cast::()); - let l2019 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2023 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2062; - let v2062 = match l2023 { - 0 => { - let e2062 = { - let l2024 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2025 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2030 = l2024; - let len2030 = l2025; - let mut result2030 = _rt::Vec::with_capacity(len2030); - for i in 0..len2030 { - let base = base2030 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2030 = { - let l2026 = *base.add(0).cast::<*mut u8>(); - let l2027 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2028 = l2027; - let bytes2028 = _rt::Vec::from_raw_parts( - l2026.cast(), - len2028, - len2028, - ); - let l2029 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2028), l2029) - }; - result2030.push(e2030); - } - _rt::cabi_dealloc( - base2030, - len2030 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2030 - }; - V2062::RecordType(e2062) - } - 1 => { - let e2062 = { - let l2031 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2032 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2038 = l2031; - let len2038 = l2032; - let mut result2038 = _rt::Vec::with_capacity(len2038); - for i in 0..len2038 { - let base = base2038 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2038 = { - let l2033 = *base.add(0).cast::<*mut u8>(); - let l2034 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2035 = l2034; - let bytes2035 = _rt::Vec::from_raw_parts( - l2033.cast(), - len2035, - len2035, - ); - let l2036 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2035), - match l2036 { - 0 => None, - 1 => { - let e = { - let l2037 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2037 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2038.push(e2038); - } - _rt::cabi_dealloc( - base2038, - len2038 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2038 - }; - V2062::VariantType(e2062) - } - 2 => { - let e2062 = { - let l2039 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2040 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2044 = l2039; - let len2044 = l2040; - let mut result2044 = _rt::Vec::with_capacity(len2044); - for i in 0..len2044 { - let base = base2044 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2044 = { - let l2041 = *base.add(0).cast::<*mut u8>(); - let l2042 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2043 = l2042; - let bytes2043 = _rt::Vec::from_raw_parts( - l2041.cast(), - len2043, - len2043, - ); - _rt::string_lift(bytes2043) - }; - result2044.push(e2044); - } - _rt::cabi_dealloc( - base2044, - len2044 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2044 - }; - V2062::EnumType(e2062) - } - 3 => { - let e2062 = { - let l2045 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2046 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2050 = l2045; - let len2050 = l2046; - let mut result2050 = _rt::Vec::with_capacity(len2050); - for i in 0..len2050 { - let base = base2050 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2050 = { - let l2047 = *base.add(0).cast::<*mut u8>(); - let l2048 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2049 = l2048; - let bytes2049 = _rt::Vec::from_raw_parts( - l2047.cast(), - len2049, - len2049, - ); - _rt::string_lift(bytes2049) - }; - result2050.push(e2050); - } - _rt::cabi_dealloc( - base2050, - len2050 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2050 - }; - V2062::FlagsType(e2062) - } - 4 => { - let e2062 = { - let l2051 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2052 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2053 = l2052; - _rt::Vec::from_raw_parts(l2051.cast(), len2053, len2053) - }; - V2062::TupleType(e2062) - } - 5 => { - let e2062 = { - let l2054 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2054 - }; - V2062::ListType(e2062) - } - 6 => { - let e2062 = { - let l2055 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2055 - }; - V2062::OptionType(e2062) - } - 7 => { - let e2062 = { - let l2056 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2058 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2056 { - 0 => None, - 1 => { - let e = { - let l2057 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2057 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2058 { - 0 => None, - 1 => { - let e = { - let l2059 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2059 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2062::ResultType(e2062) - } - 8 => V2062::PrimU8Type, - 9 => V2062::PrimU16Type, - 10 => V2062::PrimU32Type, - 11 => V2062::PrimU64Type, - 12 => V2062::PrimS8Type, - 13 => V2062::PrimS16Type, - 14 => V2062::PrimS32Type, - 15 => V2062::PrimS64Type, - 16 => V2062::PrimF32Type, - 17 => V2062::PrimF64Type, - 18 => V2062::PrimCharType, - 19 => V2062::PrimBoolType, - 20 => V2062::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2062 = { - let l2060 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2061 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2060 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2061 as u8, - ), - ) - }; - V2062::HandleType(e2062) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2015 { - 0 => None, - 1 => { - let e = { - let l2016 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2017 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2018 = l2017; - let bytes2018 = _rt::Vec::from_raw_parts( - l2016.cast(), - len2018, - len2018, - ); - _rt::string_lift(bytes2018) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2019 { - 0 => None, - 1 => { - let e = { - let l2020 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2021 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2022 = l2021; - let bytes2022 = _rt::Vec::from_raw_parts( - l2020.cast(), - len2022, - len2022, - ); - _rt::string_lift(bytes2022) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2062, - } - }; - result2063.push(e2063); - } - _rt::cabi_dealloc( - base2063, - len2063 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2063, - } - }; - V2078::ComponentModel(e2078) - } - 1 => { - let e2078 = { - let l2064 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2064 { - 0 => None, - 1 => { - let e = { - let l2065 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2066 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2070 = l2065; - let len2070 = l2066; - let mut result2070 = _rt::Vec::with_capacity(len2070); - for i in 0..len2070 { - let base = base2070 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2070 = { - let l2067 = *base.add(0).cast::<*mut u8>(); - let l2068 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2069 = l2068; - let bytes2069 = _rt::Vec::from_raw_parts( - l2067.cast(), - len2069, - len2069, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2069), - } - }; - result2070.push(e2070); - } - _rt::cabi_dealloc( - base2070, - len2070 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2070 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2078::UnstructuredText(e2078) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2078 = { - let l2071 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2071 { - 0 => None, - 1 => { - let e = { - let l2072 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2073 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2077 = l2072; - let len2077 = l2073; - let mut result2077 = _rt::Vec::with_capacity(len2077); - for i in 0..len2077 { - let base = base2077 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2077 = { - let l2074 = *base.add(0).cast::<*mut u8>(); - let l2075 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2076 = l2075; - let bytes2076 = _rt::Vec::from_raw_parts( - l2074.cast(), - len2076, - len2076, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2076), - } - }; - result2077.push(e2077); - } - _rt::cabi_dealloc( - base2077, - len2077 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2077 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2078::UnstructuredBinary(e2078) - } - }; - (_rt::string_lift(bytes2011), v2078) - }; - result2079.push(e2079); - } - _rt::cabi_dealloc( - base2079, - len2079 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2079 - }; - V2080::Multimodal(e2080) - } - }; - let l2081 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2082 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2083 = l2082; - let bytes2083 = _rt::Vec::from_raw_parts( - l2081.cast(), - len2083, - len2083, - ); - let l2084 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2085 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2089 = l2084; - let len2089 = l2085; - let mut result2089 = _rt::Vec::with_capacity(len2089); - for i in 0..len2089 { - let base = base2089 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2089 = { - let l2086 = *base.add(0).cast::<*mut u8>(); - let l2087 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2088 = l2087; - let bytes2088 = _rt::Vec::from_raw_parts( - l2086.cast(), - len2088, - len2088, - ); - _rt::string_lift(bytes2088) - }; - result2089.push(e2089); - } - _rt::cabi_dealloc( - base2089, - len2089 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2090 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2091 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2123 = l2090; - let len2123 = l2091; - let mut result2123 = _rt::Vec::with_capacity(len2123); - for i in 0..len2123 { - let base = base2123 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2123 = { - let l2092 = *base.add(0).cast::<*mut u8>(); - let l2093 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2122 = l2092; - let len2122 = l2093; - let mut result2122 = _rt::Vec::with_capacity(len2122); - for i in 0..len2122 { - let base = base2122 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2122 = { - let l2094 = i32::from(*base.add(0).cast::()); - let v2121 = match l2094 { - 0 => { - let e2121 = { - let l2095 = *base.add(8).cast::<*mut u8>(); - let l2096 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2097 = l2096; - let bytes2097 = _rt::Vec::from_raw_parts( - l2095.cast(), - len2097, - len2097, - ); - let l2098 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2099 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2100 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2104 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2106 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2107 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2116 = l2106; - let len2116 = l2107; - let mut result2116 = _rt::Vec::with_capacity(len2116); - for i in 0..len2116 { - let base = base2116 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2116 = { - let l2108 = *base.add(0).cast::<*mut u8>(); - let l2109 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2110 = l2109; - let bytes2110 = _rt::Vec::from_raw_parts( - l2108.cast(), - len2110, - len2110, - ); - let l2111 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2115; - let v2115 = match l2111 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2115 = { - let l2112 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2113 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2114 = l2113; - let bytes2114 = _rt::Vec::from_raw_parts( - l2112.cast(), - len2114, - len2114, - ); - _rt::string_lift(bytes2114) - }; - V2115::String(e2115) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2110), - value: v2115, - } - }; - result2116.push(e2116); - } - _rt::cabi_dealloc( - base2116, - len2116 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2117 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2097), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2098 as u64, - nanoseconds: l2099 as u32, - }, - parent: match l2100 { - 0 => None, - 1 => { - let e = { - let l2101 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2102 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2103 = l2102; - let bytes2103 = _rt::Vec::from_raw_parts( - l2101.cast(), - len2103, - len2103, - ); - _rt::string_lift(bytes2103) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2104 { - 0 => None, - 1 => { - let e = { - let l2105 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2105 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2116, - inherited: _rt::bool_lift(l2117 as u8), - } - }; - SpanData::LocalSpan(e2121) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2121 = { - let l2118 = *base.add(8).cast::<*mut u8>(); - let l2119 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2120 = l2119; - let bytes2120 = _rt::Vec::from_raw_parts( - l2118.cast(), - len2120, - len2120, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2120), - } - }; - SpanData::ExternalSpan(e2121) - } - }; - v2121 - }; - result2122.push(e2122); - } - _rt::cabi_dealloc( - base2122, - len2122 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2122 - }; - result2123.push(e2123); - } - _rt::cabi_dealloc( - base2123, - len2123 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes1775), - constructor_parameters: TypedDataValue { - value: v1932, - schema: v2080, - }, - trace_id: _rt::string_lift(bytes2083), - trace_states: result2089, - invocation_context: result2123, - } - }; - AgentInvocation::AgentInitialization(e2488) - } - 1 => { - let e2488 = { - let l2124 = *base.add(32).cast::<*mut u8>(); - let l2125 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2126 = l2125; - let bytes2126 = _rt::Vec::from_raw_parts( - l2124.cast(), - len2126, - len2126, - ); - let l2127 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2128 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2129 = l2128; - let bytes2129 = _rt::Vec::from_raw_parts( - l2127.cast(), - len2129, - len2129, - ); - let l2130 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V2286; - let v2286 = match l2130 { - 0 => { - let e2286 = { - let l2131 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2132 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2206 = l2131; - let len2206 = l2132; - let mut result2206 = _rt::Vec::with_capacity(len2206); - for i in 0..len2206 { - let base = base2206 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e2206 = { - let l2133 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V2205; - let v2205 = match l2133 { - 0 => { - let e2205 = { - let l2134 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2135 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2181 = l2134; - let len2181 = l2135; - let mut result2181 = _rt::Vec::with_capacity(len2181); - for i in 0..len2181 { - let base = base2181 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2181 = { - let l2136 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2180; - let v2180 = match l2136 { - 0 => { - let e2180 = { - let l2137 = *base.add(8).cast::<*mut u8>(); - let l2138 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2139 = l2138; - _rt::Vec::from_raw_parts(l2137.cast(), len2139, len2139) - }; - V2180::RecordValue(e2180) - } - 1 => { - let e2180 = { - let l2140 = *base.add(8).cast::(); - let l2141 = i32::from(*base.add(12).cast::()); - ( - l2140 as u32, - match l2141 { - 0 => None, - 1 => { - let e = { - let l2142 = *base.add(16).cast::(); - l2142 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2180::VariantValue(e2180) - } - 2 => { - let e2180 = { - let l2143 = *base.add(8).cast::(); - l2143 as u32 - }; - V2180::EnumValue(e2180) - } - 3 => { - let e2180 = { - let l2144 = *base.add(8).cast::<*mut u8>(); - let l2145 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2147 = l2144; - let len2147 = l2145; - let mut result2147 = _rt::Vec::with_capacity(len2147); - for i in 0..len2147 { - let base = base2147.add(i * 1); - let e2147 = { - let l2146 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2146 as u8) - }; - result2147.push(e2147); - } - _rt::cabi_dealloc(base2147, len2147 * 1, 1); - result2147 - }; - V2180::FlagsValue(e2180) - } - 4 => { - let e2180 = { - let l2148 = *base.add(8).cast::<*mut u8>(); - let l2149 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2150 = l2149; - _rt::Vec::from_raw_parts(l2148.cast(), len2150, len2150) - }; - V2180::TupleValue(e2180) - } - 5 => { - let e2180 = { - let l2151 = *base.add(8).cast::<*mut u8>(); - let l2152 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2153 = l2152; - _rt::Vec::from_raw_parts(l2151.cast(), len2153, len2153) - }; - V2180::ListValue(e2180) - } - 6 => { - let e2180 = { - let l2154 = i32::from(*base.add(8).cast::()); - match l2154 { - 0 => None, - 1 => { - let e = { - let l2155 = *base.add(12).cast::(); - l2155 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2180::OptionValue(e2180) - } - 7 => { - let e2180 = { - let l2156 = i32::from(*base.add(8).cast::()); - match l2156 { - 0 => { - let e = { - let l2157 = i32::from(*base.add(12).cast::()); - match l2157 { - 0 => None, - 1 => { - let e = { - let l2158 = *base.add(16).cast::(); - l2158 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2159 = i32::from(*base.add(12).cast::()); - match l2159 { - 0 => None, - 1 => { - let e = { - let l2160 = *base.add(16).cast::(); - l2160 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2180::ResultValue(e2180) - } - 8 => { - let e2180 = { - let l2161 = i32::from(*base.add(8).cast::()); - l2161 as u8 - }; - V2180::PrimU8(e2180) - } - 9 => { - let e2180 = { - let l2162 = i32::from(*base.add(8).cast::()); - l2162 as u16 - }; - V2180::PrimU16(e2180) - } - 10 => { - let e2180 = { - let l2163 = *base.add(8).cast::(); - l2163 as u32 - }; - V2180::PrimU32(e2180) - } - 11 => { - let e2180 = { - let l2164 = *base.add(8).cast::(); - l2164 as u64 - }; - V2180::PrimU64(e2180) - } - 12 => { - let e2180 = { - let l2165 = i32::from(*base.add(8).cast::()); - l2165 as i8 - }; - V2180::PrimS8(e2180) - } - 13 => { - let e2180 = { - let l2166 = i32::from(*base.add(8).cast::()); - l2166 as i16 - }; - V2180::PrimS16(e2180) - } - 14 => { - let e2180 = { - let l2167 = *base.add(8).cast::(); - l2167 - }; - V2180::PrimS32(e2180) - } - 15 => { - let e2180 = { - let l2168 = *base.add(8).cast::(); - l2168 - }; - V2180::PrimS64(e2180) - } - 16 => { - let e2180 = { - let l2169 = *base.add(8).cast::(); - l2169 - }; - V2180::PrimFloat32(e2180) - } - 17 => { - let e2180 = { - let l2170 = *base.add(8).cast::(); - l2170 - }; - V2180::PrimFloat64(e2180) - } - 18 => { - let e2180 = { - let l2171 = *base.add(8).cast::(); - _rt::char_lift(l2171 as u32) - }; - V2180::PrimChar(e2180) - } - 19 => { - let e2180 = { - let l2172 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2172 as u8) - }; - V2180::PrimBool(e2180) - } - 20 => { - let e2180 = { - let l2173 = *base.add(8).cast::<*mut u8>(); - let l2174 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2175 = l2174; - let bytes2175 = _rt::Vec::from_raw_parts( - l2173.cast(), - len2175, - len2175, - ); - _rt::string_lift(bytes2175) - }; - V2180::PrimString(e2180) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2180 = { - let l2176 = *base.add(8).cast::<*mut u8>(); - let l2177 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2178 = l2177; - let bytes2178 = _rt::Vec::from_raw_parts( - l2176.cast(), - len2178, - len2178, - ); - let l2179 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2178), - }, - l2179 as u64, - ) - }; - V2180::Handle(e2180) - } - }; - v2180 - }; - result2181.push(e2181); - } - _rt::cabi_dealloc( - base2181, - len2181 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2181, - } - }; - V2205::ComponentModel(e2205) - } - 1 => { - let e2205 = { - let l2182 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2193; - let v2193 = match l2182 { - 0 => { - let e2193 = { - let l2183 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2184 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2185 = l2184; - let bytes2185 = _rt::Vec::from_raw_parts( - l2183.cast(), - len2185, - len2185, - ); - _rt::string_lift(bytes2185) - }; - V2193::Url(e2193) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2193 = { - let l2186 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2187 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2188 = l2187; - let bytes2188 = _rt::Vec::from_raw_parts( - l2186.cast(), - len2188, - len2188, - ); - let l2189 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2188), - text_type: match l2189 { - 0 => None, - 1 => { - let e = { - let l2190 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2191 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2192 = l2191; - let bytes2192 = _rt::Vec::from_raw_parts( - l2190.cast(), - len2192, - len2192, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2192), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2193::Inline(e2193) - } - }; - v2193 - }; - V2205::UnstructuredText(e2205) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2205 = { - let l2194 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2204; - let v2204 = match l2194 { - 0 => { - let e2204 = { - let l2195 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2196 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2197 = l2196; - let bytes2197 = _rt::Vec::from_raw_parts( - l2195.cast(), - len2197, - len2197, - ); - _rt::string_lift(bytes2197) - }; - V2204::Url(e2204) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2204 = { - let l2198 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2199 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2200 = l2199; - let l2201 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2202 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2203 = l2202; - let bytes2203 = _rt::Vec::from_raw_parts( - l2201.cast(), - len2203, - len2203, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2198.cast(), - len2200, - len2200, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2203), - }, - } - }; - V2204::Inline(e2204) - } - }; - v2204 - }; - V2205::UnstructuredBinary(e2205) - } - }; - v2205 - }; - result2206.push(e2206); - } - _rt::cabi_dealloc( - base2206, - len2206 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2206 - }; - V2286::Tuple(e2286) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2286 = { - let l2207 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2208 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2285 = l2207; - let len2285 = l2208; - let mut result2285 = _rt::Vec::with_capacity(len2285); - for i in 0..len2285 { - let base = base2285 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e2285 = { - let l2209 = *base.add(0).cast::<*mut u8>(); - let l2210 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2211 = l2210; - let bytes2211 = _rt::Vec::from_raw_parts( - l2209.cast(), - len2211, - len2211, - ); - let l2212 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V2284; - let v2284 = match l2212 { - 0 => { - let e2284 = { - let l2213 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2214 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2260 = l2213; - let len2260 = l2214; - let mut result2260 = _rt::Vec::with_capacity(len2260); - for i in 0..len2260 { - let base = base2260 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2260 = { - let l2215 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2259; - let v2259 = match l2215 { - 0 => { - let e2259 = { - let l2216 = *base.add(8).cast::<*mut u8>(); - let l2217 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2218 = l2217; - _rt::Vec::from_raw_parts(l2216.cast(), len2218, len2218) - }; - V2259::RecordValue(e2259) - } - 1 => { - let e2259 = { - let l2219 = *base.add(8).cast::(); - let l2220 = i32::from(*base.add(12).cast::()); - ( - l2219 as u32, - match l2220 { - 0 => None, - 1 => { - let e = { - let l2221 = *base.add(16).cast::(); - l2221 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2259::VariantValue(e2259) - } - 2 => { - let e2259 = { - let l2222 = *base.add(8).cast::(); - l2222 as u32 - }; - V2259::EnumValue(e2259) - } - 3 => { - let e2259 = { - let l2223 = *base.add(8).cast::<*mut u8>(); - let l2224 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2226 = l2223; - let len2226 = l2224; - let mut result2226 = _rt::Vec::with_capacity(len2226); - for i in 0..len2226 { - let base = base2226.add(i * 1); - let e2226 = { - let l2225 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2225 as u8) - }; - result2226.push(e2226); - } - _rt::cabi_dealloc(base2226, len2226 * 1, 1); - result2226 - }; - V2259::FlagsValue(e2259) - } - 4 => { - let e2259 = { - let l2227 = *base.add(8).cast::<*mut u8>(); - let l2228 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2229 = l2228; - _rt::Vec::from_raw_parts(l2227.cast(), len2229, len2229) - }; - V2259::TupleValue(e2259) - } - 5 => { - let e2259 = { - let l2230 = *base.add(8).cast::<*mut u8>(); - let l2231 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2232 = l2231; - _rt::Vec::from_raw_parts(l2230.cast(), len2232, len2232) - }; - V2259::ListValue(e2259) - } - 6 => { - let e2259 = { - let l2233 = i32::from(*base.add(8).cast::()); - match l2233 { - 0 => None, - 1 => { - let e = { - let l2234 = *base.add(12).cast::(); - l2234 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2259::OptionValue(e2259) - } - 7 => { - let e2259 = { - let l2235 = i32::from(*base.add(8).cast::()); - match l2235 { - 0 => { - let e = { - let l2236 = i32::from(*base.add(12).cast::()); - match l2236 { - 0 => None, - 1 => { - let e = { - let l2237 = *base.add(16).cast::(); - l2237 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2238 = i32::from(*base.add(12).cast::()); - match l2238 { - 0 => None, - 1 => { - let e = { - let l2239 = *base.add(16).cast::(); - l2239 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2259::ResultValue(e2259) - } - 8 => { - let e2259 = { - let l2240 = i32::from(*base.add(8).cast::()); - l2240 as u8 - }; - V2259::PrimU8(e2259) - } - 9 => { - let e2259 = { - let l2241 = i32::from(*base.add(8).cast::()); - l2241 as u16 - }; - V2259::PrimU16(e2259) - } - 10 => { - let e2259 = { - let l2242 = *base.add(8).cast::(); - l2242 as u32 - }; - V2259::PrimU32(e2259) - } - 11 => { - let e2259 = { - let l2243 = *base.add(8).cast::(); - l2243 as u64 - }; - V2259::PrimU64(e2259) - } - 12 => { - let e2259 = { - let l2244 = i32::from(*base.add(8).cast::()); - l2244 as i8 - }; - V2259::PrimS8(e2259) - } - 13 => { - let e2259 = { - let l2245 = i32::from(*base.add(8).cast::()); - l2245 as i16 - }; - V2259::PrimS16(e2259) - } - 14 => { - let e2259 = { - let l2246 = *base.add(8).cast::(); - l2246 - }; - V2259::PrimS32(e2259) - } - 15 => { - let e2259 = { - let l2247 = *base.add(8).cast::(); - l2247 - }; - V2259::PrimS64(e2259) - } - 16 => { - let e2259 = { - let l2248 = *base.add(8).cast::(); - l2248 - }; - V2259::PrimFloat32(e2259) - } - 17 => { - let e2259 = { - let l2249 = *base.add(8).cast::(); - l2249 - }; - V2259::PrimFloat64(e2259) - } - 18 => { - let e2259 = { - let l2250 = *base.add(8).cast::(); - _rt::char_lift(l2250 as u32) - }; - V2259::PrimChar(e2259) - } - 19 => { - let e2259 = { - let l2251 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2251 as u8) - }; - V2259::PrimBool(e2259) - } - 20 => { - let e2259 = { - let l2252 = *base.add(8).cast::<*mut u8>(); - let l2253 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2254 = l2253; - let bytes2254 = _rt::Vec::from_raw_parts( - l2252.cast(), - len2254, - len2254, - ); - _rt::string_lift(bytes2254) - }; - V2259::PrimString(e2259) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2259 = { - let l2255 = *base.add(8).cast::<*mut u8>(); - let l2256 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2257 = l2256; - let bytes2257 = _rt::Vec::from_raw_parts( - l2255.cast(), - len2257, - len2257, - ); - let l2258 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2257), - }, - l2258 as u64, - ) - }; - V2259::Handle(e2259) - } - }; - v2259 - }; - result2260.push(e2260); - } - _rt::cabi_dealloc( - base2260, - len2260 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2260, - } - }; - V2284::ComponentModel(e2284) - } - 1 => { - let e2284 = { - let l2261 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2272; - let v2272 = match l2261 { - 0 => { - let e2272 = { - let l2262 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2263 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2264 = l2263; - let bytes2264 = _rt::Vec::from_raw_parts( - l2262.cast(), - len2264, - len2264, - ); - _rt::string_lift(bytes2264) - }; - V2272::Url(e2272) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2272 = { - let l2265 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2266 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2267 = l2266; - let bytes2267 = _rt::Vec::from_raw_parts( - l2265.cast(), - len2267, - len2267, - ); - let l2268 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2267), - text_type: match l2268 { - 0 => None, - 1 => { - let e = { - let l2269 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2270 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2271 = l2270; - let bytes2271 = _rt::Vec::from_raw_parts( - l2269.cast(), - len2271, - len2271, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2271), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2272::Inline(e2272) - } - }; - v2272 - }; - V2284::UnstructuredText(e2284) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2284 = { - let l2273 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2283; - let v2283 = match l2273 { - 0 => { - let e2283 = { - let l2274 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2275 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2276 = l2275; - let bytes2276 = _rt::Vec::from_raw_parts( - l2274.cast(), - len2276, - len2276, - ); - _rt::string_lift(bytes2276) - }; - V2283::Url(e2283) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2283 = { - let l2277 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2278 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2279 = l2278; - let l2280 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2281 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2282 = l2281; - let bytes2282 = _rt::Vec::from_raw_parts( - l2280.cast(), - len2282, - len2282, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2277.cast(), - len2279, - len2279, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2282), - }, - } - }; - V2283::Inline(e2283) - } - }; - v2283 - }; - V2284::UnstructuredBinary(e2284) - } - }; - (_rt::string_lift(bytes2211), v2284) - }; - result2285.push(e2285); - } - _rt::cabi_dealloc( - base2285, - len2285 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2285 - }; - V2286::Multimodal(e2286) - } - }; - let l2287 = i32::from( - *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2434; - let v2434 = match l2287 { - 0 => { - let e2434 = { - let l2288 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2289 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2360 = l2288; - let len2360 = l2289; - let mut result2360 = _rt::Vec::with_capacity(len2360); - for i in 0..len2360 { - let base = base2360 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2360 = { - let l2290 = *base.add(0).cast::<*mut u8>(); - let l2291 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2292 = l2291; - let bytes2292 = _rt::Vec::from_raw_parts( - l2290.cast(), - len2292, - len2292, - ); - let l2293 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2359; - let v2359 = match l2293 { - 0 => { - let e2359 = { - let l2294 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2295 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2344 = l2294; - let len2344 = l2295; - let mut result2344 = _rt::Vec::with_capacity(len2344); - for i in 0..len2344 { - let base = base2344 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2344 = { - let l2296 = i32::from(*base.add(0).cast::()); - let l2300 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2304 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2343; - let v2343 = match l2304 { - 0 => { - let e2343 = { - let l2305 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2306 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2311 = l2305; - let len2311 = l2306; - let mut result2311 = _rt::Vec::with_capacity(len2311); - for i in 0..len2311 { - let base = base2311 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2311 = { - let l2307 = *base.add(0).cast::<*mut u8>(); - let l2308 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2309 = l2308; - let bytes2309 = _rt::Vec::from_raw_parts( - l2307.cast(), - len2309, - len2309, - ); - let l2310 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2309), l2310) - }; - result2311.push(e2311); - } - _rt::cabi_dealloc( - base2311, - len2311 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2311 - }; - V2343::RecordType(e2343) - } - 1 => { - let e2343 = { - let l2312 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2313 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2319 = l2312; - let len2319 = l2313; - let mut result2319 = _rt::Vec::with_capacity(len2319); - for i in 0..len2319 { - let base = base2319 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2319 = { - let l2314 = *base.add(0).cast::<*mut u8>(); - let l2315 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2316 = l2315; - let bytes2316 = _rt::Vec::from_raw_parts( - l2314.cast(), - len2316, - len2316, - ); - let l2317 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2316), - match l2317 { - 0 => None, - 1 => { - let e = { - let l2318 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2318 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2319.push(e2319); - } - _rt::cabi_dealloc( - base2319, - len2319 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2319 - }; - V2343::VariantType(e2343) - } - 2 => { - let e2343 = { - let l2320 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2321 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2325 = l2320; - let len2325 = l2321; - let mut result2325 = _rt::Vec::with_capacity(len2325); - for i in 0..len2325 { - let base = base2325 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2325 = { - let l2322 = *base.add(0).cast::<*mut u8>(); - let l2323 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2324 = l2323; - let bytes2324 = _rt::Vec::from_raw_parts( - l2322.cast(), - len2324, - len2324, - ); - _rt::string_lift(bytes2324) - }; - result2325.push(e2325); - } - _rt::cabi_dealloc( - base2325, - len2325 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2325 - }; - V2343::EnumType(e2343) - } - 3 => { - let e2343 = { - let l2326 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2327 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2331 = l2326; - let len2331 = l2327; - let mut result2331 = _rt::Vec::with_capacity(len2331); - for i in 0..len2331 { - let base = base2331 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2331 = { - let l2328 = *base.add(0).cast::<*mut u8>(); - let l2329 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2330 = l2329; - let bytes2330 = _rt::Vec::from_raw_parts( - l2328.cast(), - len2330, - len2330, - ); - _rt::string_lift(bytes2330) - }; - result2331.push(e2331); - } - _rt::cabi_dealloc( - base2331, - len2331 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2331 - }; - V2343::FlagsType(e2343) - } - 4 => { - let e2343 = { - let l2332 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2333 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2334 = l2333; - _rt::Vec::from_raw_parts(l2332.cast(), len2334, len2334) - }; - V2343::TupleType(e2343) - } - 5 => { - let e2343 = { - let l2335 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2335 - }; - V2343::ListType(e2343) - } - 6 => { - let e2343 = { - let l2336 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2336 - }; - V2343::OptionType(e2343) - } - 7 => { - let e2343 = { - let l2337 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2339 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2337 { - 0 => None, - 1 => { - let e = { - let l2338 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2338 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2339 { - 0 => None, - 1 => { - let e = { - let l2340 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2340 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2343::ResultType(e2343) - } - 8 => V2343::PrimU8Type, - 9 => V2343::PrimU16Type, - 10 => V2343::PrimU32Type, - 11 => V2343::PrimU64Type, - 12 => V2343::PrimS8Type, - 13 => V2343::PrimS16Type, - 14 => V2343::PrimS32Type, - 15 => V2343::PrimS64Type, - 16 => V2343::PrimF32Type, - 17 => V2343::PrimF64Type, - 18 => V2343::PrimCharType, - 19 => V2343::PrimBoolType, - 20 => V2343::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2343 = { - let l2341 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2342 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2341 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2342 as u8, - ), - ) - }; - V2343::HandleType(e2343) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2296 { - 0 => None, - 1 => { - let e = { - let l2297 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2298 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2299 = l2298; - let bytes2299 = _rt::Vec::from_raw_parts( - l2297.cast(), - len2299, - len2299, - ); - _rt::string_lift(bytes2299) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2300 { - 0 => None, - 1 => { - let e = { - let l2301 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2302 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2303 = l2302; - let bytes2303 = _rt::Vec::from_raw_parts( - l2301.cast(), - len2303, - len2303, - ); - _rt::string_lift(bytes2303) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2343, - } - }; - result2344.push(e2344); - } - _rt::cabi_dealloc( - base2344, - len2344 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2344, - } - }; - V2359::ComponentModel(e2359) - } - 1 => { - let e2359 = { - let l2345 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2345 { - 0 => None, - 1 => { - let e = { - let l2346 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2347 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2351 = l2346; - let len2351 = l2347; - let mut result2351 = _rt::Vec::with_capacity(len2351); - for i in 0..len2351 { - let base = base2351 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2351 = { - let l2348 = *base.add(0).cast::<*mut u8>(); - let l2349 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2350 = l2349; - let bytes2350 = _rt::Vec::from_raw_parts( - l2348.cast(), - len2350, - len2350, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2350), - } - }; - result2351.push(e2351); - } - _rt::cabi_dealloc( - base2351, - len2351 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2351 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2359::UnstructuredText(e2359) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2359 = { - let l2352 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2352 { - 0 => None, - 1 => { - let e = { - let l2353 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2354 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2358 = l2353; - let len2358 = l2354; - let mut result2358 = _rt::Vec::with_capacity(len2358); - for i in 0..len2358 { - let base = base2358 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2358 = { - let l2355 = *base.add(0).cast::<*mut u8>(); - let l2356 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2357 = l2356; - let bytes2357 = _rt::Vec::from_raw_parts( - l2355.cast(), - len2357, - len2357, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2357), - } - }; - result2358.push(e2358); - } - _rt::cabi_dealloc( - base2358, - len2358 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2358 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2359::UnstructuredBinary(e2359) - } - }; - (_rt::string_lift(bytes2292), v2359) - }; - result2360.push(e2360); - } - _rt::cabi_dealloc( - base2360, - len2360 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2360 - }; - V2434::Tuple(e2434) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2434 = { - let l2361 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2362 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2433 = l2361; - let len2433 = l2362; - let mut result2433 = _rt::Vec::with_capacity(len2433); - for i in 0..len2433 { - let base = base2433 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2433 = { - let l2363 = *base.add(0).cast::<*mut u8>(); - let l2364 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2365 = l2364; - let bytes2365 = _rt::Vec::from_raw_parts( - l2363.cast(), - len2365, - len2365, - ); - let l2366 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2432; - let v2432 = match l2366 { - 0 => { - let e2432 = { - let l2367 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2368 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2417 = l2367; - let len2417 = l2368; - let mut result2417 = _rt::Vec::with_capacity(len2417); - for i in 0..len2417 { - let base = base2417 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2417 = { - let l2369 = i32::from(*base.add(0).cast::()); - let l2373 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2377 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2416; - let v2416 = match l2377 { - 0 => { - let e2416 = { - let l2378 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2379 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2384 = l2378; - let len2384 = l2379; - let mut result2384 = _rt::Vec::with_capacity(len2384); - for i in 0..len2384 { - let base = base2384 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2384 = { - let l2380 = *base.add(0).cast::<*mut u8>(); - let l2381 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2382 = l2381; - let bytes2382 = _rt::Vec::from_raw_parts( - l2380.cast(), - len2382, - len2382, - ); - let l2383 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2382), l2383) - }; - result2384.push(e2384); - } - _rt::cabi_dealloc( - base2384, - len2384 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2384 - }; - V2416::RecordType(e2416) - } - 1 => { - let e2416 = { - let l2385 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2386 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2392 = l2385; - let len2392 = l2386; - let mut result2392 = _rt::Vec::with_capacity(len2392); - for i in 0..len2392 { - let base = base2392 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2392 = { - let l2387 = *base.add(0).cast::<*mut u8>(); - let l2388 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2389 = l2388; - let bytes2389 = _rt::Vec::from_raw_parts( - l2387.cast(), - len2389, - len2389, - ); - let l2390 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2389), - match l2390 { - 0 => None, - 1 => { - let e = { - let l2391 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2391 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2392.push(e2392); - } - _rt::cabi_dealloc( - base2392, - len2392 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2392 - }; - V2416::VariantType(e2416) - } - 2 => { - let e2416 = { - let l2393 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2394 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2398 = l2393; - let len2398 = l2394; - let mut result2398 = _rt::Vec::with_capacity(len2398); - for i in 0..len2398 { - let base = base2398 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2398 = { - let l2395 = *base.add(0).cast::<*mut u8>(); - let l2396 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2397 = l2396; - let bytes2397 = _rt::Vec::from_raw_parts( - l2395.cast(), - len2397, - len2397, - ); - _rt::string_lift(bytes2397) - }; - result2398.push(e2398); - } - _rt::cabi_dealloc( - base2398, - len2398 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2398 - }; - V2416::EnumType(e2416) - } - 3 => { - let e2416 = { - let l2399 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2400 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2404 = l2399; - let len2404 = l2400; - let mut result2404 = _rt::Vec::with_capacity(len2404); - for i in 0..len2404 { - let base = base2404 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2404 = { - let l2401 = *base.add(0).cast::<*mut u8>(); - let l2402 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2403 = l2402; - let bytes2403 = _rt::Vec::from_raw_parts( - l2401.cast(), - len2403, - len2403, - ); - _rt::string_lift(bytes2403) - }; - result2404.push(e2404); - } - _rt::cabi_dealloc( - base2404, - len2404 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2404 - }; - V2416::FlagsType(e2416) - } - 4 => { - let e2416 = { - let l2405 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2406 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2407 = l2406; - _rt::Vec::from_raw_parts(l2405.cast(), len2407, len2407) - }; - V2416::TupleType(e2416) - } - 5 => { - let e2416 = { - let l2408 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2408 - }; - V2416::ListType(e2416) - } - 6 => { - let e2416 = { - let l2409 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2409 - }; - V2416::OptionType(e2416) - } - 7 => { - let e2416 = { - let l2410 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2412 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2410 { - 0 => None, - 1 => { - let e = { - let l2411 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2411 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2412 { - 0 => None, - 1 => { - let e = { - let l2413 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2413 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2416::ResultType(e2416) - } - 8 => V2416::PrimU8Type, - 9 => V2416::PrimU16Type, - 10 => V2416::PrimU32Type, - 11 => V2416::PrimU64Type, - 12 => V2416::PrimS8Type, - 13 => V2416::PrimS16Type, - 14 => V2416::PrimS32Type, - 15 => V2416::PrimS64Type, - 16 => V2416::PrimF32Type, - 17 => V2416::PrimF64Type, - 18 => V2416::PrimCharType, - 19 => V2416::PrimBoolType, - 20 => V2416::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2416 = { - let l2414 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2415 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2414 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2415 as u8, - ), - ) - }; - V2416::HandleType(e2416) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2369 { - 0 => None, - 1 => { - let e = { - let l2370 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2371 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2372 = l2371; - let bytes2372 = _rt::Vec::from_raw_parts( - l2370.cast(), - len2372, - len2372, - ); - _rt::string_lift(bytes2372) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2373 { - 0 => None, - 1 => { - let e = { - let l2374 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2375 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2376 = l2375; - let bytes2376 = _rt::Vec::from_raw_parts( - l2374.cast(), - len2376, - len2376, - ); - _rt::string_lift(bytes2376) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2416, - } - }; - result2417.push(e2417); - } - _rt::cabi_dealloc( - base2417, - len2417 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2417, - } - }; - V2432::ComponentModel(e2432) - } - 1 => { - let e2432 = { - let l2418 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2418 { - 0 => None, - 1 => { - let e = { - let l2419 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2420 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2424 = l2419; - let len2424 = l2420; - let mut result2424 = _rt::Vec::with_capacity(len2424); - for i in 0..len2424 { - let base = base2424 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2424 = { - let l2421 = *base.add(0).cast::<*mut u8>(); - let l2422 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2423 = l2422; - let bytes2423 = _rt::Vec::from_raw_parts( - l2421.cast(), - len2423, - len2423, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2423), - } - }; - result2424.push(e2424); - } - _rt::cabi_dealloc( - base2424, - len2424 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2424 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2432::UnstructuredText(e2432) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2432 = { - let l2425 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2425 { - 0 => None, - 1 => { - let e = { - let l2426 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2427 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2431 = l2426; - let len2431 = l2427; - let mut result2431 = _rt::Vec::with_capacity(len2431); - for i in 0..len2431 { - let base = base2431 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2431 = { - let l2428 = *base.add(0).cast::<*mut u8>(); - let l2429 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2430 = l2429; - let bytes2430 = _rt::Vec::from_raw_parts( - l2428.cast(), - len2430, - len2430, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2430), - } - }; - result2431.push(e2431); - } - _rt::cabi_dealloc( - base2431, - len2431 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2431 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2432::UnstructuredBinary(e2432) - } - }; - (_rt::string_lift(bytes2365), v2432) - }; - result2433.push(e2433); - } - _rt::cabi_dealloc( - base2433, - len2433 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2433 - }; - V2434::Multimodal(e2434) - } - }; - let l2435 = *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2436 = *base - .add(32 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2437 = l2436; - let bytes2437 = _rt::Vec::from_raw_parts( - l2435.cast(), - len2437, - len2437, - ); - let l2438 = *base - .add(32 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2439 = *base - .add(32 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2443 = l2438; - let len2443 = l2439; - let mut result2443 = _rt::Vec::with_capacity(len2443); - for i in 0..len2443 { - let base = base2443 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2443 = { - let l2440 = *base.add(0).cast::<*mut u8>(); - let l2441 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2442 = l2441; - let bytes2442 = _rt::Vec::from_raw_parts( - l2440.cast(), - len2442, - len2442, - ); - _rt::string_lift(bytes2442) - }; - result2443.push(e2443); - } - _rt::cabi_dealloc( - base2443, - len2443 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2444 = *base - .add(32 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2445 = *base - .add(32 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2477 = l2444; - let len2477 = l2445; - let mut result2477 = _rt::Vec::with_capacity(len2477); - for i in 0..len2477 { - let base = base2477 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2477 = { - let l2446 = *base.add(0).cast::<*mut u8>(); - let l2447 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2476 = l2446; - let len2476 = l2447; - let mut result2476 = _rt::Vec::with_capacity(len2476); - for i in 0..len2476 { - let base = base2476 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2476 = { - let l2448 = i32::from(*base.add(0).cast::()); - let v2475 = match l2448 { - 0 => { - let e2475 = { - let l2449 = *base.add(8).cast::<*mut u8>(); - let l2450 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2451 = l2450; - let bytes2451 = _rt::Vec::from_raw_parts( - l2449.cast(), - len2451, - len2451, - ); - let l2452 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2453 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2454 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2458 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2460 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2461 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2470 = l2460; - let len2470 = l2461; - let mut result2470 = _rt::Vec::with_capacity(len2470); - for i in 0..len2470 { - let base = base2470 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2470 = { - let l2462 = *base.add(0).cast::<*mut u8>(); - let l2463 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2464 = l2463; - let bytes2464 = _rt::Vec::from_raw_parts( - l2462.cast(), - len2464, - len2464, - ); - let l2465 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2469; - let v2469 = match l2465 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2469 = { - let l2466 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2467 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2468 = l2467; - let bytes2468 = _rt::Vec::from_raw_parts( - l2466.cast(), - len2468, - len2468, - ); - _rt::string_lift(bytes2468) - }; - V2469::String(e2469) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2464), - value: v2469, - } - }; - result2470.push(e2470); - } - _rt::cabi_dealloc( - base2470, - len2470 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2471 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2451), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2452 as u64, - nanoseconds: l2453 as u32, - }, - parent: match l2454 { - 0 => None, - 1 => { - let e = { - let l2455 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2456 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2457 = l2456; - let bytes2457 = _rt::Vec::from_raw_parts( - l2455.cast(), - len2457, - len2457, - ); - _rt::string_lift(bytes2457) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2458 { - 0 => None, - 1 => { - let e = { - let l2459 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2459 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2470, - inherited: _rt::bool_lift(l2471 as u8), - } - }; - SpanData::LocalSpan(e2475) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2475 = { - let l2472 = *base.add(8).cast::<*mut u8>(); - let l2473 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2474 = l2473; - let bytes2474 = _rt::Vec::from_raw_parts( - l2472.cast(), - len2474, - len2474, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2474), - } - }; - SpanData::ExternalSpan(e2475) - } - }; - v2475 - }; - result2476.push(e2476); - } - _rt::cabi_dealloc( - base2476, - len2476 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2476 - }; - result2477.push(e2477); - } - _rt::cabi_dealloc( - base2477, - len2477 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes2126), - method_name: _rt::string_lift(bytes2129), - function_input: TypedDataValue { - value: v2286, - schema: v2434, - }, - trace_id: _rt::string_lift(bytes2437), - trace_states: result2443, - invocation_context: result2477, - } - }; - AgentInvocation::AgentMethodInvocation(e2488) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e2488 = { - let l2478 = *base.add(32).cast::<*mut u8>(); - let l2479 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2480 = l2479; - let l2481 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2482 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2483 = l2482; - let bytes2483 = _rt::Vec::from_raw_parts( - l2481.cast(), - len2483, - len2483, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2478.cast(), - len2480, - len2480, - ), - mime_type: _rt::string_lift(bytes2483), - }, - } - }; - AgentInvocation::LoadSnapshot(e2488) - } - 4 => { - let e2488 = { - let l2484 = *base.add(32).cast::<*mut u8>(); - let l2485 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2486 = l2485; - let bytes2486 = _rt::Vec::from_raw_parts( - l2484.cast(), - len2486, - len2486, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes2486), - } - }; - AgentInvocation::ProcessOplogEntries(e2488) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e2488 = { - let l2487 = *base.add(32).cast::(); - ManualUpdateParameters { - target_revision: l2487 as u64, - } - }; - AgentInvocation::ManualUpdate(e2488) - } - }; - PendingAgentInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1770 as u64, - nanoseconds: l1771 as u32, - }, - invocation: v2488, - } - }; - PublicOplogEntry::PendingAgentInvocation(e2675) - } - 16 => { - let e2675 = { - let l2489 = *base.add(8).cast::(); - let l2490 = *base.add(16).cast::(); - let l2491 = *base.add(24).cast::(); - let l2492 = i32::from(*base.add(32).cast::()); - let v2499 = match l2492 { - 0 => UpdateDescription::AutoUpdate, - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2499 = { - let l2493 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2494 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2495 = l2494; - let l2496 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2497 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2498 = l2497; - let bytes2498 = _rt::Vec::from_raw_parts( - l2496.cast(), - len2498, - len2498, - ); - super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2493.cast(), - len2495, - len2495, - ), - mime_type: _rt::string_lift(bytes2498), - } - }; - UpdateDescription::SnapshotBased(e2499) - } - }; - PendingUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2489 as u64, - nanoseconds: l2490 as u32, - }, - target_revision: l2491 as u64, - update_description: v2499, - } - }; - PublicOplogEntry::PendingUpdate(e2675) - } - 17 => { - let e2675 = { - let l2500 = *base.add(8).cast::(); - let l2501 = *base.add(16).cast::(); - let l2502 = *base.add(24).cast::(); - let l2503 = *base.add(32).cast::(); - let l2504 = *base.add(40).cast::<*mut u8>(); - let l2505 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2521 = l2504; - let len2521 = l2505; - let mut result2521 = _rt::Vec::with_capacity(len2521); - for i in 0..len2521 { - let base = base2521 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2521 = { - let l2506 = *base.add(0).cast::<*mut u8>(); - let l2507 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2508 = l2507; - let bytes2508 = _rt::Vec::from_raw_parts( - l2506.cast(), - len2508, - len2508, - ); - let l2509 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2510 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2511 = l2510; - let bytes2511 = _rt::Vec::from_raw_parts( - l2509.cast(), - len2511, - len2511, - ); - let l2512 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2513 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2520 = l2512; - let len2520 = l2513; - let mut result2520 = _rt::Vec::with_capacity(len2520); - for i in 0..len2520 { - let base = base2520 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2520 = { - let l2514 = *base.add(0).cast::<*mut u8>(); - let l2515 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2516 = l2515; - let bytes2516 = _rt::Vec::from_raw_parts( - l2514.cast(), - len2516, - len2516, - ); - let l2517 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2518 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2519 = l2518; - let bytes2519 = _rt::Vec::from_raw_parts( - l2517.cast(), - len2519, - len2519, - ); - (_rt::string_lift(bytes2516), _rt::string_lift(bytes2519)) - }; - result2520.push(e2520); - } - _rt::cabi_dealloc( - base2520, - len2520 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes2508), - version: _rt::string_lift(bytes2511), - parameters: result2520, - } - }; - result2521.push(e2521); - } - _rt::cabi_dealloc( - base2521, - len2521 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - SuccessfulUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2500 as u64, - nanoseconds: l2501 as u32, - }, - target_revision: l2502 as u64, - new_component_size: l2503 as u64, - new_active_plugins: result2521, - } - }; - PublicOplogEntry::SuccessfulUpdate(e2675) - } - 18 => { - let e2675 = { - let l2522 = *base.add(8).cast::(); - let l2523 = *base.add(16).cast::(); - let l2524 = *base.add(24).cast::(); - let l2525 = i32::from(*base.add(32).cast::()); - FailedUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2522 as u64, - nanoseconds: l2523 as u32, - }, - target_revision: l2524 as u64, - details: match l2525 { - 0 => None, - 1 => { - let e = { - let l2526 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2527 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2528 = l2527; - let bytes2528 = _rt::Vec::from_raw_parts( - l2526.cast(), - len2528, - len2528, - ); - _rt::string_lift(bytes2528) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - PublicOplogEntry::FailedUpdate(e2675) - } - 19 => { - let e2675 = { - let l2529 = *base.add(8).cast::(); - let l2530 = *base.add(16).cast::(); - let l2531 = *base.add(24).cast::(); - GrowMemoryParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2529 as u64, - nanoseconds: l2530 as u32, - }, - delta: l2531 as u64, - } - }; - PublicOplogEntry::GrowMemory(e2675) - } - 20 => { - let e2675 = { - let l2532 = *base.add(8).cast::(); - let l2533 = *base.add(16).cast::(); - let l2534 = *base.add(24).cast::(); - let l2535 = *base.add(32).cast::<*mut u8>(); - let l2536 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2537 = l2536; - let bytes2537 = _rt::Vec::from_raw_parts( - l2535.cast(), - len2537, - len2537, - ); - let l2538 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2539 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2540 = l2539; - let bytes2540 = _rt::Vec::from_raw_parts( - l2538.cast(), - len2540, - len2540, - ); - CreateResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2532 as u64, - nanoseconds: l2533 as u32, - }, - resource_id: l2534 as u64, - name: _rt::string_lift(bytes2537), - owner: _rt::string_lift(bytes2540), - } - }; - PublicOplogEntry::CreateResource(e2675) - } - 21 => { - let e2675 = { - let l2541 = *base.add(8).cast::(); - let l2542 = *base.add(16).cast::(); - let l2543 = *base.add(24).cast::(); - let l2544 = *base.add(32).cast::<*mut u8>(); - let l2545 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2546 = l2545; - let bytes2546 = _rt::Vec::from_raw_parts( - l2544.cast(), - len2546, - len2546, - ); - let l2547 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2548 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2549 = l2548; - let bytes2549 = _rt::Vec::from_raw_parts( - l2547.cast(), - len2549, - len2549, - ); - DropResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2541 as u64, - nanoseconds: l2542 as u32, - }, - resource_id: l2543 as u64, - name: _rt::string_lift(bytes2546), - owner: _rt::string_lift(bytes2549), - } - }; - PublicOplogEntry::DropResource(e2675) - } - 22 => { - let e2675 = { - let l2550 = *base.add(8).cast::(); - let l2551 = *base.add(16).cast::(); - let l2552 = i32::from(*base.add(24).cast::()); - let l2553 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2554 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2555 = l2554; - let bytes2555 = _rt::Vec::from_raw_parts( - l2553.cast(), - len2555, - len2555, - ); - let l2556 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2557 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2558 = l2557; - let bytes2558 = _rt::Vec::from_raw_parts( - l2556.cast(), - len2558, - len2558, - ); - LogParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2550 as u64, - nanoseconds: l2551 as u32, - }, - level: LogLevel::_lift(l2552 as u8), - context: _rt::string_lift(bytes2555), - message: _rt::string_lift(bytes2558), - } - }; - PublicOplogEntry::Log(e2675) - } - 23 => { - let e2675 = { - let l2559 = *base.add(8).cast::(); - let l2560 = *base.add(16).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2559 as u64, - nanoseconds: l2560 as u32, - }, - } - }; - PublicOplogEntry::Restart(e2675) - } - 24 => { - let e2675 = { - let l2561 = *base.add(8).cast::(); - let l2562 = *base.add(16).cast::(); - let l2563 = *base.add(24).cast::<*mut u8>(); - let l2564 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2565 = l2564; - let bytes2565 = _rt::Vec::from_raw_parts( - l2563.cast(), - len2565, - len2565, - ); - let l2566 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2567 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2568 = l2567; - let bytes2568 = _rt::Vec::from_raw_parts( - l2566.cast(), - len2568, - len2568, - ); - let l2569 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2570 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2577 = l2569; - let len2577 = l2570; - let mut result2577 = _rt::Vec::with_capacity(len2577); - for i in 0..len2577 { - let base = base2577 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2577 = { - let l2571 = *base.add(0).cast::<*mut u8>(); - let l2572 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2573 = l2572; - let bytes2573 = _rt::Vec::from_raw_parts( - l2571.cast(), - len2573, - len2573, - ); - let l2574 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2575 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2576 = l2575; - let bytes2576 = _rt::Vec::from_raw_parts( - l2574.cast(), - len2576, - len2576, - ); - (_rt::string_lift(bytes2573), _rt::string_lift(bytes2576)) - }; - result2577.push(e2577); - } - _rt::cabi_dealloc( - base2577, - len2577 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - ActivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2561 as u64, - nanoseconds: l2562 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2565), - version: _rt::string_lift(bytes2568), - parameters: result2577, - }, - } - }; - PublicOplogEntry::ActivatePlugin(e2675) - } - 25 => { - let e2675 = { - let l2578 = *base.add(8).cast::(); - let l2579 = *base.add(16).cast::(); - let l2580 = *base.add(24).cast::<*mut u8>(); - let l2581 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2582 = l2581; - let bytes2582 = _rt::Vec::from_raw_parts( - l2580.cast(), - len2582, - len2582, - ); - let l2583 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2584 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2585 = l2584; - let bytes2585 = _rt::Vec::from_raw_parts( - l2583.cast(), - len2585, - len2585, - ); - let l2586 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2587 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2594 = l2586; - let len2594 = l2587; - let mut result2594 = _rt::Vec::with_capacity(len2594); - for i in 0..len2594 { - let base = base2594 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2594 = { - let l2588 = *base.add(0).cast::<*mut u8>(); - let l2589 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2590 = l2589; - let bytes2590 = _rt::Vec::from_raw_parts( - l2588.cast(), - len2590, - len2590, - ); - let l2591 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2592 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2593 = l2592; - let bytes2593 = _rt::Vec::from_raw_parts( - l2591.cast(), - len2593, - len2593, - ); - (_rt::string_lift(bytes2590), _rt::string_lift(bytes2593)) - }; - result2594.push(e2594); - } - _rt::cabi_dealloc( - base2594, - len2594 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - DeactivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2578 as u64, - nanoseconds: l2579 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2582), - version: _rt::string_lift(bytes2585), - parameters: result2594, - }, - } - }; - PublicOplogEntry::DeactivatePlugin(e2675) - } - 26 => { - let e2675 = { - let l2595 = *base.add(8).cast::(); - let l2596 = *base.add(16).cast::(); - let l2597 = *base.add(24).cast::(); - let l2598 = *base.add(32).cast::(); - RevertParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2595 as u64, - nanoseconds: l2596 as u32, - }, - dropped_region: OplogRegion { - start: l2597 as u64, - end: l2598 as u64, - }, - } - }; - PublicOplogEntry::Revert(e2675) - } - 27 => { - let e2675 = { - let l2599 = *base.add(8).cast::(); - let l2600 = *base.add(16).cast::(); - let l2601 = *base.add(24).cast::<*mut u8>(); - let l2602 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2603 = l2602; - let bytes2603 = _rt::Vec::from_raw_parts( - l2601.cast(), - len2603, - len2603, - ); - CancelPendingInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2599 as u64, - nanoseconds: l2600 as u32, - }, - idempotency_key: _rt::string_lift(bytes2603), - } - }; - PublicOplogEntry::CancelPendingInvocation(e2675) - } - 28 => { - let e2675 = { - let l2604 = *base.add(8).cast::(); - let l2605 = *base.add(16).cast::(); - let l2606 = *base.add(24).cast::<*mut u8>(); - let l2607 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2608 = l2607; - let bytes2608 = _rt::Vec::from_raw_parts( - l2606.cast(), - len2608, - len2608, - ); - let l2609 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2613 = i32::from( - *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2617 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2618 = *base - .add(24 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2627 = l2617; - let len2627 = l2618; - let mut result2627 = _rt::Vec::with_capacity(len2627); - for i in 0..len2627 { - let base = base2627 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2627 = { - let l2619 = *base.add(0).cast::<*mut u8>(); - let l2620 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2621 = l2620; - let bytes2621 = _rt::Vec::from_raw_parts( - l2619.cast(), - len2621, - len2621, - ); - let l2622 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2626; - let v2626 = match l2622 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2626 = { - let l2623 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2624 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2625 = l2624; - let bytes2625 = _rt::Vec::from_raw_parts( - l2623.cast(), - len2625, - len2625, - ); - _rt::string_lift(bytes2625) - }; - V2626::String(e2626) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2621), - value: v2626, - } - }; - result2627.push(e2627); - } - _rt::cabi_dealloc( - base2627, - len2627 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - StartSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2604 as u64, - nanoseconds: l2605 as u32, - }, - span_id: _rt::string_lift(bytes2608), - parent: match l2609 { - 0 => None, - 1 => { - let e = { - let l2610 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2611 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2612 = l2611; - let bytes2612 = _rt::Vec::from_raw_parts( - l2610.cast(), - len2612, - len2612, - ); - _rt::string_lift(bytes2612) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context_id: match l2613 { - 0 => None, - 1 => { - let e = { - let l2614 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2615 = *base - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2616 = l2615; - let bytes2616 = _rt::Vec::from_raw_parts( - l2614.cast(), - len2616, - len2616, - ); - _rt::string_lift(bytes2616) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2627, - } - }; - PublicOplogEntry::StartSpan(e2675) - } - 29 => { - let e2675 = { - let l2628 = *base.add(8).cast::(); - let l2629 = *base.add(16).cast::(); - let l2630 = *base.add(24).cast::<*mut u8>(); - let l2631 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2632 = l2631; - let bytes2632 = _rt::Vec::from_raw_parts( - l2630.cast(), - len2632, - len2632, - ); - FinishSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2628 as u64, - nanoseconds: l2629 as u32, - }, - span_id: _rt::string_lift(bytes2632), - } - }; - PublicOplogEntry::FinishSpan(e2675) - } - 30 => { - let e2675 = { - let l2633 = *base.add(8).cast::(); - let l2634 = *base.add(16).cast::(); - let l2635 = *base.add(24).cast::<*mut u8>(); - let l2636 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2637 = l2636; - let bytes2637 = _rt::Vec::from_raw_parts( - l2635.cast(), - len2637, - len2637, - ); - let l2638 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2639 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2640 = l2639; - let bytes2640 = _rt::Vec::from_raw_parts( - l2638.cast(), - len2640, - len2640, - ); - let l2641 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2645; - let v2645 = match l2641 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2645 = { - let l2642 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2643 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2644 = l2643; - let bytes2644 = _rt::Vec::from_raw_parts( - l2642.cast(), - len2644, - len2644, - ); - _rt::string_lift(bytes2644) - }; - V2645::String(e2645) - } - }; - SetSpanAttributeParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2633 as u64, - nanoseconds: l2634 as u32, - }, - span_id: _rt::string_lift(bytes2637), - key: _rt::string_lift(bytes2640), - value: v2645, - } - }; - PublicOplogEntry::SetSpanAttribute(e2675) - } - 31 => { - let e2675 = { - let l2646 = *base.add(8).cast::(); - let l2647 = *base.add(16).cast::(); - let l2648 = i32::from(*base.add(24).cast::()); - use super::super::super::golem::api::host::PersistenceLevel as V2649; - let v2649 = match l2648 { - 0 => V2649::PersistNothing, - 1 => V2649::PersistRemoteSideEffects, - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - V2649::Smart - } - }; - ChangePersistenceLevelParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2646 as u64, - nanoseconds: l2647 as u32, - }, - persistence_level: v2649, - } - }; - PublicOplogEntry::ChangePersistenceLevel(e2675) - } - 32 => { - let e2675 = { - let l2650 = *base.add(8).cast::(); - let l2651 = *base.add(16).cast::(); - let l2652 = *base.add(24).cast::<*mut u8>(); - let l2653 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2654 = l2653; - let bytes2654 = _rt::Vec::from_raw_parts( - l2652.cast(), - len2654, - len2654, - ); - BeginRemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2650 as u64, - nanoseconds: l2651 as u32, - }, - transaction_id: _rt::string_lift(bytes2654), - } - }; - PublicOplogEntry::BeginRemoteTransaction(e2675) - } - 33 => { - let e2675 = { - let l2655 = *base.add(8).cast::(); - let l2656 = *base.add(16).cast::(); - let l2657 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2655 as u64, - nanoseconds: l2656 as u32, - }, - begin_index: l2657 as u64, - } - }; - PublicOplogEntry::PreCommitRemoteTransaction(e2675) - } - 34 => { - let e2675 = { - let l2658 = *base.add(8).cast::(); - let l2659 = *base.add(16).cast::(); - let l2660 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2658 as u64, - nanoseconds: l2659 as u32, - }, - begin_index: l2660 as u64, - } - }; - PublicOplogEntry::PreRollbackRemoteTransaction(e2675) - } - 35 => { - let e2675 = { - let l2661 = *base.add(8).cast::(); - let l2662 = *base.add(16).cast::(); - let l2663 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2661 as u64, - nanoseconds: l2662 as u32, - }, - begin_index: l2663 as u64, - } - }; - PublicOplogEntry::CommittedRemoteTransaction(e2675) - } - 36 => { - let e2675 = { - let l2664 = *base.add(8).cast::(); - let l2665 = *base.add(16).cast::(); - let l2666 = *base.add(24).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2664 as u64, - nanoseconds: l2665 as u32, - }, - begin_index: l2666 as u64, - } - }; - PublicOplogEntry::RolledBackRemoteTransaction(e2675) - } - n => { - debug_assert_eq!(n, 37, "invalid enum discriminant"); - let e2675 = { - let l2667 = *base.add(8).cast::(); - let l2668 = *base.add(16).cast::(); - let l2669 = *base.add(24).cast::<*mut u8>(); - let l2670 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2671 = l2670; - let l2672 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2673 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2674 = l2673; - let bytes2674 = _rt::Vec::from_raw_parts( - l2672.cast(), - len2674, - len2674, - ); - SnapshotParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2667 as u64, - nanoseconds: l2668 as u32, - }, - data: _rt::Vec::from_raw_parts( - l2669.cast(), - len2671, - len2671, - ), - mime_type: _rt::string_lift(bytes2674), - } - }; - PublicOplogEntry::Snapshot(e2675) - } - }; - v2675 - }; - result2676.push(e2676); - } - _rt::cabi_dealloc( - base2676, - len2676 * (120 + 14 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2676 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result2677 - } - } - } - impl SearchOplog { - #[allow(unused_unsafe, clippy::all)] - pub fn new(agent_id: &AgentId, text: &str) -> Self { - unsafe { - let super::super::super::golem::core::types::AgentId { - component_id: component_id0, - agent_id: agent_id0, - } = agent_id; - let super::super::super::golem::core::types::ComponentId { - uuid: uuid1, - } = component_id0; - let super::super::super::golem::core::types::Uuid { - high_bits: high_bits2, - low_bits: low_bits2, - } = uuid1; - let vec3 = agent_id0; - let ptr3 = vec3.as_ptr().cast::(); - let len3 = vec3.len(); - let vec4 = text; - let ptr4 = vec4.as_ptr().cast::(); - let len4 = vec4.len(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[constructor]search-oplog"] - fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - ) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import5( - _: i64, - _: i64, - _: *mut u8, - _: usize, - _: *mut u8, - _: usize, - ) -> i32 { - unreachable!() - } - let ret = unsafe { - wit_import5( - _rt::as_i64(high_bits2), - _rt::as_i64(low_bits2), - ptr3.cast_mut(), - len3, - ptr4.cast_mut(), - len4, - ) - }; - unsafe { SearchOplog::from_handle(ret as u32) } - } - } - } - impl SearchOplog { - #[allow(unused_unsafe, clippy::all)] - pub fn get_next( - &self, - ) -> Option<_rt::Vec<(OplogIndex, PublicOplogEntry)>> { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:api/oplog@1.5.0")] - unsafe extern "C" { - #[link_name = "[method]search-oplog.get-next"] - fn wit_import1(_: i32, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) { - unreachable!() - } - unsafe { wit_import1((self).handle() as i32, ptr0) }; - let l2 = i32::from(*ptr0.add(0).cast::()); - let result2678 = match l2 { - 0 => None, - 1 => { - let e = { - let l3 = *ptr0 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l4 = *ptr0 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2677 = l3; - let len2677 = l4; - let mut result2677 = _rt::Vec::with_capacity(len2677); - for i in 0..len2677 { - let base = base2677 - .add(i * (128 + 14 * ::core::mem::size_of::<*const u8>())); - let e2677 = { - let l5 = *base.add(0).cast::(); - let l6 = i32::from(*base.add(8).cast::()); - let v2676 = match l6 { - 0 => { - let e2676 = { - let l7 = *base.add(16).cast::(); - let l8 = *base.add(24).cast::(); - let l9 = *base.add(32).cast::(); - let l10 = *base.add(40).cast::(); - let l11 = *base.add(48).cast::<*mut u8>(); - let l12 = *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len13 = l12; - let bytes13 = _rt::Vec::from_raw_parts( - l11.cast(), - len13, - len13, - ); - let l14 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l15 = *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l16 = *base - .add(56 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base20 = l15; - let len20 = l16; - let mut result20 = _rt::Vec::with_capacity(len20); - for i in 0..len20 { - let base = base20 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e20 = { - let l17 = *base.add(0).cast::<*mut u8>(); - let l18 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len19 = l18; - let bytes19 = _rt::Vec::from_raw_parts( - l17.cast(), - len19, - len19, - ); - _rt::string_lift(bytes19) - }; - result20.push(e20); - } - _rt::cabi_dealloc( - base20, - len20 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l21 = *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l22 = *base - .add(56 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base29 = l21; - let len29 = l22; - let mut result29 = _rt::Vec::with_capacity(len29); - for i in 0..len29 { - let base = base29 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e29 = { - let l23 = *base.add(0).cast::<*mut u8>(); - let l24 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len25 = l24; - let bytes25 = _rt::Vec::from_raw_parts( - l23.cast(), - len25, - len25, - ); - let l26 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l27 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len28 = l27; - let bytes28 = _rt::Vec::from_raw_parts( - l26.cast(), - len28, - len28, - ); - (_rt::string_lift(bytes25), _rt::string_lift(bytes28)) - }; - result29.push(e29); - } - _rt::cabi_dealloc( - base29, - len29 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l30 = *base - .add(56 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l31 = *base - .add(64 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l32 = *base - .add(72 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l33 = *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l34 = i32::from( - *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l40 = *base - .add(112 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l41 = *base - .add(120 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l42 = *base - .add(128 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l43 = *base - .add(128 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base59 = l42; - let len59 = l43; - let mut result59 = _rt::Vec::with_capacity(len59); - for i in 0..len59 { - let base = base59 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e59 = { - let l44 = *base.add(0).cast::<*mut u8>(); - let l45 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len46 = l45; - let bytes46 = _rt::Vec::from_raw_parts( - l44.cast(), - len46, - len46, - ); - let l47 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l48 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, - ); - let l50 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l51 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base58 = l50; - let len58 = l51; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l52 = *base.add(0).cast::<*mut u8>(); - let l53 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len54 = l53; - let bytes54 = _rt::Vec::from_raw_parts( - l52.cast(), - len54, - len54, - ); - let l55 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l56 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, - ); - (_rt::string_lift(bytes54), _rt::string_lift(bytes57)) - }; - result58.push(e58); - } - _rt::cabi_dealloc( - base58, - len58 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes46), - version: _rt::string_lift(bytes49), - parameters: result58, - } - }; - result59.push(e59); - } - _rt::cabi_dealloc( - base59, - len59 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l60 = *base - .add(128 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l61 = *base - .add(128 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base68 = l60; - let len68 = l61; - let mut result68 = _rt::Vec::with_capacity(len68); - for i in 0..len68 { - let base = base68 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e68 = { - let l62 = *base.add(0).cast::<*mut u8>(); - let l63 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len64 = l63; - let bytes64 = _rt::Vec::from_raw_parts( - l62.cast(), - len64, - len64, - ); - let l65 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l66 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len67 = l66; - let bytes67 = _rt::Vec::from_raw_parts( - l65.cast(), - len67, - len67, - ); - (_rt::string_lift(bytes64), _rt::string_lift(bytes67)) - }; - result68.push(e68); - } - _rt::cabi_dealloc( - base68, - len68 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l69 = *base - .add(128 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l70 = *base - .add(128 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base176 = l69; - let len176 = l70; - let mut result176 = _rt::Vec::with_capacity(len176); - for i in 0..len176 { - let base = base176 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e176 = { - let l71 = *base.add(0).cast::<*mut u8>(); - let l72 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base76 = l71; - let len76 = l72; - let mut result76 = _rt::Vec::with_capacity(len76); - for i in 0..len76 { - let base = base76 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e76 = { - let l73 = *base.add(0).cast::<*mut u8>(); - let l74 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, - ); - _rt::string_lift(bytes75) - }; - result76.push(e76); - } - _rt::cabi_dealloc( - base76, - len76 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l77 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l78 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base124 = l77; - let len124 = l78; - let mut result124 = _rt::Vec::with_capacity(len124); - for i in 0..len124 { - let base = base124 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e124 = { - let l79 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V123; - let v123 = match l79 { - 0 => { - let e123 = { - let l80 = *base.add(8).cast::<*mut u8>(); - let l81 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len82 = l81; - _rt::Vec::from_raw_parts(l80.cast(), len82, len82) - }; - V123::RecordValue(e123) - } - 1 => { - let e123 = { - let l83 = *base.add(8).cast::(); - let l84 = i32::from(*base.add(12).cast::()); - ( - l83 as u32, - match l84 { - 0 => None, - 1 => { - let e = { - let l85 = *base.add(16).cast::(); - l85 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V123::VariantValue(e123) - } - 2 => { - let e123 = { - let l86 = *base.add(8).cast::(); - l86 as u32 - }; - V123::EnumValue(e123) - } - 3 => { - let e123 = { - let l87 = *base.add(8).cast::<*mut u8>(); - let l88 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base90 = l87; - let len90 = l88; - let mut result90 = _rt::Vec::with_capacity(len90); - for i in 0..len90 { - let base = base90.add(i * 1); - let e90 = { - let l89 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l89 as u8) - }; - result90.push(e90); - } - _rt::cabi_dealloc(base90, len90 * 1, 1); - result90 - }; - V123::FlagsValue(e123) - } - 4 => { - let e123 = { - let l91 = *base.add(8).cast::<*mut u8>(); - let l92 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len93 = l92; - _rt::Vec::from_raw_parts(l91.cast(), len93, len93) - }; - V123::TupleValue(e123) - } - 5 => { - let e123 = { - let l94 = *base.add(8).cast::<*mut u8>(); - let l95 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len96 = l95; - _rt::Vec::from_raw_parts(l94.cast(), len96, len96) - }; - V123::ListValue(e123) - } - 6 => { - let e123 = { - let l97 = i32::from(*base.add(8).cast::()); - match l97 { - 0 => None, - 1 => { - let e = { - let l98 = *base.add(12).cast::(); - l98 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V123::OptionValue(e123) - } - 7 => { - let e123 = { - let l99 = i32::from(*base.add(8).cast::()); - match l99 { - 0 => { - let e = { - let l100 = i32::from(*base.add(12).cast::()); - match l100 { - 0 => None, - 1 => { - let e = { - let l101 = *base.add(16).cast::(); - l101 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l102 = i32::from(*base.add(12).cast::()); - match l102 { - 0 => None, - 1 => { - let e = { - let l103 = *base.add(16).cast::(); - l103 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V123::ResultValue(e123) - } - 8 => { - let e123 = { - let l104 = i32::from(*base.add(8).cast::()); - l104 as u8 - }; - V123::PrimU8(e123) - } - 9 => { - let e123 = { - let l105 = i32::from(*base.add(8).cast::()); - l105 as u16 - }; - V123::PrimU16(e123) - } - 10 => { - let e123 = { - let l106 = *base.add(8).cast::(); - l106 as u32 - }; - V123::PrimU32(e123) - } - 11 => { - let e123 = { - let l107 = *base.add(8).cast::(); - l107 as u64 - }; - V123::PrimU64(e123) - } - 12 => { - let e123 = { - let l108 = i32::from(*base.add(8).cast::()); - l108 as i8 - }; - V123::PrimS8(e123) - } - 13 => { - let e123 = { - let l109 = i32::from(*base.add(8).cast::()); - l109 as i16 - }; - V123::PrimS16(e123) - } - 14 => { - let e123 = { - let l110 = *base.add(8).cast::(); - l110 - }; - V123::PrimS32(e123) - } - 15 => { - let e123 = { - let l111 = *base.add(8).cast::(); - l111 - }; - V123::PrimS64(e123) - } - 16 => { - let e123 = { - let l112 = *base.add(8).cast::(); - l112 - }; - V123::PrimFloat32(e123) - } - 17 => { - let e123 = { - let l113 = *base.add(8).cast::(); - l113 - }; - V123::PrimFloat64(e123) - } - 18 => { - let e123 = { - let l114 = *base.add(8).cast::(); - _rt::char_lift(l114 as u32) - }; - V123::PrimChar(e123) - } - 19 => { - let e123 = { - let l115 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l115 as u8) - }; - V123::PrimBool(e123) - } - 20 => { - let e123 = { - let l116 = *base.add(8).cast::<*mut u8>(); - let l117 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len118 = l117; - let bytes118 = _rt::Vec::from_raw_parts( - l116.cast(), - len118, - len118, - ); - _rt::string_lift(bytes118) - }; - V123::PrimString(e123) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e123 = { - let l119 = *base.add(8).cast::<*mut u8>(); - let l120 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len121 = l120; - let bytes121 = _rt::Vec::from_raw_parts( - l119.cast(), - len121, - len121, - ); - let l122 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes121), - }, - l122 as u64, - ) - }; - V123::Handle(e123) - } - }; - v123 - }; - result124.push(e124); - } - _rt::cabi_dealloc( - base124, - len124 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l125 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l126 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base175 = l125; - let len175 = l126; - let mut result175 = _rt::Vec::with_capacity(len175); - for i in 0..len175 { - let base = base175 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e175 = { - let l127 = i32::from(*base.add(0).cast::()); - let l131 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l135 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V174; - let v174 = match l135 { - 0 => { - let e174 = { - let l136 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l137 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base142 = l136; - let len142 = l137; - let mut result142 = _rt::Vec::with_capacity(len142); - for i in 0..len142 { - let base = base142 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e142 = { - let l138 = *base.add(0).cast::<*mut u8>(); - let l139 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len140 = l139; - let bytes140 = _rt::Vec::from_raw_parts( - l138.cast(), - len140, - len140, - ); - let l141 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes140), l141) - }; - result142.push(e142); - } - _rt::cabi_dealloc( - base142, - len142 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result142 - }; - V174::RecordType(e174) - } - 1 => { - let e174 = { - let l143 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l144 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base150 = l143; - let len150 = l144; - let mut result150 = _rt::Vec::with_capacity(len150); - for i in 0..len150 { - let base = base150 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e150 = { - let l145 = *base.add(0).cast::<*mut u8>(); - let l146 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len147 = l146; - let bytes147 = _rt::Vec::from_raw_parts( - l145.cast(), - len147, - len147, - ); - let l148 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes147), - match l148 { - 0 => None, - 1 => { - let e = { - let l149 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l149 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result150.push(e150); - } - _rt::cabi_dealloc( - base150, - len150 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result150 - }; - V174::VariantType(e174) - } - 2 => { - let e174 = { - let l151 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l152 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base156 = l151; - let len156 = l152; - let mut result156 = _rt::Vec::with_capacity(len156); - for i in 0..len156 { - let base = base156 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e156 = { - let l153 = *base.add(0).cast::<*mut u8>(); - let l154 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len155 = l154; - let bytes155 = _rt::Vec::from_raw_parts( - l153.cast(), - len155, - len155, - ); - _rt::string_lift(bytes155) - }; - result156.push(e156); - } - _rt::cabi_dealloc( - base156, - len156 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result156 - }; - V174::EnumType(e174) - } - 3 => { - let e174 = { - let l157 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l158 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base162 = l157; - let len162 = l158; - let mut result162 = _rt::Vec::with_capacity(len162); - for i in 0..len162 { - let base = base162 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e162 = { - let l159 = *base.add(0).cast::<*mut u8>(); - let l160 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len161 = l160; - let bytes161 = _rt::Vec::from_raw_parts( - l159.cast(), - len161, - len161, - ); - _rt::string_lift(bytes161) - }; - result162.push(e162); - } - _rt::cabi_dealloc( - base162, - len162 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result162 - }; - V174::FlagsType(e174) - } - 4 => { - let e174 = { - let l163 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l164 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len165 = l164; - _rt::Vec::from_raw_parts(l163.cast(), len165, len165) - }; - V174::TupleType(e174) - } - 5 => { - let e174 = { - let l166 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l166 - }; - V174::ListType(e174) - } - 6 => { - let e174 = { - let l167 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l167 - }; - V174::OptionType(e174) - } - 7 => { - let e174 = { - let l168 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l170 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l168 { - 0 => None, - 1 => { - let e = { - let l169 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l169 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l170 { - 0 => None, - 1 => { - let e = { - let l171 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l171 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V174::ResultType(e174) - } - 8 => V174::PrimU8Type, - 9 => V174::PrimU16Type, - 10 => V174::PrimU32Type, - 11 => V174::PrimU64Type, - 12 => V174::PrimS8Type, - 13 => V174::PrimS16Type, - 14 => V174::PrimS32Type, - 15 => V174::PrimS64Type, - 16 => V174::PrimF32Type, - 17 => V174::PrimF64Type, - 18 => V174::PrimCharType, - 19 => V174::PrimBoolType, - 20 => V174::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e174 = { - let l172 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l173 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l172 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l173 as u8, - ), - ) - }; - V174::HandleType(e174) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l127 { - 0 => None, - 1 => { - let e = { - let l128 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l129 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len130 = l129; - let bytes130 = _rt::Vec::from_raw_parts( - l128.cast(), - len130, - len130, - ); - _rt::string_lift(bytes130) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l131 { - 0 => None, - 1 => { - let e = { - let l132 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l133 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len134 = l133; - let bytes134 = _rt::Vec::from_raw_parts( - l132.cast(), - len134, - len134, - ); - _rt::string_lift(bytes134) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v174, - } - }; - result175.push(e175); - } - _rt::cabi_dealloc( - base175, - len175 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - LocalAgentConfigEntry { - path: result76, - value: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result124, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result175, - }, - }, - } - }; - result176.push(e176); - } - _rt::cabi_dealloc( - base176, - len176 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - CreateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l7 as u64, - nanoseconds: l8 as u32, - }, - agent_id: super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l9 as u64, - low_bits: l10 as u64, - }, - }, - agent_id: _rt::string_lift(bytes13), - }, - component_revision: l14 as u64, - args: result20, - env: result29, - created_by: super::super::super::golem::core::types::AccountId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l30 as u64, - low_bits: l31 as u64, - }, - }, - environment_id: super::super::super::golem::api::host::EnvironmentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l32 as u64, - low_bits: l33 as u64, - }, - }, - parent: match l34 { - 0 => None, - 1 => { - let e = { - let l35 = *base - .add(96 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l36 = *base - .add(104 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l37 = *base - .add(112 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l38 = *base - .add(112 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len39 = l38; - let bytes39 = _rt::Vec::from_raw_parts( - l37.cast(), - len39, - len39, - ); - super::super::super::golem::core::types::AgentId { - component_id: super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::golem::core::types::Uuid { - high_bits: l35 as u64, - low_bits: l36 as u64, - }, - }, - agent_id: _rt::string_lift(bytes39), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - component_size: l40 as u64, - initial_total_linear_memory_size: l41 as u64, - initial_active_plugins: result59, - config_vars: result68, - local_agent_config: result176, - } - }; - PublicOplogEntry::Create(e2676) - } - 1 => { - let e2676 = { - let l177 = *base.add(16).cast::(); - let l178 = *base.add(24).cast::(); - let l179 = *base.add(32).cast::<*mut u8>(); - let l180 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len181 = l180; - let bytes181 = _rt::Vec::from_raw_parts( - l179.cast(), - len181, - len181, - ); - let l182 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l183 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base229 = l182; - let len229 = l183; - let mut result229 = _rt::Vec::with_capacity(len229); - for i in 0..len229 { - let base = base229 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e229 = { - let l184 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V228; - let v228 = match l184 { - 0 => { - let e228 = { - let l185 = *base.add(8).cast::<*mut u8>(); - let l186 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len187 = l186; - _rt::Vec::from_raw_parts(l185.cast(), len187, len187) - }; - V228::RecordValue(e228) - } - 1 => { - let e228 = { - let l188 = *base.add(8).cast::(); - let l189 = i32::from(*base.add(12).cast::()); - ( - l188 as u32, - match l189 { - 0 => None, - 1 => { - let e = { - let l190 = *base.add(16).cast::(); - l190 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V228::VariantValue(e228) - } - 2 => { - let e228 = { - let l191 = *base.add(8).cast::(); - l191 as u32 - }; - V228::EnumValue(e228) - } - 3 => { - let e228 = { - let l192 = *base.add(8).cast::<*mut u8>(); - let l193 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base195 = l192; - let len195 = l193; - let mut result195 = _rt::Vec::with_capacity(len195); - for i in 0..len195 { - let base = base195.add(i * 1); - let e195 = { - let l194 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l194 as u8) - }; - result195.push(e195); - } - _rt::cabi_dealloc(base195, len195 * 1, 1); - result195 - }; - V228::FlagsValue(e228) - } - 4 => { - let e228 = { - let l196 = *base.add(8).cast::<*mut u8>(); - let l197 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len198 = l197; - _rt::Vec::from_raw_parts(l196.cast(), len198, len198) - }; - V228::TupleValue(e228) - } - 5 => { - let e228 = { - let l199 = *base.add(8).cast::<*mut u8>(); - let l200 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len201 = l200; - _rt::Vec::from_raw_parts(l199.cast(), len201, len201) - }; - V228::ListValue(e228) - } - 6 => { - let e228 = { - let l202 = i32::from(*base.add(8).cast::()); - match l202 { - 0 => None, - 1 => { - let e = { - let l203 = *base.add(12).cast::(); - l203 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V228::OptionValue(e228) - } - 7 => { - let e228 = { - let l204 = i32::from(*base.add(8).cast::()); - match l204 { - 0 => { - let e = { - let l205 = i32::from(*base.add(12).cast::()); - match l205 { - 0 => None, - 1 => { - let e = { - let l206 = *base.add(16).cast::(); - l206 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l207 = i32::from(*base.add(12).cast::()); - match l207 { - 0 => None, - 1 => { - let e = { - let l208 = *base.add(16).cast::(); - l208 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V228::ResultValue(e228) - } - 8 => { - let e228 = { - let l209 = i32::from(*base.add(8).cast::()); - l209 as u8 - }; - V228::PrimU8(e228) - } - 9 => { - let e228 = { - let l210 = i32::from(*base.add(8).cast::()); - l210 as u16 - }; - V228::PrimU16(e228) - } - 10 => { - let e228 = { - let l211 = *base.add(8).cast::(); - l211 as u32 - }; - V228::PrimU32(e228) - } - 11 => { - let e228 = { - let l212 = *base.add(8).cast::(); - l212 as u64 - }; - V228::PrimU64(e228) - } - 12 => { - let e228 = { - let l213 = i32::from(*base.add(8).cast::()); - l213 as i8 - }; - V228::PrimS8(e228) - } - 13 => { - let e228 = { - let l214 = i32::from(*base.add(8).cast::()); - l214 as i16 - }; - V228::PrimS16(e228) - } - 14 => { - let e228 = { - let l215 = *base.add(8).cast::(); - l215 - }; - V228::PrimS32(e228) - } - 15 => { - let e228 = { - let l216 = *base.add(8).cast::(); - l216 - }; - V228::PrimS64(e228) - } - 16 => { - let e228 = { - let l217 = *base.add(8).cast::(); - l217 - }; - V228::PrimFloat32(e228) - } - 17 => { - let e228 = { - let l218 = *base.add(8).cast::(); - l218 - }; - V228::PrimFloat64(e228) - } - 18 => { - let e228 = { - let l219 = *base.add(8).cast::(); - _rt::char_lift(l219 as u32) - }; - V228::PrimChar(e228) - } - 19 => { - let e228 = { - let l220 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l220 as u8) - }; - V228::PrimBool(e228) - } - 20 => { - let e228 = { - let l221 = *base.add(8).cast::<*mut u8>(); - let l222 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len223 = l222; - let bytes223 = _rt::Vec::from_raw_parts( - l221.cast(), - len223, - len223, - ); - _rt::string_lift(bytes223) - }; - V228::PrimString(e228) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e228 = { - let l224 = *base.add(8).cast::<*mut u8>(); - let l225 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len226 = l225; - let bytes226 = _rt::Vec::from_raw_parts( - l224.cast(), - len226, - len226, - ); - let l227 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes226), - }, - l227 as u64, - ) - }; - V228::Handle(e228) - } - }; - v228 - }; - result229.push(e229); - } - _rt::cabi_dealloc( - base229, - len229 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l230 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l231 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base280 = l230; - let len280 = l231; - let mut result280 = _rt::Vec::with_capacity(len280); - for i in 0..len280 { - let base = base280 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e280 = { - let l232 = i32::from(*base.add(0).cast::()); - let l236 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l240 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V279; - let v279 = match l240 { - 0 => { - let e279 = { - let l241 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l242 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base247 = l241; - let len247 = l242; - let mut result247 = _rt::Vec::with_capacity(len247); - for i in 0..len247 { - let base = base247 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e247 = { - let l243 = *base.add(0).cast::<*mut u8>(); - let l244 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len245 = l244; - let bytes245 = _rt::Vec::from_raw_parts( - l243.cast(), - len245, - len245, - ); - let l246 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes245), l246) - }; - result247.push(e247); - } - _rt::cabi_dealloc( - base247, - len247 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result247 - }; - V279::RecordType(e279) - } - 1 => { - let e279 = { - let l248 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l249 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base255 = l248; - let len255 = l249; - let mut result255 = _rt::Vec::with_capacity(len255); - for i in 0..len255 { - let base = base255 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e255 = { - let l250 = *base.add(0).cast::<*mut u8>(); - let l251 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len252 = l251; - let bytes252 = _rt::Vec::from_raw_parts( - l250.cast(), - len252, - len252, - ); - let l253 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes252), - match l253 { - 0 => None, - 1 => { - let e = { - let l254 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l254 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result255.push(e255); - } - _rt::cabi_dealloc( - base255, - len255 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result255 - }; - V279::VariantType(e279) - } - 2 => { - let e279 = { - let l256 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l257 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base261 = l256; - let len261 = l257; - let mut result261 = _rt::Vec::with_capacity(len261); - for i in 0..len261 { - let base = base261 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e261 = { - let l258 = *base.add(0).cast::<*mut u8>(); - let l259 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len260 = l259; - let bytes260 = _rt::Vec::from_raw_parts( - l258.cast(), - len260, - len260, - ); - _rt::string_lift(bytes260) - }; - result261.push(e261); - } - _rt::cabi_dealloc( - base261, - len261 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result261 - }; - V279::EnumType(e279) - } - 3 => { - let e279 = { - let l262 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l263 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base267 = l262; - let len267 = l263; - let mut result267 = _rt::Vec::with_capacity(len267); - for i in 0..len267 { - let base = base267 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e267 = { - let l264 = *base.add(0).cast::<*mut u8>(); - let l265 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len266 = l265; - let bytes266 = _rt::Vec::from_raw_parts( - l264.cast(), - len266, - len266, - ); - _rt::string_lift(bytes266) - }; - result267.push(e267); - } - _rt::cabi_dealloc( - base267, - len267 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result267 - }; - V279::FlagsType(e279) - } - 4 => { - let e279 = { - let l268 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l269 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len270 = l269; - _rt::Vec::from_raw_parts(l268.cast(), len270, len270) - }; - V279::TupleType(e279) - } - 5 => { - let e279 = { - let l271 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l271 - }; - V279::ListType(e279) - } - 6 => { - let e279 = { - let l272 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l272 - }; - V279::OptionType(e279) - } - 7 => { - let e279 = { - let l273 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l275 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l273 { - 0 => None, - 1 => { - let e = { - let l274 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l274 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l275 { - 0 => None, - 1 => { - let e = { - let l276 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l276 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V279::ResultType(e279) - } - 8 => V279::PrimU8Type, - 9 => V279::PrimU16Type, - 10 => V279::PrimU32Type, - 11 => V279::PrimU64Type, - 12 => V279::PrimS8Type, - 13 => V279::PrimS16Type, - 14 => V279::PrimS32Type, - 15 => V279::PrimS64Type, - 16 => V279::PrimF32Type, - 17 => V279::PrimF64Type, - 18 => V279::PrimCharType, - 19 => V279::PrimBoolType, - 20 => V279::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e279 = { - let l277 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l278 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l277 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l278 as u8, - ), - ) - }; - V279::HandleType(e279) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l232 { - 0 => None, - 1 => { - let e = { - let l233 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l234 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len235 = l234; - let bytes235 = _rt::Vec::from_raw_parts( - l233.cast(), - len235, - len235, - ); - _rt::string_lift(bytes235) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l236 { - 0 => None, - 1 => { - let e = { - let l237 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l238 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len239 = l238; - let bytes239 = _rt::Vec::from_raw_parts( - l237.cast(), - len239, - len239, - ); - _rt::string_lift(bytes239) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v279, - } - }; - result280.push(e280); - } - _rt::cabi_dealloc( - base280, - len280 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l281 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l282 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base328 = l281; - let len328 = l282; - let mut result328 = _rt::Vec::with_capacity(len328); - for i in 0..len328 { - let base = base328 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e328 = { - let l283 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V327; - let v327 = match l283 { - 0 => { - let e327 = { - let l284 = *base.add(8).cast::<*mut u8>(); - let l285 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len286 = l285; - _rt::Vec::from_raw_parts(l284.cast(), len286, len286) - }; - V327::RecordValue(e327) - } - 1 => { - let e327 = { - let l287 = *base.add(8).cast::(); - let l288 = i32::from(*base.add(12).cast::()); - ( - l287 as u32, - match l288 { - 0 => None, - 1 => { - let e = { - let l289 = *base.add(16).cast::(); - l289 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V327::VariantValue(e327) - } - 2 => { - let e327 = { - let l290 = *base.add(8).cast::(); - l290 as u32 - }; - V327::EnumValue(e327) - } - 3 => { - let e327 = { - let l291 = *base.add(8).cast::<*mut u8>(); - let l292 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base294 = l291; - let len294 = l292; - let mut result294 = _rt::Vec::with_capacity(len294); - for i in 0..len294 { - let base = base294.add(i * 1); - let e294 = { - let l293 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l293 as u8) - }; - result294.push(e294); - } - _rt::cabi_dealloc(base294, len294 * 1, 1); - result294 - }; - V327::FlagsValue(e327) - } - 4 => { - let e327 = { - let l295 = *base.add(8).cast::<*mut u8>(); - let l296 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len297 = l296; - _rt::Vec::from_raw_parts(l295.cast(), len297, len297) - }; - V327::TupleValue(e327) - } - 5 => { - let e327 = { - let l298 = *base.add(8).cast::<*mut u8>(); - let l299 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len300 = l299; - _rt::Vec::from_raw_parts(l298.cast(), len300, len300) - }; - V327::ListValue(e327) - } - 6 => { - let e327 = { - let l301 = i32::from(*base.add(8).cast::()); - match l301 { - 0 => None, - 1 => { - let e = { - let l302 = *base.add(12).cast::(); - l302 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V327::OptionValue(e327) - } - 7 => { - let e327 = { - let l303 = i32::from(*base.add(8).cast::()); - match l303 { - 0 => { - let e = { - let l304 = i32::from(*base.add(12).cast::()); - match l304 { - 0 => None, - 1 => { - let e = { - let l305 = *base.add(16).cast::(); - l305 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l306 = i32::from(*base.add(12).cast::()); - match l306 { - 0 => None, - 1 => { - let e = { - let l307 = *base.add(16).cast::(); - l307 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V327::ResultValue(e327) - } - 8 => { - let e327 = { - let l308 = i32::from(*base.add(8).cast::()); - l308 as u8 - }; - V327::PrimU8(e327) - } - 9 => { - let e327 = { - let l309 = i32::from(*base.add(8).cast::()); - l309 as u16 - }; - V327::PrimU16(e327) - } - 10 => { - let e327 = { - let l310 = *base.add(8).cast::(); - l310 as u32 - }; - V327::PrimU32(e327) - } - 11 => { - let e327 = { - let l311 = *base.add(8).cast::(); - l311 as u64 - }; - V327::PrimU64(e327) - } - 12 => { - let e327 = { - let l312 = i32::from(*base.add(8).cast::()); - l312 as i8 - }; - V327::PrimS8(e327) - } - 13 => { - let e327 = { - let l313 = i32::from(*base.add(8).cast::()); - l313 as i16 - }; - V327::PrimS16(e327) - } - 14 => { - let e327 = { - let l314 = *base.add(8).cast::(); - l314 - }; - V327::PrimS32(e327) - } - 15 => { - let e327 = { - let l315 = *base.add(8).cast::(); - l315 - }; - V327::PrimS64(e327) - } - 16 => { - let e327 = { - let l316 = *base.add(8).cast::(); - l316 - }; - V327::PrimFloat32(e327) - } - 17 => { - let e327 = { - let l317 = *base.add(8).cast::(); - l317 - }; - V327::PrimFloat64(e327) - } - 18 => { - let e327 = { - let l318 = *base.add(8).cast::(); - _rt::char_lift(l318 as u32) - }; - V327::PrimChar(e327) - } - 19 => { - let e327 = { - let l319 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l319 as u8) - }; - V327::PrimBool(e327) - } - 20 => { - let e327 = { - let l320 = *base.add(8).cast::<*mut u8>(); - let l321 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len322 = l321; - let bytes322 = _rt::Vec::from_raw_parts( - l320.cast(), - len322, - len322, - ); - _rt::string_lift(bytes322) - }; - V327::PrimString(e327) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e327 = { - let l323 = *base.add(8).cast::<*mut u8>(); - let l324 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len325 = l324; - let bytes325 = _rt::Vec::from_raw_parts( - l323.cast(), - len325, - len325, - ); - let l326 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes325), - }, - l326 as u64, - ) - }; - V327::Handle(e327) - } - }; - v327 - }; - result328.push(e328); - } - _rt::cabi_dealloc( - base328, - len328 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l329 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l330 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base379 = l329; - let len379 = l330; - let mut result379 = _rt::Vec::with_capacity(len379); - for i in 0..len379 { - let base = base379 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e379 = { - let l331 = i32::from(*base.add(0).cast::()); - let l335 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l339 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V378; - let v378 = match l339 { - 0 => { - let e378 = { - let l340 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l341 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base346 = l340; - let len346 = l341; - let mut result346 = _rt::Vec::with_capacity(len346); - for i in 0..len346 { - let base = base346 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e346 = { - let l342 = *base.add(0).cast::<*mut u8>(); - let l343 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len344 = l343; - let bytes344 = _rt::Vec::from_raw_parts( - l342.cast(), - len344, - len344, - ); - let l345 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes344), l345) - }; - result346.push(e346); - } - _rt::cabi_dealloc( - base346, - len346 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result346 - }; - V378::RecordType(e378) - } - 1 => { - let e378 = { - let l347 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l348 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base354 = l347; - let len354 = l348; - let mut result354 = _rt::Vec::with_capacity(len354); - for i in 0..len354 { - let base = base354 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e354 = { - let l349 = *base.add(0).cast::<*mut u8>(); - let l350 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len351 = l350; - let bytes351 = _rt::Vec::from_raw_parts( - l349.cast(), - len351, - len351, - ); - let l352 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes351), - match l352 { - 0 => None, - 1 => { - let e = { - let l353 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l353 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result354.push(e354); - } - _rt::cabi_dealloc( - base354, - len354 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result354 - }; - V378::VariantType(e378) - } - 2 => { - let e378 = { - let l355 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l356 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base360 = l355; - let len360 = l356; - let mut result360 = _rt::Vec::with_capacity(len360); - for i in 0..len360 { - let base = base360 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e360 = { - let l357 = *base.add(0).cast::<*mut u8>(); - let l358 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len359 = l358; - let bytes359 = _rt::Vec::from_raw_parts( - l357.cast(), - len359, - len359, - ); - _rt::string_lift(bytes359) - }; - result360.push(e360); - } - _rt::cabi_dealloc( - base360, - len360 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result360 - }; - V378::EnumType(e378) - } - 3 => { - let e378 = { - let l361 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l362 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base366 = l361; - let len366 = l362; - let mut result366 = _rt::Vec::with_capacity(len366); - for i in 0..len366 { - let base = base366 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e366 = { - let l363 = *base.add(0).cast::<*mut u8>(); - let l364 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len365 = l364; - let bytes365 = _rt::Vec::from_raw_parts( - l363.cast(), - len365, - len365, - ); - _rt::string_lift(bytes365) - }; - result366.push(e366); - } - _rt::cabi_dealloc( - base366, - len366 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result366 - }; - V378::FlagsType(e378) - } - 4 => { - let e378 = { - let l367 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l368 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len369 = l368; - _rt::Vec::from_raw_parts(l367.cast(), len369, len369) - }; - V378::TupleType(e378) - } - 5 => { - let e378 = { - let l370 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l370 - }; - V378::ListType(e378) - } - 6 => { - let e378 = { - let l371 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l371 - }; - V378::OptionType(e378) - } - 7 => { - let e378 = { - let l372 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l374 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l372 { - 0 => None, - 1 => { - let e = { - let l373 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l373 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l374 { - 0 => None, - 1 => { - let e = { - let l375 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l375 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V378::ResultType(e378) - } - 8 => V378::PrimU8Type, - 9 => V378::PrimU16Type, - 10 => V378::PrimU32Type, - 11 => V378::PrimU64Type, - 12 => V378::PrimS8Type, - 13 => V378::PrimS16Type, - 14 => V378::PrimS32Type, - 15 => V378::PrimS64Type, - 16 => V378::PrimF32Type, - 17 => V378::PrimF64Type, - 18 => V378::PrimCharType, - 19 => V378::PrimBoolType, - 20 => V378::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e378 = { - let l376 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l377 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l376 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l377 as u8, - ), - ) - }; - V378::HandleType(e378) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l331 { - 0 => None, - 1 => { - let e = { - let l332 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l333 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len334 = l333; - let bytes334 = _rt::Vec::from_raw_parts( - l332.cast(), - len334, - len334, - ); - _rt::string_lift(bytes334) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l335 { - 0 => None, - 1 => { - let e = { - let l336 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l337 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len338 = l337; - let bytes338 = _rt::Vec::from_raw_parts( - l336.cast(), - len338, - len338, - ); - _rt::string_lift(bytes338) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v378, - } - }; - result379.push(e379); - } - _rt::cabi_dealloc( - base379, - len379 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let l380 = i32::from( - *base - .add(32 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let v385 = match l380 { - 0 => WrappedFunctionType::ReadLocal, - 1 => WrappedFunctionType::WriteLocal, - 2 => WrappedFunctionType::ReadRemote, - 3 => WrappedFunctionType::WriteRemote, - 4 => { - let e385 = { - let l381 = i32::from( - *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l381 { - 0 => None, - 1 => { - let e = { - let l382 = *base - .add(48 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l382 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteBatched(e385) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e385 = { - let l383 = i32::from( - *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l383 { - 0 => None, - 1 => { - let e = { - let l384 = *base - .add(48 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l384 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - WrappedFunctionType::WriteRemoteTransaction(e385) - } - }; - HostCallParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l177 as u64, - nanoseconds: l178 as u32, - }, - function_name: _rt::string_lift(bytes181), - request: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result229, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result280, - }, - }, - response: super::super::super::golem::core::types::ValueAndType { - value: super::super::super::golem::core::types::WitValue { - nodes: result328, - }, - typ: super::super::super::golem::core::types::WitType { - nodes: result379, - }, - }, - wrapped_function_type: v385, - } - }; - PublicOplogEntry::HostCall(e2676) - } - 2 => { - let e2676 = { - let l386 = *base.add(16).cast::(); - let l387 = *base.add(24).cast::(); - let l388 = i32::from(*base.add(32).cast::()); - let v1104 = match l388 { - 0 => { - let e1104 = { - let l389 = *base.add(40).cast::<*mut u8>(); - let l390 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len391 = l390; - let bytes391 = _rt::Vec::from_raw_parts( - l389.cast(), - len391, - len391, - ); - let l392 = i32::from( - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V548; - let v548 = match l392 { - 0 => { - let e548 = { - let l393 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l394 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base468 = l393; - let len468 = l394; - let mut result468 = _rt::Vec::with_capacity(len468); - for i in 0..len468 { - let base = base468 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e468 = { - let l395 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V467; - let v467 = match l395 { - 0 => { - let e467 = { - let l396 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l397 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base443 = l396; - let len443 = l397; - let mut result443 = _rt::Vec::with_capacity(len443); - for i in 0..len443 { - let base = base443 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e443 = { - let l398 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V442; - let v442 = match l398 { - 0 => { - let e442 = { - let l399 = *base.add(8).cast::<*mut u8>(); - let l400 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len401 = l400; - _rt::Vec::from_raw_parts(l399.cast(), len401, len401) - }; - V442::RecordValue(e442) - } - 1 => { - let e442 = { - let l402 = *base.add(8).cast::(); - let l403 = i32::from(*base.add(12).cast::()); - ( - l402 as u32, - match l403 { - 0 => None, - 1 => { - let e = { - let l404 = *base.add(16).cast::(); - l404 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V442::VariantValue(e442) - } - 2 => { - let e442 = { - let l405 = *base.add(8).cast::(); - l405 as u32 - }; - V442::EnumValue(e442) - } - 3 => { - let e442 = { - let l406 = *base.add(8).cast::<*mut u8>(); - let l407 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base409 = l406; - let len409 = l407; - let mut result409 = _rt::Vec::with_capacity(len409); - for i in 0..len409 { - let base = base409.add(i * 1); - let e409 = { - let l408 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l408 as u8) - }; - result409.push(e409); - } - _rt::cabi_dealloc(base409, len409 * 1, 1); - result409 - }; - V442::FlagsValue(e442) - } - 4 => { - let e442 = { - let l410 = *base.add(8).cast::<*mut u8>(); - let l411 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len412 = l411; - _rt::Vec::from_raw_parts(l410.cast(), len412, len412) - }; - V442::TupleValue(e442) - } - 5 => { - let e442 = { - let l413 = *base.add(8).cast::<*mut u8>(); - let l414 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len415 = l414; - _rt::Vec::from_raw_parts(l413.cast(), len415, len415) - }; - V442::ListValue(e442) - } - 6 => { - let e442 = { - let l416 = i32::from(*base.add(8).cast::()); - match l416 { - 0 => None, - 1 => { - let e = { - let l417 = *base.add(12).cast::(); - l417 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V442::OptionValue(e442) - } - 7 => { - let e442 = { - let l418 = i32::from(*base.add(8).cast::()); - match l418 { - 0 => { - let e = { - let l419 = i32::from(*base.add(12).cast::()); - match l419 { - 0 => None, - 1 => { - let e = { - let l420 = *base.add(16).cast::(); - l420 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l421 = i32::from(*base.add(12).cast::()); - match l421 { - 0 => None, - 1 => { - let e = { - let l422 = *base.add(16).cast::(); - l422 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V442::ResultValue(e442) - } - 8 => { - let e442 = { - let l423 = i32::from(*base.add(8).cast::()); - l423 as u8 - }; - V442::PrimU8(e442) - } - 9 => { - let e442 = { - let l424 = i32::from(*base.add(8).cast::()); - l424 as u16 - }; - V442::PrimU16(e442) - } - 10 => { - let e442 = { - let l425 = *base.add(8).cast::(); - l425 as u32 - }; - V442::PrimU32(e442) - } - 11 => { - let e442 = { - let l426 = *base.add(8).cast::(); - l426 as u64 - }; - V442::PrimU64(e442) - } - 12 => { - let e442 = { - let l427 = i32::from(*base.add(8).cast::()); - l427 as i8 - }; - V442::PrimS8(e442) - } - 13 => { - let e442 = { - let l428 = i32::from(*base.add(8).cast::()); - l428 as i16 - }; - V442::PrimS16(e442) - } - 14 => { - let e442 = { - let l429 = *base.add(8).cast::(); - l429 - }; - V442::PrimS32(e442) - } - 15 => { - let e442 = { - let l430 = *base.add(8).cast::(); - l430 - }; - V442::PrimS64(e442) - } - 16 => { - let e442 = { - let l431 = *base.add(8).cast::(); - l431 - }; - V442::PrimFloat32(e442) - } - 17 => { - let e442 = { - let l432 = *base.add(8).cast::(); - l432 - }; - V442::PrimFloat64(e442) - } - 18 => { - let e442 = { - let l433 = *base.add(8).cast::(); - _rt::char_lift(l433 as u32) - }; - V442::PrimChar(e442) - } - 19 => { - let e442 = { - let l434 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l434 as u8) - }; - V442::PrimBool(e442) - } - 20 => { - let e442 = { - let l435 = *base.add(8).cast::<*mut u8>(); - let l436 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len437 = l436; - let bytes437 = _rt::Vec::from_raw_parts( - l435.cast(), - len437, - len437, - ); - _rt::string_lift(bytes437) - }; - V442::PrimString(e442) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e442 = { - let l438 = *base.add(8).cast::<*mut u8>(); - let l439 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len440 = l439; - let bytes440 = _rt::Vec::from_raw_parts( - l438.cast(), - len440, - len440, - ); - let l441 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes440), - }, - l441 as u64, - ) - }; - V442::Handle(e442) - } - }; - v442 - }; - result443.push(e443); - } - _rt::cabi_dealloc( - base443, - len443 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result443, - } - }; - V467::ComponentModel(e467) - } - 1 => { - let e467 = { - let l444 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V455; - let v455 = match l444 { - 0 => { - let e455 = { - let l445 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l446 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len447 = l446; - let bytes447 = _rt::Vec::from_raw_parts( - l445.cast(), - len447, - len447, - ); - _rt::string_lift(bytes447) - }; - V455::Url(e455) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e455 = { - let l448 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l449 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len450 = l449; - let bytes450 = _rt::Vec::from_raw_parts( - l448.cast(), - len450, - len450, - ); - let l451 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes450), - text_type: match l451 { - 0 => None, - 1 => { - let e = { - let l452 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l453 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len454 = l453; - let bytes454 = _rt::Vec::from_raw_parts( - l452.cast(), - len454, - len454, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes454), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V455::Inline(e455) - } - }; - v455 - }; - V467::UnstructuredText(e467) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e467 = { - let l456 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V466; - let v466 = match l456 { - 0 => { - let e466 = { - let l457 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l458 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len459 = l458; - let bytes459 = _rt::Vec::from_raw_parts( - l457.cast(), - len459, - len459, - ); - _rt::string_lift(bytes459) - }; - V466::Url(e466) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e466 = { - let l460 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l461 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len462 = l461; - let l463 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l464 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len465 = l464; - let bytes465 = _rt::Vec::from_raw_parts( - l463.cast(), - len465, - len465, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l460.cast(), len462, len462), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes465), - }, - } - }; - V466::Inline(e466) - } - }; - v466 - }; - V467::UnstructuredBinary(e467) - } - }; - v467 - }; - result468.push(e468); - } - _rt::cabi_dealloc( - base468, - len468 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result468 - }; - V548::Tuple(e548) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e548 = { - let l469 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l470 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base547 = l469; - let len547 = l470; - let mut result547 = _rt::Vec::with_capacity(len547); - for i in 0..len547 { - let base = base547 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e547 = { - let l471 = *base.add(0).cast::<*mut u8>(); - let l472 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len473 = l472; - let bytes473 = _rt::Vec::from_raw_parts( - l471.cast(), - len473, - len473, - ); - let l474 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V546; - let v546 = match l474 { - 0 => { - let e546 = { - let l475 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l476 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base522 = l475; - let len522 = l476; - let mut result522 = _rt::Vec::with_capacity(len522); - for i in 0..len522 { - let base = base522 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e522 = { - let l477 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V521; - let v521 = match l477 { - 0 => { - let e521 = { - let l478 = *base.add(8).cast::<*mut u8>(); - let l479 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len480 = l479; - _rt::Vec::from_raw_parts(l478.cast(), len480, len480) - }; - V521::RecordValue(e521) - } - 1 => { - let e521 = { - let l481 = *base.add(8).cast::(); - let l482 = i32::from(*base.add(12).cast::()); - ( - l481 as u32, - match l482 { - 0 => None, - 1 => { - let e = { - let l483 = *base.add(16).cast::(); - l483 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V521::VariantValue(e521) - } - 2 => { - let e521 = { - let l484 = *base.add(8).cast::(); - l484 as u32 - }; - V521::EnumValue(e521) - } - 3 => { - let e521 = { - let l485 = *base.add(8).cast::<*mut u8>(); - let l486 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base488 = l485; - let len488 = l486; - let mut result488 = _rt::Vec::with_capacity(len488); - for i in 0..len488 { - let base = base488.add(i * 1); - let e488 = { - let l487 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l487 as u8) - }; - result488.push(e488); - } - _rt::cabi_dealloc(base488, len488 * 1, 1); - result488 - }; - V521::FlagsValue(e521) - } - 4 => { - let e521 = { - let l489 = *base.add(8).cast::<*mut u8>(); - let l490 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len491 = l490; - _rt::Vec::from_raw_parts(l489.cast(), len491, len491) - }; - V521::TupleValue(e521) - } - 5 => { - let e521 = { - let l492 = *base.add(8).cast::<*mut u8>(); - let l493 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len494 = l493; - _rt::Vec::from_raw_parts(l492.cast(), len494, len494) - }; - V521::ListValue(e521) - } - 6 => { - let e521 = { - let l495 = i32::from(*base.add(8).cast::()); - match l495 { - 0 => None, - 1 => { - let e = { - let l496 = *base.add(12).cast::(); - l496 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V521::OptionValue(e521) - } - 7 => { - let e521 = { - let l497 = i32::from(*base.add(8).cast::()); - match l497 { - 0 => { - let e = { - let l498 = i32::from(*base.add(12).cast::()); - match l498 { - 0 => None, - 1 => { - let e = { - let l499 = *base.add(16).cast::(); - l499 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l500 = i32::from(*base.add(12).cast::()); - match l500 { - 0 => None, - 1 => { - let e = { - let l501 = *base.add(16).cast::(); - l501 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V521::ResultValue(e521) - } - 8 => { - let e521 = { - let l502 = i32::from(*base.add(8).cast::()); - l502 as u8 - }; - V521::PrimU8(e521) - } - 9 => { - let e521 = { - let l503 = i32::from(*base.add(8).cast::()); - l503 as u16 - }; - V521::PrimU16(e521) - } - 10 => { - let e521 = { - let l504 = *base.add(8).cast::(); - l504 as u32 - }; - V521::PrimU32(e521) - } - 11 => { - let e521 = { - let l505 = *base.add(8).cast::(); - l505 as u64 - }; - V521::PrimU64(e521) - } - 12 => { - let e521 = { - let l506 = i32::from(*base.add(8).cast::()); - l506 as i8 - }; - V521::PrimS8(e521) - } - 13 => { - let e521 = { - let l507 = i32::from(*base.add(8).cast::()); - l507 as i16 - }; - V521::PrimS16(e521) - } - 14 => { - let e521 = { - let l508 = *base.add(8).cast::(); - l508 - }; - V521::PrimS32(e521) - } - 15 => { - let e521 = { - let l509 = *base.add(8).cast::(); - l509 - }; - V521::PrimS64(e521) - } - 16 => { - let e521 = { - let l510 = *base.add(8).cast::(); - l510 - }; - V521::PrimFloat32(e521) - } - 17 => { - let e521 = { - let l511 = *base.add(8).cast::(); - l511 - }; - V521::PrimFloat64(e521) - } - 18 => { - let e521 = { - let l512 = *base.add(8).cast::(); - _rt::char_lift(l512 as u32) - }; - V521::PrimChar(e521) - } - 19 => { - let e521 = { - let l513 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l513 as u8) - }; - V521::PrimBool(e521) - } - 20 => { - let e521 = { - let l514 = *base.add(8).cast::<*mut u8>(); - let l515 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len516 = l515; - let bytes516 = _rt::Vec::from_raw_parts( - l514.cast(), - len516, - len516, - ); - _rt::string_lift(bytes516) - }; - V521::PrimString(e521) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e521 = { - let l517 = *base.add(8).cast::<*mut u8>(); - let l518 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len519 = l518; - let bytes519 = _rt::Vec::from_raw_parts( - l517.cast(), - len519, - len519, - ); - let l520 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes519), - }, - l520 as u64, - ) - }; - V521::Handle(e521) - } - }; - v521 - }; - result522.push(e522); - } - _rt::cabi_dealloc( - base522, - len522 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result522, - } - }; - V546::ComponentModel(e546) - } - 1 => { - let e546 = { - let l523 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V534; - let v534 = match l523 { - 0 => { - let e534 = { - let l524 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l525 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len526 = l525; - let bytes526 = _rt::Vec::from_raw_parts( - l524.cast(), - len526, - len526, - ); - _rt::string_lift(bytes526) - }; - V534::Url(e534) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e534 = { - let l527 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l528 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len529 = l528; - let bytes529 = _rt::Vec::from_raw_parts( - l527.cast(), - len529, - len529, - ); - let l530 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes529), - text_type: match l530 { - 0 => None, - 1 => { - let e = { - let l531 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l532 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len533 = l532; - let bytes533 = _rt::Vec::from_raw_parts( - l531.cast(), - len533, - len533, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes533), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V534::Inline(e534) - } - }; - v534 - }; - V546::UnstructuredText(e546) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e546 = { - let l535 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V545; - let v545 = match l535 { - 0 => { - let e545 = { - let l536 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l537 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len538 = l537; - let bytes538 = _rt::Vec::from_raw_parts( - l536.cast(), - len538, - len538, - ); - _rt::string_lift(bytes538) - }; - V545::Url(e545) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e545 = { - let l539 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l540 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len541 = l540; - let l542 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l543 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len544 = l543; - let bytes544 = _rt::Vec::from_raw_parts( - l542.cast(), - len544, - len544, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l539.cast(), len541, len541), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes544), - }, - } - }; - V545::Inline(e545) - } - }; - v545 - }; - V546::UnstructuredBinary(e546) - } - }; - (_rt::string_lift(bytes473), v546) - }; - result547.push(e547); - } - _rt::cabi_dealloc( - base547, - len547 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result547 - }; - V548::Multimodal(e548) - } - }; - let l549 = i32::from( - *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V696; - let v696 = match l549 { - 0 => { - let e696 = { - let l550 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l551 = *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base622 = l550; - let len622 = l551; - let mut result622 = _rt::Vec::with_capacity(len622); - for i in 0..len622 { - let base = base622 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e622 = { - let l552 = *base.add(0).cast::<*mut u8>(); - let l553 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len554 = l553; - let bytes554 = _rt::Vec::from_raw_parts( - l552.cast(), - len554, - len554, - ); - let l555 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V621; - let v621 = match l555 { - 0 => { - let e621 = { - let l556 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l557 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base606 = l556; - let len606 = l557; - let mut result606 = _rt::Vec::with_capacity(len606); - for i in 0..len606 { - let base = base606 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e606 = { - let l558 = i32::from(*base.add(0).cast::()); - let l562 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l566 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V605; - let v605 = match l566 { - 0 => { - let e605 = { - let l567 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l568 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base573 = l567; - let len573 = l568; - let mut result573 = _rt::Vec::with_capacity(len573); - for i in 0..len573 { - let base = base573 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e573 = { - let l569 = *base.add(0).cast::<*mut u8>(); - let l570 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len571 = l570; - let bytes571 = _rt::Vec::from_raw_parts( - l569.cast(), - len571, - len571, - ); - let l572 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes571), l572) - }; - result573.push(e573); - } - _rt::cabi_dealloc( - base573, - len573 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result573 - }; - V605::RecordType(e605) - } - 1 => { - let e605 = { - let l574 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l575 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base581 = l574; - let len581 = l575; - let mut result581 = _rt::Vec::with_capacity(len581); - for i in 0..len581 { - let base = base581 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e581 = { - let l576 = *base.add(0).cast::<*mut u8>(); - let l577 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len578 = l577; - let bytes578 = _rt::Vec::from_raw_parts( - l576.cast(), - len578, - len578, - ); - let l579 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes578), - match l579 { - 0 => None, - 1 => { - let e = { - let l580 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l580 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result581.push(e581); - } - _rt::cabi_dealloc( - base581, - len581 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result581 - }; - V605::VariantType(e605) - } - 2 => { - let e605 = { - let l582 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l583 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base587 = l582; - let len587 = l583; - let mut result587 = _rt::Vec::with_capacity(len587); - for i in 0..len587 { - let base = base587 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e587 = { - let l584 = *base.add(0).cast::<*mut u8>(); - let l585 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len586 = l585; - let bytes586 = _rt::Vec::from_raw_parts( - l584.cast(), - len586, - len586, - ); - _rt::string_lift(bytes586) - }; - result587.push(e587); - } - _rt::cabi_dealloc( - base587, - len587 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result587 - }; - V605::EnumType(e605) - } - 3 => { - let e605 = { - let l588 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l589 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base593 = l588; - let len593 = l589; - let mut result593 = _rt::Vec::with_capacity(len593); - for i in 0..len593 { - let base = base593 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e593 = { - let l590 = *base.add(0).cast::<*mut u8>(); - let l591 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len592 = l591; - let bytes592 = _rt::Vec::from_raw_parts( - l590.cast(), - len592, - len592, - ); - _rt::string_lift(bytes592) - }; - result593.push(e593); - } - _rt::cabi_dealloc( - base593, - len593 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result593 - }; - V605::FlagsType(e605) - } - 4 => { - let e605 = { - let l594 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l595 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len596 = l595; - _rt::Vec::from_raw_parts(l594.cast(), len596, len596) - }; - V605::TupleType(e605) - } - 5 => { - let e605 = { - let l597 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l597 - }; - V605::ListType(e605) - } - 6 => { - let e605 = { - let l598 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l598 - }; - V605::OptionType(e605) - } - 7 => { - let e605 = { - let l599 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l601 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l599 { - 0 => None, - 1 => { - let e = { - let l600 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l600 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l601 { - 0 => None, - 1 => { - let e = { - let l602 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l602 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V605::ResultType(e605) - } - 8 => V605::PrimU8Type, - 9 => V605::PrimU16Type, - 10 => V605::PrimU32Type, - 11 => V605::PrimU64Type, - 12 => V605::PrimS8Type, - 13 => V605::PrimS16Type, - 14 => V605::PrimS32Type, - 15 => V605::PrimS64Type, - 16 => V605::PrimF32Type, - 17 => V605::PrimF64Type, - 18 => V605::PrimCharType, - 19 => V605::PrimBoolType, - 20 => V605::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e605 = { - let l603 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l604 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l603 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l604 as u8, - ), - ) - }; - V605::HandleType(e605) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l558 { - 0 => None, - 1 => { - let e = { - let l559 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l560 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len561 = l560; - let bytes561 = _rt::Vec::from_raw_parts( - l559.cast(), - len561, - len561, - ); - _rt::string_lift(bytes561) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l562 { - 0 => None, - 1 => { - let e = { - let l563 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l564 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len565 = l564; - let bytes565 = _rt::Vec::from_raw_parts( - l563.cast(), - len565, - len565, - ); - _rt::string_lift(bytes565) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v605, - } - }; - result606.push(e606); - } - _rt::cabi_dealloc( - base606, - len606 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result606, - } - }; - V621::ComponentModel(e621) - } - 1 => { - let e621 = { - let l607 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l607 { - 0 => None, - 1 => { - let e = { - let l608 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l609 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base613 = l608; - let len613 = l609; - let mut result613 = _rt::Vec::with_capacity(len613); - for i in 0..len613 { - let base = base613 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e613 = { - let l610 = *base.add(0).cast::<*mut u8>(); - let l611 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len612 = l611; - let bytes612 = _rt::Vec::from_raw_parts( - l610.cast(), - len612, - len612, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes612), - } - }; - result613.push(e613); - } - _rt::cabi_dealloc( - base613, - len613 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result613 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V621::UnstructuredText(e621) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e621 = { - let l614 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l614 { - 0 => None, - 1 => { - let e = { - let l615 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l616 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base620 = l615; - let len620 = l616; - let mut result620 = _rt::Vec::with_capacity(len620); - for i in 0..len620 { - let base = base620 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e620 = { - let l617 = *base.add(0).cast::<*mut u8>(); - let l618 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len619 = l618; - let bytes619 = _rt::Vec::from_raw_parts( - l617.cast(), - len619, - len619, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes619), - } - }; - result620.push(e620); - } - _rt::cabi_dealloc( - base620, - len620 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result620 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V621::UnstructuredBinary(e621) - } - }; - (_rt::string_lift(bytes554), v621) - }; - result622.push(e622); - } - _rt::cabi_dealloc( - base622, - len622 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result622 - }; - V696::Tuple(e696) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e696 = { - let l623 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l624 = *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base695 = l623; - let len695 = l624; - let mut result695 = _rt::Vec::with_capacity(len695); - for i in 0..len695 { - let base = base695 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e695 = { - let l625 = *base.add(0).cast::<*mut u8>(); - let l626 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len627 = l626; - let bytes627 = _rt::Vec::from_raw_parts( - l625.cast(), - len627, - len627, - ); - let l628 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V694; - let v694 = match l628 { - 0 => { - let e694 = { - let l629 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l630 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base679 = l629; - let len679 = l630; - let mut result679 = _rt::Vec::with_capacity(len679); - for i in 0..len679 { - let base = base679 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e679 = { - let l631 = i32::from(*base.add(0).cast::()); - let l635 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l639 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V678; - let v678 = match l639 { - 0 => { - let e678 = { - let l640 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l641 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base646 = l640; - let len646 = l641; - let mut result646 = _rt::Vec::with_capacity(len646); - for i in 0..len646 { - let base = base646 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e646 = { - let l642 = *base.add(0).cast::<*mut u8>(); - let l643 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len644 = l643; - let bytes644 = _rt::Vec::from_raw_parts( - l642.cast(), - len644, - len644, - ); - let l645 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes644), l645) - }; - result646.push(e646); - } - _rt::cabi_dealloc( - base646, - len646 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result646 - }; - V678::RecordType(e678) - } - 1 => { - let e678 = { - let l647 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l648 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base654 = l647; - let len654 = l648; - let mut result654 = _rt::Vec::with_capacity(len654); - for i in 0..len654 { - let base = base654 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e654 = { - let l649 = *base.add(0).cast::<*mut u8>(); - let l650 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len651 = l650; - let bytes651 = _rt::Vec::from_raw_parts( - l649.cast(), - len651, - len651, - ); - let l652 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes651), - match l652 { - 0 => None, - 1 => { - let e = { - let l653 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l653 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result654.push(e654); - } - _rt::cabi_dealloc( - base654, - len654 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result654 - }; - V678::VariantType(e678) - } - 2 => { - let e678 = { - let l655 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l656 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base660 = l655; - let len660 = l656; - let mut result660 = _rt::Vec::with_capacity(len660); - for i in 0..len660 { - let base = base660 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e660 = { - let l657 = *base.add(0).cast::<*mut u8>(); - let l658 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len659 = l658; - let bytes659 = _rt::Vec::from_raw_parts( - l657.cast(), - len659, - len659, - ); - _rt::string_lift(bytes659) - }; - result660.push(e660); - } - _rt::cabi_dealloc( - base660, - len660 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result660 - }; - V678::EnumType(e678) - } - 3 => { - let e678 = { - let l661 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l662 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base666 = l661; - let len666 = l662; - let mut result666 = _rt::Vec::with_capacity(len666); - for i in 0..len666 { - let base = base666 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e666 = { - let l663 = *base.add(0).cast::<*mut u8>(); - let l664 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len665 = l664; - let bytes665 = _rt::Vec::from_raw_parts( - l663.cast(), - len665, - len665, - ); - _rt::string_lift(bytes665) - }; - result666.push(e666); - } - _rt::cabi_dealloc( - base666, - len666 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result666 - }; - V678::FlagsType(e678) - } - 4 => { - let e678 = { - let l667 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l668 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len669 = l668; - _rt::Vec::from_raw_parts(l667.cast(), len669, len669) - }; - V678::TupleType(e678) - } - 5 => { - let e678 = { - let l670 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l670 - }; - V678::ListType(e678) - } - 6 => { - let e678 = { - let l671 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l671 - }; - V678::OptionType(e678) - } - 7 => { - let e678 = { - let l672 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l674 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l672 { - 0 => None, - 1 => { - let e = { - let l673 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l673 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l674 { - 0 => None, - 1 => { - let e = { - let l675 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l675 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V678::ResultType(e678) - } - 8 => V678::PrimU8Type, - 9 => V678::PrimU16Type, - 10 => V678::PrimU32Type, - 11 => V678::PrimU64Type, - 12 => V678::PrimS8Type, - 13 => V678::PrimS16Type, - 14 => V678::PrimS32Type, - 15 => V678::PrimS64Type, - 16 => V678::PrimF32Type, - 17 => V678::PrimF64Type, - 18 => V678::PrimCharType, - 19 => V678::PrimBoolType, - 20 => V678::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e678 = { - let l676 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l677 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l676 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l677 as u8, - ), - ) - }; - V678::HandleType(e678) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l631 { - 0 => None, - 1 => { - let e = { - let l632 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l633 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len634 = l633; - let bytes634 = _rt::Vec::from_raw_parts( - l632.cast(), - len634, - len634, - ); - _rt::string_lift(bytes634) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l635 { - 0 => None, - 1 => { - let e = { - let l636 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l637 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len638 = l637; - let bytes638 = _rt::Vec::from_raw_parts( - l636.cast(), - len638, - len638, - ); - _rt::string_lift(bytes638) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v678, - } - }; - result679.push(e679); - } - _rt::cabi_dealloc( - base679, - len679 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result679, - } - }; - V694::ComponentModel(e694) - } - 1 => { - let e694 = { - let l680 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l680 { - 0 => None, - 1 => { - let e = { - let l681 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l682 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base686 = l681; - let len686 = l682; - let mut result686 = _rt::Vec::with_capacity(len686); - for i in 0..len686 { - let base = base686 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e686 = { - let l683 = *base.add(0).cast::<*mut u8>(); - let l684 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len685 = l684; - let bytes685 = _rt::Vec::from_raw_parts( - l683.cast(), - len685, - len685, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes685), - } - }; - result686.push(e686); - } - _rt::cabi_dealloc( - base686, - len686 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result686 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V694::UnstructuredText(e694) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e694 = { - let l687 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l687 { - 0 => None, - 1 => { - let e = { - let l688 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l689 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base693 = l688; - let len693 = l689; - let mut result693 = _rt::Vec::with_capacity(len693); - for i in 0..len693 { - let base = base693 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e693 = { - let l690 = *base.add(0).cast::<*mut u8>(); - let l691 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len692 = l691; - let bytes692 = _rt::Vec::from_raw_parts( - l690.cast(), - len692, - len692, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes692), - } - }; - result693.push(e693); - } - _rt::cabi_dealloc( - base693, - len693 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result693 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V694::UnstructuredBinary(e694) - } - }; - (_rt::string_lift(bytes627), v694) - }; - result695.push(e695); - } - _rt::cabi_dealloc( - base695, - len695 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result695 - }; - V696::Multimodal(e696) - } - }; - let l697 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l698 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len699 = l698; - let bytes699 = _rt::Vec::from_raw_parts( - l697.cast(), - len699, - len699, - ); - let l700 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l701 = *base - .add(40 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base705 = l700; - let len705 = l701; - let mut result705 = _rt::Vec::with_capacity(len705); - for i in 0..len705 { - let base = base705 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e705 = { - let l702 = *base.add(0).cast::<*mut u8>(); - let l703 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len704 = l703; - let bytes704 = _rt::Vec::from_raw_parts( - l702.cast(), - len704, - len704, - ); - _rt::string_lift(bytes704) - }; - result705.push(e705); - } - _rt::cabi_dealloc( - base705, - len705 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l706 = *base - .add(40 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l707 = *base - .add(40 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base739 = l706; - let len739 = l707; - let mut result739 = _rt::Vec::with_capacity(len739); - for i in 0..len739 { - let base = base739 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e739 = { - let l708 = *base.add(0).cast::<*mut u8>(); - let l709 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base738 = l708; - let len738 = l709; - let mut result738 = _rt::Vec::with_capacity(len738); - for i in 0..len738 { - let base = base738 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e738 = { - let l710 = i32::from(*base.add(0).cast::()); - let v737 = match l710 { - 0 => { - let e737 = { - let l711 = *base.add(8).cast::<*mut u8>(); - let l712 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len713 = l712; - let bytes713 = _rt::Vec::from_raw_parts( - l711.cast(), - len713, - len713, - ); - let l714 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l715 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l716 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l720 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l722 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l723 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base732 = l722; - let len732 = l723; - let mut result732 = _rt::Vec::with_capacity(len732); - for i in 0..len732 { - let base = base732 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e732 = { - let l724 = *base.add(0).cast::<*mut u8>(); - let l725 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len726 = l725; - let bytes726 = _rt::Vec::from_raw_parts( - l724.cast(), - len726, - len726, - ); - let l727 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V731; - let v731 = match l727 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e731 = { - let l728 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l729 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len730 = l729; - let bytes730 = _rt::Vec::from_raw_parts( - l728.cast(), - len730, - len730, - ); - _rt::string_lift(bytes730) - }; - V731::String(e731) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes726), - value: v731, - } - }; - result732.push(e732); - } - _rt::cabi_dealloc( - base732, - len732 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l733 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes713), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l714 as u64, - nanoseconds: l715 as u32, - }, - parent: match l716 { - 0 => None, - 1 => { - let e = { - let l717 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l718 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len719 = l718; - let bytes719 = _rt::Vec::from_raw_parts( - l717.cast(), - len719, - len719, - ); - _rt::string_lift(bytes719) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l720 { - 0 => None, - 1 => { - let e = { - let l721 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l721 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result732, - inherited: _rt::bool_lift(l733 as u8), - } - }; - SpanData::LocalSpan(e737) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e737 = { - let l734 = *base.add(8).cast::<*mut u8>(); - let l735 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len736 = l735; - let bytes736 = _rt::Vec::from_raw_parts( - l734.cast(), - len736, - len736, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes736), - } - }; - SpanData::ExternalSpan(e737) - } - }; - v737 - }; - result738.push(e738); - } - _rt::cabi_dealloc( - base738, - len738 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result738 - }; - result739.push(e739); - } - _rt::cabi_dealloc( - base739, - len739 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes391), - constructor_parameters: TypedDataValue { - value: v548, - schema: v696, - }, - trace_id: _rt::string_lift(bytes699), - trace_states: result705, - invocation_context: result739, - } - }; - AgentInvocation::AgentInitialization(e1104) - } - 1 => { - let e1104 = { - let l740 = *base.add(40).cast::<*mut u8>(); - let l741 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len742 = l741; - let bytes742 = _rt::Vec::from_raw_parts( - l740.cast(), - len742, - len742, - ); - let l743 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l744 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len745 = l744; - let bytes745 = _rt::Vec::from_raw_parts( - l743.cast(), - len745, - len745, - ); - let l746 = i32::from( - *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V902; - let v902 = match l746 { - 0 => { - let e902 = { - let l747 = *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l748 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base822 = l747; - let len822 = l748; - let mut result822 = _rt::Vec::with_capacity(len822); - for i in 0..len822 { - let base = base822 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e822 = { - let l749 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V821; - let v821 = match l749 { - 0 => { - let e821 = { - let l750 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l751 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base797 = l750; - let len797 = l751; - let mut result797 = _rt::Vec::with_capacity(len797); - for i in 0..len797 { - let base = base797 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e797 = { - let l752 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V796; - let v796 = match l752 { - 0 => { - let e796 = { - let l753 = *base.add(8).cast::<*mut u8>(); - let l754 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len755 = l754; - _rt::Vec::from_raw_parts(l753.cast(), len755, len755) - }; - V796::RecordValue(e796) - } - 1 => { - let e796 = { - let l756 = *base.add(8).cast::(); - let l757 = i32::from(*base.add(12).cast::()); - ( - l756 as u32, - match l757 { - 0 => None, - 1 => { - let e = { - let l758 = *base.add(16).cast::(); - l758 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V796::VariantValue(e796) - } - 2 => { - let e796 = { - let l759 = *base.add(8).cast::(); - l759 as u32 - }; - V796::EnumValue(e796) - } - 3 => { - let e796 = { - let l760 = *base.add(8).cast::<*mut u8>(); - let l761 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base763 = l760; - let len763 = l761; - let mut result763 = _rt::Vec::with_capacity(len763); - for i in 0..len763 { - let base = base763.add(i * 1); - let e763 = { - let l762 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l762 as u8) - }; - result763.push(e763); - } - _rt::cabi_dealloc(base763, len763 * 1, 1); - result763 - }; - V796::FlagsValue(e796) - } - 4 => { - let e796 = { - let l764 = *base.add(8).cast::<*mut u8>(); - let l765 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len766 = l765; - _rt::Vec::from_raw_parts(l764.cast(), len766, len766) - }; - V796::TupleValue(e796) - } - 5 => { - let e796 = { - let l767 = *base.add(8).cast::<*mut u8>(); - let l768 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len769 = l768; - _rt::Vec::from_raw_parts(l767.cast(), len769, len769) - }; - V796::ListValue(e796) - } - 6 => { - let e796 = { - let l770 = i32::from(*base.add(8).cast::()); - match l770 { - 0 => None, - 1 => { - let e = { - let l771 = *base.add(12).cast::(); - l771 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V796::OptionValue(e796) - } - 7 => { - let e796 = { - let l772 = i32::from(*base.add(8).cast::()); - match l772 { - 0 => { - let e = { - let l773 = i32::from(*base.add(12).cast::()); - match l773 { - 0 => None, - 1 => { - let e = { - let l774 = *base.add(16).cast::(); - l774 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l775 = i32::from(*base.add(12).cast::()); - match l775 { - 0 => None, - 1 => { - let e = { - let l776 = *base.add(16).cast::(); - l776 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V796::ResultValue(e796) - } - 8 => { - let e796 = { - let l777 = i32::from(*base.add(8).cast::()); - l777 as u8 - }; - V796::PrimU8(e796) - } - 9 => { - let e796 = { - let l778 = i32::from(*base.add(8).cast::()); - l778 as u16 - }; - V796::PrimU16(e796) - } - 10 => { - let e796 = { - let l779 = *base.add(8).cast::(); - l779 as u32 - }; - V796::PrimU32(e796) - } - 11 => { - let e796 = { - let l780 = *base.add(8).cast::(); - l780 as u64 - }; - V796::PrimU64(e796) - } - 12 => { - let e796 = { - let l781 = i32::from(*base.add(8).cast::()); - l781 as i8 - }; - V796::PrimS8(e796) - } - 13 => { - let e796 = { - let l782 = i32::from(*base.add(8).cast::()); - l782 as i16 - }; - V796::PrimS16(e796) - } - 14 => { - let e796 = { - let l783 = *base.add(8).cast::(); - l783 - }; - V796::PrimS32(e796) - } - 15 => { - let e796 = { - let l784 = *base.add(8).cast::(); - l784 - }; - V796::PrimS64(e796) - } - 16 => { - let e796 = { - let l785 = *base.add(8).cast::(); - l785 - }; - V796::PrimFloat32(e796) - } - 17 => { - let e796 = { - let l786 = *base.add(8).cast::(); - l786 - }; - V796::PrimFloat64(e796) - } - 18 => { - let e796 = { - let l787 = *base.add(8).cast::(); - _rt::char_lift(l787 as u32) - }; - V796::PrimChar(e796) - } - 19 => { - let e796 = { - let l788 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l788 as u8) - }; - V796::PrimBool(e796) - } - 20 => { - let e796 = { - let l789 = *base.add(8).cast::<*mut u8>(); - let l790 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len791 = l790; - let bytes791 = _rt::Vec::from_raw_parts( - l789.cast(), - len791, - len791, - ); - _rt::string_lift(bytes791) - }; - V796::PrimString(e796) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e796 = { - let l792 = *base.add(8).cast::<*mut u8>(); - let l793 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len794 = l793; - let bytes794 = _rt::Vec::from_raw_parts( - l792.cast(), - len794, - len794, - ); - let l795 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes794), - }, - l795 as u64, - ) - }; - V796::Handle(e796) - } - }; - v796 - }; - result797.push(e797); - } - _rt::cabi_dealloc( - base797, - len797 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result797, - } - }; - V821::ComponentModel(e821) - } - 1 => { - let e821 = { - let l798 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V809; - let v809 = match l798 { - 0 => { - let e809 = { - let l799 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l800 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len801 = l800; - let bytes801 = _rt::Vec::from_raw_parts( - l799.cast(), - len801, - len801, - ); - _rt::string_lift(bytes801) - }; - V809::Url(e809) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e809 = { - let l802 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l803 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len804 = l803; - let bytes804 = _rt::Vec::from_raw_parts( - l802.cast(), - len804, - len804, - ); - let l805 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes804), - text_type: match l805 { - 0 => None, - 1 => { - let e = { - let l806 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l807 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len808 = l807; - let bytes808 = _rt::Vec::from_raw_parts( - l806.cast(), - len808, - len808, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes808), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V809::Inline(e809) - } - }; - v809 - }; - V821::UnstructuredText(e821) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e821 = { - let l810 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V820; - let v820 = match l810 { - 0 => { - let e820 = { - let l811 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l812 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len813 = l812; - let bytes813 = _rt::Vec::from_raw_parts( - l811.cast(), - len813, - len813, - ); - _rt::string_lift(bytes813) - }; - V820::Url(e820) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e820 = { - let l814 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l815 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len816 = l815; - let l817 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l818 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len819 = l818; - let bytes819 = _rt::Vec::from_raw_parts( - l817.cast(), - len819, - len819, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l814.cast(), len816, len816), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes819), - }, - } - }; - V820::Inline(e820) - } - }; - v820 - }; - V821::UnstructuredBinary(e821) - } - }; - v821 - }; - result822.push(e822); - } - _rt::cabi_dealloc( - base822, - len822 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result822 - }; - V902::Tuple(e902) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e902 = { - let l823 = *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l824 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base901 = l823; - let len901 = l824; - let mut result901 = _rt::Vec::with_capacity(len901); - for i in 0..len901 { - let base = base901 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e901 = { - let l825 = *base.add(0).cast::<*mut u8>(); - let l826 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len827 = l826; - let bytes827 = _rt::Vec::from_raw_parts( - l825.cast(), - len827, - len827, - ); - let l828 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V900; - let v900 = match l828 { - 0 => { - let e900 = { - let l829 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l830 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base876 = l829; - let len876 = l830; - let mut result876 = _rt::Vec::with_capacity(len876); - for i in 0..len876 { - let base = base876 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e876 = { - let l831 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V875; - let v875 = match l831 { - 0 => { - let e875 = { - let l832 = *base.add(8).cast::<*mut u8>(); - let l833 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len834 = l833; - _rt::Vec::from_raw_parts(l832.cast(), len834, len834) - }; - V875::RecordValue(e875) - } - 1 => { - let e875 = { - let l835 = *base.add(8).cast::(); - let l836 = i32::from(*base.add(12).cast::()); - ( - l835 as u32, - match l836 { - 0 => None, - 1 => { - let e = { - let l837 = *base.add(16).cast::(); - l837 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V875::VariantValue(e875) - } - 2 => { - let e875 = { - let l838 = *base.add(8).cast::(); - l838 as u32 - }; - V875::EnumValue(e875) - } - 3 => { - let e875 = { - let l839 = *base.add(8).cast::<*mut u8>(); - let l840 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base842 = l839; - let len842 = l840; - let mut result842 = _rt::Vec::with_capacity(len842); - for i in 0..len842 { - let base = base842.add(i * 1); - let e842 = { - let l841 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l841 as u8) - }; - result842.push(e842); - } - _rt::cabi_dealloc(base842, len842 * 1, 1); - result842 - }; - V875::FlagsValue(e875) - } - 4 => { - let e875 = { - let l843 = *base.add(8).cast::<*mut u8>(); - let l844 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len845 = l844; - _rt::Vec::from_raw_parts(l843.cast(), len845, len845) - }; - V875::TupleValue(e875) - } - 5 => { - let e875 = { - let l846 = *base.add(8).cast::<*mut u8>(); - let l847 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len848 = l847; - _rt::Vec::from_raw_parts(l846.cast(), len848, len848) - }; - V875::ListValue(e875) - } - 6 => { - let e875 = { - let l849 = i32::from(*base.add(8).cast::()); - match l849 { - 0 => None, - 1 => { - let e = { - let l850 = *base.add(12).cast::(); - l850 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V875::OptionValue(e875) - } - 7 => { - let e875 = { - let l851 = i32::from(*base.add(8).cast::()); - match l851 { - 0 => { - let e = { - let l852 = i32::from(*base.add(12).cast::()); - match l852 { - 0 => None, - 1 => { - let e = { - let l853 = *base.add(16).cast::(); - l853 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l854 = i32::from(*base.add(12).cast::()); - match l854 { - 0 => None, - 1 => { - let e = { - let l855 = *base.add(16).cast::(); - l855 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V875::ResultValue(e875) - } - 8 => { - let e875 = { - let l856 = i32::from(*base.add(8).cast::()); - l856 as u8 - }; - V875::PrimU8(e875) - } - 9 => { - let e875 = { - let l857 = i32::from(*base.add(8).cast::()); - l857 as u16 - }; - V875::PrimU16(e875) - } - 10 => { - let e875 = { - let l858 = *base.add(8).cast::(); - l858 as u32 - }; - V875::PrimU32(e875) - } - 11 => { - let e875 = { - let l859 = *base.add(8).cast::(); - l859 as u64 - }; - V875::PrimU64(e875) - } - 12 => { - let e875 = { - let l860 = i32::from(*base.add(8).cast::()); - l860 as i8 - }; - V875::PrimS8(e875) - } - 13 => { - let e875 = { - let l861 = i32::from(*base.add(8).cast::()); - l861 as i16 - }; - V875::PrimS16(e875) - } - 14 => { - let e875 = { - let l862 = *base.add(8).cast::(); - l862 - }; - V875::PrimS32(e875) - } - 15 => { - let e875 = { - let l863 = *base.add(8).cast::(); - l863 - }; - V875::PrimS64(e875) - } - 16 => { - let e875 = { - let l864 = *base.add(8).cast::(); - l864 - }; - V875::PrimFloat32(e875) - } - 17 => { - let e875 = { - let l865 = *base.add(8).cast::(); - l865 - }; - V875::PrimFloat64(e875) - } - 18 => { - let e875 = { - let l866 = *base.add(8).cast::(); - _rt::char_lift(l866 as u32) - }; - V875::PrimChar(e875) - } - 19 => { - let e875 = { - let l867 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l867 as u8) - }; - V875::PrimBool(e875) - } - 20 => { - let e875 = { - let l868 = *base.add(8).cast::<*mut u8>(); - let l869 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len870 = l869; - let bytes870 = _rt::Vec::from_raw_parts( - l868.cast(), - len870, - len870, - ); - _rt::string_lift(bytes870) - }; - V875::PrimString(e875) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e875 = { - let l871 = *base.add(8).cast::<*mut u8>(); - let l872 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len873 = l872; - let bytes873 = _rt::Vec::from_raw_parts( - l871.cast(), - len873, - len873, - ); - let l874 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes873), - }, - l874 as u64, - ) - }; - V875::Handle(e875) - } - }; - v875 - }; - result876.push(e876); - } - _rt::cabi_dealloc( - base876, - len876 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result876, - } - }; - V900::ComponentModel(e900) - } - 1 => { - let e900 = { - let l877 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V888; - let v888 = match l877 { - 0 => { - let e888 = { - let l878 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l879 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len880 = l879; - let bytes880 = _rt::Vec::from_raw_parts( - l878.cast(), - len880, - len880, - ); - _rt::string_lift(bytes880) - }; - V888::Url(e888) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e888 = { - let l881 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l882 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len883 = l882; - let bytes883 = _rt::Vec::from_raw_parts( - l881.cast(), - len883, - len883, - ); - let l884 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes883), - text_type: match l884 { - 0 => None, - 1 => { - let e = { - let l885 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l886 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len887 = l886; - let bytes887 = _rt::Vec::from_raw_parts( - l885.cast(), - len887, - len887, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes887), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V888::Inline(e888) - } - }; - v888 - }; - V900::UnstructuredText(e900) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e900 = { - let l889 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V899; - let v899 = match l889 { - 0 => { - let e899 = { - let l890 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l891 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len892 = l891; - let bytes892 = _rt::Vec::from_raw_parts( - l890.cast(), - len892, - len892, - ); - _rt::string_lift(bytes892) - }; - V899::Url(e899) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e899 = { - let l893 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l894 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len895 = l894; - let l896 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l897 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len898 = l897; - let bytes898 = _rt::Vec::from_raw_parts( - l896.cast(), - len898, - len898, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts(l893.cast(), len895, len895), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes898), - }, - } - }; - V899::Inline(e899) - } - }; - v899 - }; - V900::UnstructuredBinary(e900) - } - }; - (_rt::string_lift(bytes827), v900) - }; - result901.push(e901); - } - _rt::cabi_dealloc( - base901, - len901 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result901 - }; - V902::Multimodal(e902) - } - }; - let l903 = i32::from( - *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1050; - let v1050 = match l903 { - 0 => { - let e1050 = { - let l904 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l905 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base976 = l904; - let len976 = l905; - let mut result976 = _rt::Vec::with_capacity(len976); - for i in 0..len976 { - let base = base976 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e976 = { - let l906 = *base.add(0).cast::<*mut u8>(); - let l907 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len908 = l907; - let bytes908 = _rt::Vec::from_raw_parts( - l906.cast(), - len908, - len908, - ); - let l909 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V975; - let v975 = match l909 { - 0 => { - let e975 = { - let l910 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l911 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base960 = l910; - let len960 = l911; - let mut result960 = _rt::Vec::with_capacity(len960); - for i in 0..len960 { - let base = base960 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e960 = { - let l912 = i32::from(*base.add(0).cast::()); - let l916 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l920 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V959; - let v959 = match l920 { - 0 => { - let e959 = { - let l921 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l922 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base927 = l921; - let len927 = l922; - let mut result927 = _rt::Vec::with_capacity(len927); - for i in 0..len927 { - let base = base927 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e927 = { - let l923 = *base.add(0).cast::<*mut u8>(); - let l924 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len925 = l924; - let bytes925 = _rt::Vec::from_raw_parts( - l923.cast(), - len925, - len925, - ); - let l926 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes925), l926) - }; - result927.push(e927); - } - _rt::cabi_dealloc( - base927, - len927 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result927 - }; - V959::RecordType(e959) - } - 1 => { - let e959 = { - let l928 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l929 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base935 = l928; - let len935 = l929; - let mut result935 = _rt::Vec::with_capacity(len935); - for i in 0..len935 { - let base = base935 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e935 = { - let l930 = *base.add(0).cast::<*mut u8>(); - let l931 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len932 = l931; - let bytes932 = _rt::Vec::from_raw_parts( - l930.cast(), - len932, - len932, - ); - let l933 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes932), - match l933 { - 0 => None, - 1 => { - let e = { - let l934 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l934 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result935.push(e935); - } - _rt::cabi_dealloc( - base935, - len935 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result935 - }; - V959::VariantType(e959) - } - 2 => { - let e959 = { - let l936 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l937 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base941 = l936; - let len941 = l937; - let mut result941 = _rt::Vec::with_capacity(len941); - for i in 0..len941 { - let base = base941 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e941 = { - let l938 = *base.add(0).cast::<*mut u8>(); - let l939 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len940 = l939; - let bytes940 = _rt::Vec::from_raw_parts( - l938.cast(), - len940, - len940, - ); - _rt::string_lift(bytes940) - }; - result941.push(e941); - } - _rt::cabi_dealloc( - base941, - len941 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result941 - }; - V959::EnumType(e959) - } - 3 => { - let e959 = { - let l942 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l943 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base947 = l942; - let len947 = l943; - let mut result947 = _rt::Vec::with_capacity(len947); - for i in 0..len947 { - let base = base947 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e947 = { - let l944 = *base.add(0).cast::<*mut u8>(); - let l945 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len946 = l945; - let bytes946 = _rt::Vec::from_raw_parts( - l944.cast(), - len946, - len946, - ); - _rt::string_lift(bytes946) - }; - result947.push(e947); - } - _rt::cabi_dealloc( - base947, - len947 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result947 - }; - V959::FlagsType(e959) - } - 4 => { - let e959 = { - let l948 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l949 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len950 = l949; - _rt::Vec::from_raw_parts(l948.cast(), len950, len950) - }; - V959::TupleType(e959) - } - 5 => { - let e959 = { - let l951 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l951 - }; - V959::ListType(e959) - } - 6 => { - let e959 = { - let l952 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l952 - }; - V959::OptionType(e959) - } - 7 => { - let e959 = { - let l953 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l955 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l953 { - 0 => None, - 1 => { - let e = { - let l954 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l954 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l955 { - 0 => None, - 1 => { - let e = { - let l956 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l956 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V959::ResultType(e959) - } - 8 => V959::PrimU8Type, - 9 => V959::PrimU16Type, - 10 => V959::PrimU32Type, - 11 => V959::PrimU64Type, - 12 => V959::PrimS8Type, - 13 => V959::PrimS16Type, - 14 => V959::PrimS32Type, - 15 => V959::PrimS64Type, - 16 => V959::PrimF32Type, - 17 => V959::PrimF64Type, - 18 => V959::PrimCharType, - 19 => V959::PrimBoolType, - 20 => V959::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e959 = { - let l957 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l958 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l957 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l958 as u8, - ), - ) - }; - V959::HandleType(e959) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l912 { - 0 => None, - 1 => { - let e = { - let l913 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l914 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len915 = l914; - let bytes915 = _rt::Vec::from_raw_parts( - l913.cast(), - len915, - len915, - ); - _rt::string_lift(bytes915) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l916 { - 0 => None, - 1 => { - let e = { - let l917 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l918 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len919 = l918; - let bytes919 = _rt::Vec::from_raw_parts( - l917.cast(), - len919, - len919, - ); - _rt::string_lift(bytes919) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v959, - } - }; - result960.push(e960); - } - _rt::cabi_dealloc( - base960, - len960 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result960, - } - }; - V975::ComponentModel(e975) - } - 1 => { - let e975 = { - let l961 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l961 { - 0 => None, - 1 => { - let e = { - let l962 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l963 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base967 = l962; - let len967 = l963; - let mut result967 = _rt::Vec::with_capacity(len967); - for i in 0..len967 { - let base = base967 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e967 = { - let l964 = *base.add(0).cast::<*mut u8>(); - let l965 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len966 = l965; - let bytes966 = _rt::Vec::from_raw_parts( - l964.cast(), - len966, - len966, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes966), - } - }; - result967.push(e967); - } - _rt::cabi_dealloc( - base967, - len967 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result967 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V975::UnstructuredText(e975) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e975 = { - let l968 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l968 { - 0 => None, - 1 => { - let e = { - let l969 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l970 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base974 = l969; - let len974 = l970; - let mut result974 = _rt::Vec::with_capacity(len974); - for i in 0..len974 { - let base = base974 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e974 = { - let l971 = *base.add(0).cast::<*mut u8>(); - let l972 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len973 = l972; - let bytes973 = _rt::Vec::from_raw_parts( - l971.cast(), - len973, - len973, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes973), - } - }; - result974.push(e974); - } - _rt::cabi_dealloc( - base974, - len974 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result974 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V975::UnstructuredBinary(e975) - } - }; - (_rt::string_lift(bytes908), v975) - }; - result976.push(e976); - } - _rt::cabi_dealloc( - base976, - len976 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result976 - }; - V1050::Tuple(e1050) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1050 = { - let l977 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l978 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1049 = l977; - let len1049 = l978; - let mut result1049 = _rt::Vec::with_capacity(len1049); - for i in 0..len1049 { - let base = base1049 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1049 = { - let l979 = *base.add(0).cast::<*mut u8>(); - let l980 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len981 = l980; - let bytes981 = _rt::Vec::from_raw_parts( - l979.cast(), - len981, - len981, - ); - let l982 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1048; - let v1048 = match l982 { - 0 => { - let e1048 = { - let l983 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l984 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1033 = l983; - let len1033 = l984; - let mut result1033 = _rt::Vec::with_capacity(len1033); - for i in 0..len1033 { - let base = base1033 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1033 = { - let l985 = i32::from(*base.add(0).cast::()); - let l989 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l993 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1032; - let v1032 = match l993 { - 0 => { - let e1032 = { - let l994 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l995 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1000 = l994; - let len1000 = l995; - let mut result1000 = _rt::Vec::with_capacity(len1000); - for i in 0..len1000 { - let base = base1000 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1000 = { - let l996 = *base.add(0).cast::<*mut u8>(); - let l997 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len998 = l997; - let bytes998 = _rt::Vec::from_raw_parts( - l996.cast(), - len998, - len998, - ); - let l999 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes998), l999) - }; - result1000.push(e1000); - } - _rt::cabi_dealloc( - base1000, - len1000 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1000 - }; - V1032::RecordType(e1032) - } - 1 => { - let e1032 = { - let l1001 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1002 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1008 = l1001; - let len1008 = l1002; - let mut result1008 = _rt::Vec::with_capacity(len1008); - for i in 0..len1008 { - let base = base1008 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1008 = { - let l1003 = *base.add(0).cast::<*mut u8>(); - let l1004 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1005 = l1004; - let bytes1005 = _rt::Vec::from_raw_parts( - l1003.cast(), - len1005, - len1005, - ); - let l1006 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1005), - match l1006 { - 0 => None, - 1 => { - let e = { - let l1007 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1007 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1008.push(e1008); - } - _rt::cabi_dealloc( - base1008, - len1008 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1008 - }; - V1032::VariantType(e1032) - } - 2 => { - let e1032 = { - let l1009 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1010 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1014 = l1009; - let len1014 = l1010; - let mut result1014 = _rt::Vec::with_capacity(len1014); - for i in 0..len1014 { - let base = base1014 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1014 = { - let l1011 = *base.add(0).cast::<*mut u8>(); - let l1012 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1013 = l1012; - let bytes1013 = _rt::Vec::from_raw_parts( - l1011.cast(), - len1013, - len1013, - ); - _rt::string_lift(bytes1013) - }; - result1014.push(e1014); - } - _rt::cabi_dealloc( - base1014, - len1014 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1014 - }; - V1032::EnumType(e1032) - } - 3 => { - let e1032 = { - let l1015 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1016 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1020 = l1015; - let len1020 = l1016; - let mut result1020 = _rt::Vec::with_capacity(len1020); - for i in 0..len1020 { - let base = base1020 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1020 = { - let l1017 = *base.add(0).cast::<*mut u8>(); - let l1018 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1019 = l1018; - let bytes1019 = _rt::Vec::from_raw_parts( - l1017.cast(), - len1019, - len1019, - ); - _rt::string_lift(bytes1019) - }; - result1020.push(e1020); - } - _rt::cabi_dealloc( - base1020, - len1020 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1020 - }; - V1032::FlagsType(e1032) - } - 4 => { - let e1032 = { - let l1021 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1022 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1023 = l1022; - _rt::Vec::from_raw_parts(l1021.cast(), len1023, len1023) - }; - V1032::TupleType(e1032) - } - 5 => { - let e1032 = { - let l1024 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1024 - }; - V1032::ListType(e1032) - } - 6 => { - let e1032 = { - let l1025 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1025 - }; - V1032::OptionType(e1032) - } - 7 => { - let e1032 = { - let l1026 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1028 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1026 { - 0 => None, - 1 => { - let e = { - let l1027 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1027 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1028 { - 0 => None, - 1 => { - let e = { - let l1029 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1029 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1032::ResultType(e1032) - } - 8 => V1032::PrimU8Type, - 9 => V1032::PrimU16Type, - 10 => V1032::PrimU32Type, - 11 => V1032::PrimU64Type, - 12 => V1032::PrimS8Type, - 13 => V1032::PrimS16Type, - 14 => V1032::PrimS32Type, - 15 => V1032::PrimS64Type, - 16 => V1032::PrimF32Type, - 17 => V1032::PrimF64Type, - 18 => V1032::PrimCharType, - 19 => V1032::PrimBoolType, - 20 => V1032::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1032 = { - let l1030 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1031 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1030 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1031 as u8, - ), - ) - }; - V1032::HandleType(e1032) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l985 { - 0 => None, - 1 => { - let e = { - let l986 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l987 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len988 = l987; - let bytes988 = _rt::Vec::from_raw_parts( - l986.cast(), - len988, - len988, - ); - _rt::string_lift(bytes988) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l989 { - 0 => None, - 1 => { - let e = { - let l990 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l991 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len992 = l991; - let bytes992 = _rt::Vec::from_raw_parts( - l990.cast(), - len992, - len992, - ); - _rt::string_lift(bytes992) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1032, - } - }; - result1033.push(e1033); - } - _rt::cabi_dealloc( - base1033, - len1033 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1033, - } - }; - V1048::ComponentModel(e1048) - } - 1 => { - let e1048 = { - let l1034 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1034 { - 0 => None, - 1 => { - let e = { - let l1035 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1036 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1040 = l1035; - let len1040 = l1036; - let mut result1040 = _rt::Vec::with_capacity(len1040); - for i in 0..len1040 { - let base = base1040 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1040 = { - let l1037 = *base.add(0).cast::<*mut u8>(); - let l1038 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1039 = l1038; - let bytes1039 = _rt::Vec::from_raw_parts( - l1037.cast(), - len1039, - len1039, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1039), - } - }; - result1040.push(e1040); - } - _rt::cabi_dealloc( - base1040, - len1040 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1040 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1048::UnstructuredText(e1048) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1048 = { - let l1041 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1041 { - 0 => None, - 1 => { - let e = { - let l1042 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1043 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1047 = l1042; - let len1047 = l1043; - let mut result1047 = _rt::Vec::with_capacity(len1047); - for i in 0..len1047 { - let base = base1047 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1047 = { - let l1044 = *base.add(0).cast::<*mut u8>(); - let l1045 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1046 = l1045; - let bytes1046 = _rt::Vec::from_raw_parts( - l1044.cast(), - len1046, - len1046, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1046), - } - }; - result1047.push(e1047); - } - _rt::cabi_dealloc( - base1047, - len1047 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1047 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1048::UnstructuredBinary(e1048) - } - }; - (_rt::string_lift(bytes981), v1048) - }; - result1049.push(e1049); - } - _rt::cabi_dealloc( - base1049, - len1049 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1049 - }; - V1050::Multimodal(e1050) - } - }; - let l1051 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1052 = *base - .add(40 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1053 = l1052; - let bytes1053 = _rt::Vec::from_raw_parts( - l1051.cast(), - len1053, - len1053, - ); - let l1054 = *base - .add(40 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1055 = *base - .add(40 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1059 = l1054; - let len1059 = l1055; - let mut result1059 = _rt::Vec::with_capacity(len1059); - for i in 0..len1059 { - let base = base1059 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1059 = { - let l1056 = *base.add(0).cast::<*mut u8>(); - let l1057 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1058 = l1057; - let bytes1058 = _rt::Vec::from_raw_parts( - l1056.cast(), - len1058, - len1058, - ); - _rt::string_lift(bytes1058) - }; - result1059.push(e1059); - } - _rt::cabi_dealloc( - base1059, - len1059 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1060 = *base - .add(40 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1061 = *base - .add(40 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1093 = l1060; - let len1093 = l1061; - let mut result1093 = _rt::Vec::with_capacity(len1093); - for i in 0..len1093 { - let base = base1093 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1093 = { - let l1062 = *base.add(0).cast::<*mut u8>(); - let l1063 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base1092 = l1062; - let len1092 = l1063; - let mut result1092 = _rt::Vec::with_capacity(len1092); - for i in 0..len1092 { - let base = base1092 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e1092 = { - let l1064 = i32::from(*base.add(0).cast::()); - let v1091 = match l1064 { - 0 => { - let e1091 = { - let l1065 = *base.add(8).cast::<*mut u8>(); - let l1066 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1067 = l1066; - let bytes1067 = _rt::Vec::from_raw_parts( - l1065.cast(), - len1067, - len1067, - ); - let l1068 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1069 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1070 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1074 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1076 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1077 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1086 = l1076; - let len1086 = l1077; - let mut result1086 = _rt::Vec::with_capacity(len1086); - for i in 0..len1086 { - let base = base1086 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e1086 = { - let l1078 = *base.add(0).cast::<*mut u8>(); - let l1079 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1080 = l1079; - let bytes1080 = _rt::Vec::from_raw_parts( - l1078.cast(), - len1080, - len1080, - ); - let l1081 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V1085; - let v1085 = match l1081 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e1085 = { - let l1082 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1083 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1084 = l1083; - let bytes1084 = _rt::Vec::from_raw_parts( - l1082.cast(), - len1084, - len1084, - ); - _rt::string_lift(bytes1084) - }; - V1085::String(e1085) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes1080), - value: v1085, - } - }; - result1086.push(e1086); - } - _rt::cabi_dealloc( - base1086, - len1086 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l1087 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes1067), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1068 as u64, - nanoseconds: l1069 as u32, - }, - parent: match l1070 { - 0 => None, - 1 => { - let e = { - let l1071 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1072 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1073 = l1072; - let bytes1073 = _rt::Vec::from_raw_parts( - l1071.cast(), - len1073, - len1073, - ); - _rt::string_lift(bytes1073) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l1074 { - 0 => None, - 1 => { - let e = { - let l1075 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1075 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result1086, - inherited: _rt::bool_lift(l1087 as u8), - } - }; - SpanData::LocalSpan(e1091) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1091 = { - let l1088 = *base.add(8).cast::<*mut u8>(); - let l1089 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1090 = l1089; - let bytes1090 = _rt::Vec::from_raw_parts( - l1088.cast(), - len1090, - len1090, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes1090), - } - }; - SpanData::ExternalSpan(e1091) - } - }; - v1091 - }; - result1092.push(e1092); - } - _rt::cabi_dealloc( - base1092, - len1092 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result1092 - }; - result1093.push(e1093); - } - _rt::cabi_dealloc( - base1093, - len1093 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes742), - method_name: _rt::string_lift(bytes745), - function_input: TypedDataValue { - value: v902, - schema: v1050, - }, - trace_id: _rt::string_lift(bytes1053), - trace_states: result1059, - invocation_context: result1093, - } - }; - AgentInvocation::AgentMethodInvocation(e1104) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e1104 = { - let l1094 = *base.add(40).cast::<*mut u8>(); - let l1095 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1096 = l1095; - let l1097 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1098 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1099 = l1098; - let bytes1099 = _rt::Vec::from_raw_parts( - l1097.cast(), - len1099, - len1099, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1094.cast(), - len1096, - len1096, - ), - mime_type: _rt::string_lift(bytes1099), - }, - } - }; - AgentInvocation::LoadSnapshot(e1104) - } - 4 => { - let e1104 = { - let l1100 = *base.add(40).cast::<*mut u8>(); - let l1101 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1102 = l1101; - let bytes1102 = _rt::Vec::from_raw_parts( - l1100.cast(), - len1102, - len1102, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes1102), - } - }; - AgentInvocation::ProcessOplogEntries(e1104) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1104 = { - let l1103 = *base.add(40).cast::(); - ManualUpdateParameters { - target_revision: l1103 as u64, - } - }; - AgentInvocation::ManualUpdate(e1104) - } - }; - AgentInvocationStartedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l386 as u64, - nanoseconds: l387 as u32, - }, - invocation: v1104, - } - }; - PublicOplogEntry::AgentInvocationStarted(e2676) - } - 3 => { - let e2676 = { - let l1105 = *base.add(16).cast::(); - let l1106 = *base.add(24).cast::(); - let l1107 = i32::from(*base.add(32).cast::()); - let v1732 = match l1107 { - 0 => { - let e1732 = { - let l1108 = i32::from( - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1264; - let v1264 = match l1108 { - 0 => { - let e1264 = { - let l1109 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1110 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1184 = l1109; - let len1184 = l1110; - let mut result1184 = _rt::Vec::with_capacity(len1184); - for i in 0..len1184 { - let base = base1184 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1184 = { - let l1111 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1183; - let v1183 = match l1111 { - 0 => { - let e1183 = { - let l1112 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1113 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1159 = l1112; - let len1159 = l1113; - let mut result1159 = _rt::Vec::with_capacity(len1159); - for i in 0..len1159 { - let base = base1159 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1159 = { - let l1114 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1158; - let v1158 = match l1114 { - 0 => { - let e1158 = { - let l1115 = *base.add(8).cast::<*mut u8>(); - let l1116 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1117 = l1116; - _rt::Vec::from_raw_parts(l1115.cast(), len1117, len1117) - }; - V1158::RecordValue(e1158) - } - 1 => { - let e1158 = { - let l1118 = *base.add(8).cast::(); - let l1119 = i32::from(*base.add(12).cast::()); - ( - l1118 as u32, - match l1119 { - 0 => None, - 1 => { - let e = { - let l1120 = *base.add(16).cast::(); - l1120 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1158::VariantValue(e1158) - } - 2 => { - let e1158 = { - let l1121 = *base.add(8).cast::(); - l1121 as u32 - }; - V1158::EnumValue(e1158) - } - 3 => { - let e1158 = { - let l1122 = *base.add(8).cast::<*mut u8>(); - let l1123 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1125 = l1122; - let len1125 = l1123; - let mut result1125 = _rt::Vec::with_capacity(len1125); - for i in 0..len1125 { - let base = base1125.add(i * 1); - let e1125 = { - let l1124 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1124 as u8) - }; - result1125.push(e1125); - } - _rt::cabi_dealloc(base1125, len1125 * 1, 1); - result1125 - }; - V1158::FlagsValue(e1158) - } - 4 => { - let e1158 = { - let l1126 = *base.add(8).cast::<*mut u8>(); - let l1127 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1128 = l1127; - _rt::Vec::from_raw_parts(l1126.cast(), len1128, len1128) - }; - V1158::TupleValue(e1158) - } - 5 => { - let e1158 = { - let l1129 = *base.add(8).cast::<*mut u8>(); - let l1130 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1131 = l1130; - _rt::Vec::from_raw_parts(l1129.cast(), len1131, len1131) - }; - V1158::ListValue(e1158) - } - 6 => { - let e1158 = { - let l1132 = i32::from(*base.add(8).cast::()); - match l1132 { - 0 => None, - 1 => { - let e = { - let l1133 = *base.add(12).cast::(); - l1133 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1158::OptionValue(e1158) - } - 7 => { - let e1158 = { - let l1134 = i32::from(*base.add(8).cast::()); - match l1134 { - 0 => { - let e = { - let l1135 = i32::from(*base.add(12).cast::()); - match l1135 { - 0 => None, - 1 => { - let e = { - let l1136 = *base.add(16).cast::(); - l1136 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1137 = i32::from(*base.add(12).cast::()); - match l1137 { - 0 => None, - 1 => { - let e = { - let l1138 = *base.add(16).cast::(); - l1138 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1158::ResultValue(e1158) - } - 8 => { - let e1158 = { - let l1139 = i32::from(*base.add(8).cast::()); - l1139 as u8 - }; - V1158::PrimU8(e1158) - } - 9 => { - let e1158 = { - let l1140 = i32::from(*base.add(8).cast::()); - l1140 as u16 - }; - V1158::PrimU16(e1158) - } - 10 => { - let e1158 = { - let l1141 = *base.add(8).cast::(); - l1141 as u32 - }; - V1158::PrimU32(e1158) - } - 11 => { - let e1158 = { - let l1142 = *base.add(8).cast::(); - l1142 as u64 - }; - V1158::PrimU64(e1158) - } - 12 => { - let e1158 = { - let l1143 = i32::from(*base.add(8).cast::()); - l1143 as i8 - }; - V1158::PrimS8(e1158) - } - 13 => { - let e1158 = { - let l1144 = i32::from(*base.add(8).cast::()); - l1144 as i16 - }; - V1158::PrimS16(e1158) - } - 14 => { - let e1158 = { - let l1145 = *base.add(8).cast::(); - l1145 - }; - V1158::PrimS32(e1158) - } - 15 => { - let e1158 = { - let l1146 = *base.add(8).cast::(); - l1146 - }; - V1158::PrimS64(e1158) - } - 16 => { - let e1158 = { - let l1147 = *base.add(8).cast::(); - l1147 - }; - V1158::PrimFloat32(e1158) - } - 17 => { - let e1158 = { - let l1148 = *base.add(8).cast::(); - l1148 - }; - V1158::PrimFloat64(e1158) - } - 18 => { - let e1158 = { - let l1149 = *base.add(8).cast::(); - _rt::char_lift(l1149 as u32) - }; - V1158::PrimChar(e1158) - } - 19 => { - let e1158 = { - let l1150 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1150 as u8) - }; - V1158::PrimBool(e1158) - } - 20 => { - let e1158 = { - let l1151 = *base.add(8).cast::<*mut u8>(); - let l1152 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1153 = l1152; - let bytes1153 = _rt::Vec::from_raw_parts( - l1151.cast(), - len1153, - len1153, - ); - _rt::string_lift(bytes1153) - }; - V1158::PrimString(e1158) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1158 = { - let l1154 = *base.add(8).cast::<*mut u8>(); - let l1155 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1156 = l1155; - let bytes1156 = _rt::Vec::from_raw_parts( - l1154.cast(), - len1156, - len1156, - ); - let l1157 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1156), - }, - l1157 as u64, - ) - }; - V1158::Handle(e1158) - } - }; - v1158 - }; - result1159.push(e1159); - } - _rt::cabi_dealloc( - base1159, - len1159 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1159, - } - }; - V1183::ComponentModel(e1183) - } - 1 => { - let e1183 = { - let l1160 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1171; - let v1171 = match l1160 { - 0 => { - let e1171 = { - let l1161 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1162 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1163 = l1162; - let bytes1163 = _rt::Vec::from_raw_parts( - l1161.cast(), - len1163, - len1163, - ); - _rt::string_lift(bytes1163) - }; - V1171::Url(e1171) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1171 = { - let l1164 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1165 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1166 = l1165; - let bytes1166 = _rt::Vec::from_raw_parts( - l1164.cast(), - len1166, - len1166, - ); - let l1167 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1166), - text_type: match l1167 { - 0 => None, - 1 => { - let e = { - let l1168 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1169 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1170 = l1169; - let bytes1170 = _rt::Vec::from_raw_parts( - l1168.cast(), - len1170, - len1170, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1170), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1171::Inline(e1171) - } - }; - v1171 - }; - V1183::UnstructuredText(e1183) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1183 = { - let l1172 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1182; - let v1182 = match l1172 { - 0 => { - let e1182 = { - let l1173 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1174 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1175 = l1174; - let bytes1175 = _rt::Vec::from_raw_parts( - l1173.cast(), - len1175, - len1175, - ); - _rt::string_lift(bytes1175) - }; - V1182::Url(e1182) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1182 = { - let l1176 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1177 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1178 = l1177; - let l1179 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1180 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1181 = l1180; - let bytes1181 = _rt::Vec::from_raw_parts( - l1179.cast(), - len1181, - len1181, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1176.cast(), - len1178, - len1178, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1181), - }, - } - }; - V1182::Inline(e1182) - } - }; - v1182 - }; - V1183::UnstructuredBinary(e1183) - } - }; - v1183 - }; - result1184.push(e1184); - } - _rt::cabi_dealloc( - base1184, - len1184 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1184 - }; - V1264::Tuple(e1264) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1264 = { - let l1185 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1186 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1263 = l1185; - let len1263 = l1186; - let mut result1263 = _rt::Vec::with_capacity(len1263); - for i in 0..len1263 { - let base = base1263 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1263 = { - let l1187 = *base.add(0).cast::<*mut u8>(); - let l1188 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1189 = l1188; - let bytes1189 = _rt::Vec::from_raw_parts( - l1187.cast(), - len1189, - len1189, - ); - let l1190 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1262; - let v1262 = match l1190 { - 0 => { - let e1262 = { - let l1191 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1192 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1238 = l1191; - let len1238 = l1192; - let mut result1238 = _rt::Vec::with_capacity(len1238); - for i in 0..len1238 { - let base = base1238 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1238 = { - let l1193 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1237; - let v1237 = match l1193 { - 0 => { - let e1237 = { - let l1194 = *base.add(8).cast::<*mut u8>(); - let l1195 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1196 = l1195; - _rt::Vec::from_raw_parts(l1194.cast(), len1196, len1196) - }; - V1237::RecordValue(e1237) - } - 1 => { - let e1237 = { - let l1197 = *base.add(8).cast::(); - let l1198 = i32::from(*base.add(12).cast::()); - ( - l1197 as u32, - match l1198 { - 0 => None, - 1 => { - let e = { - let l1199 = *base.add(16).cast::(); - l1199 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1237::VariantValue(e1237) - } - 2 => { - let e1237 = { - let l1200 = *base.add(8).cast::(); - l1200 as u32 - }; - V1237::EnumValue(e1237) - } - 3 => { - let e1237 = { - let l1201 = *base.add(8).cast::<*mut u8>(); - let l1202 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1204 = l1201; - let len1204 = l1202; - let mut result1204 = _rt::Vec::with_capacity(len1204); - for i in 0..len1204 { - let base = base1204.add(i * 1); - let e1204 = { - let l1203 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1203 as u8) - }; - result1204.push(e1204); - } - _rt::cabi_dealloc(base1204, len1204 * 1, 1); - result1204 - }; - V1237::FlagsValue(e1237) - } - 4 => { - let e1237 = { - let l1205 = *base.add(8).cast::<*mut u8>(); - let l1206 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1207 = l1206; - _rt::Vec::from_raw_parts(l1205.cast(), len1207, len1207) - }; - V1237::TupleValue(e1237) - } - 5 => { - let e1237 = { - let l1208 = *base.add(8).cast::<*mut u8>(); - let l1209 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1210 = l1209; - _rt::Vec::from_raw_parts(l1208.cast(), len1210, len1210) - }; - V1237::ListValue(e1237) - } - 6 => { - let e1237 = { - let l1211 = i32::from(*base.add(8).cast::()); - match l1211 { - 0 => None, - 1 => { - let e = { - let l1212 = *base.add(12).cast::(); - l1212 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1237::OptionValue(e1237) - } - 7 => { - let e1237 = { - let l1213 = i32::from(*base.add(8).cast::()); - match l1213 { - 0 => { - let e = { - let l1214 = i32::from(*base.add(12).cast::()); - match l1214 { - 0 => None, - 1 => { - let e = { - let l1215 = *base.add(16).cast::(); - l1215 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1216 = i32::from(*base.add(12).cast::()); - match l1216 { - 0 => None, - 1 => { - let e = { - let l1217 = *base.add(16).cast::(); - l1217 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1237::ResultValue(e1237) - } - 8 => { - let e1237 = { - let l1218 = i32::from(*base.add(8).cast::()); - l1218 as u8 - }; - V1237::PrimU8(e1237) - } - 9 => { - let e1237 = { - let l1219 = i32::from(*base.add(8).cast::()); - l1219 as u16 - }; - V1237::PrimU16(e1237) - } - 10 => { - let e1237 = { - let l1220 = *base.add(8).cast::(); - l1220 as u32 - }; - V1237::PrimU32(e1237) - } - 11 => { - let e1237 = { - let l1221 = *base.add(8).cast::(); - l1221 as u64 - }; - V1237::PrimU64(e1237) - } - 12 => { - let e1237 = { - let l1222 = i32::from(*base.add(8).cast::()); - l1222 as i8 - }; - V1237::PrimS8(e1237) - } - 13 => { - let e1237 = { - let l1223 = i32::from(*base.add(8).cast::()); - l1223 as i16 - }; - V1237::PrimS16(e1237) - } - 14 => { - let e1237 = { - let l1224 = *base.add(8).cast::(); - l1224 - }; - V1237::PrimS32(e1237) - } - 15 => { - let e1237 = { - let l1225 = *base.add(8).cast::(); - l1225 - }; - V1237::PrimS64(e1237) - } - 16 => { - let e1237 = { - let l1226 = *base.add(8).cast::(); - l1226 - }; - V1237::PrimFloat32(e1237) - } - 17 => { - let e1237 = { - let l1227 = *base.add(8).cast::(); - l1227 - }; - V1237::PrimFloat64(e1237) - } - 18 => { - let e1237 = { - let l1228 = *base.add(8).cast::(); - _rt::char_lift(l1228 as u32) - }; - V1237::PrimChar(e1237) - } - 19 => { - let e1237 = { - let l1229 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1229 as u8) - }; - V1237::PrimBool(e1237) - } - 20 => { - let e1237 = { - let l1230 = *base.add(8).cast::<*mut u8>(); - let l1231 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1232 = l1231; - let bytes1232 = _rt::Vec::from_raw_parts( - l1230.cast(), - len1232, - len1232, - ); - _rt::string_lift(bytes1232) - }; - V1237::PrimString(e1237) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1237 = { - let l1233 = *base.add(8).cast::<*mut u8>(); - let l1234 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1235 = l1234; - let bytes1235 = _rt::Vec::from_raw_parts( - l1233.cast(), - len1235, - len1235, - ); - let l1236 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1235), - }, - l1236 as u64, - ) - }; - V1237::Handle(e1237) - } - }; - v1237 - }; - result1238.push(e1238); - } - _rt::cabi_dealloc( - base1238, - len1238 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1238, - } - }; - V1262::ComponentModel(e1262) - } - 1 => { - let e1262 = { - let l1239 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1250; - let v1250 = match l1239 { - 0 => { - let e1250 = { - let l1240 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1241 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1242 = l1241; - let bytes1242 = _rt::Vec::from_raw_parts( - l1240.cast(), - len1242, - len1242, - ); - _rt::string_lift(bytes1242) - }; - V1250::Url(e1250) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1250 = { - let l1243 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1244 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1245 = l1244; - let bytes1245 = _rt::Vec::from_raw_parts( - l1243.cast(), - len1245, - len1245, - ); - let l1246 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1245), - text_type: match l1246 { - 0 => None, - 1 => { - let e = { - let l1247 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1248 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1249 = l1248; - let bytes1249 = _rt::Vec::from_raw_parts( - l1247.cast(), - len1249, - len1249, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1249), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1250::Inline(e1250) - } - }; - v1250 - }; - V1262::UnstructuredText(e1262) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1262 = { - let l1251 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1261; - let v1261 = match l1251 { - 0 => { - let e1261 = { - let l1252 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1253 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1254 = l1253; - let bytes1254 = _rt::Vec::from_raw_parts( - l1252.cast(), - len1254, - len1254, - ); - _rt::string_lift(bytes1254) - }; - V1261::Url(e1261) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1261 = { - let l1255 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1256 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1257 = l1256; - let l1258 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1259 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1260 = l1259; - let bytes1260 = _rt::Vec::from_raw_parts( - l1258.cast(), - len1260, - len1260, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1255.cast(), - len1257, - len1257, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1260), - }, - } - }; - V1261::Inline(e1261) - } - }; - v1261 - }; - V1262::UnstructuredBinary(e1262) - } - }; - (_rt::string_lift(bytes1189), v1262) - }; - result1263.push(e1263); - } - _rt::cabi_dealloc( - base1263, - len1263 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1263 - }; - V1264::Multimodal(e1264) - } - }; - let l1265 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1412; - let v1412 = match l1265 { - 0 => { - let e1412 = { - let l1266 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1267 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1338 = l1266; - let len1338 = l1267; - let mut result1338 = _rt::Vec::with_capacity(len1338); - for i in 0..len1338 { - let base = base1338 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1338 = { - let l1268 = *base.add(0).cast::<*mut u8>(); - let l1269 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1270 = l1269; - let bytes1270 = _rt::Vec::from_raw_parts( - l1268.cast(), - len1270, - len1270, - ); - let l1271 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1337; - let v1337 = match l1271 { - 0 => { - let e1337 = { - let l1272 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1273 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1322 = l1272; - let len1322 = l1273; - let mut result1322 = _rt::Vec::with_capacity(len1322); - for i in 0..len1322 { - let base = base1322 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1322 = { - let l1274 = i32::from(*base.add(0).cast::()); - let l1278 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1282 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1321; - let v1321 = match l1282 { - 0 => { - let e1321 = { - let l1283 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1284 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1289 = l1283; - let len1289 = l1284; - let mut result1289 = _rt::Vec::with_capacity(len1289); - for i in 0..len1289 { - let base = base1289 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1289 = { - let l1285 = *base.add(0).cast::<*mut u8>(); - let l1286 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1287 = l1286; - let bytes1287 = _rt::Vec::from_raw_parts( - l1285.cast(), - len1287, - len1287, - ); - let l1288 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1287), l1288) - }; - result1289.push(e1289); - } - _rt::cabi_dealloc( - base1289, - len1289 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1289 - }; - V1321::RecordType(e1321) - } - 1 => { - let e1321 = { - let l1290 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1291 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1297 = l1290; - let len1297 = l1291; - let mut result1297 = _rt::Vec::with_capacity(len1297); - for i in 0..len1297 { - let base = base1297 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1297 = { - let l1292 = *base.add(0).cast::<*mut u8>(); - let l1293 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1294 = l1293; - let bytes1294 = _rt::Vec::from_raw_parts( - l1292.cast(), - len1294, - len1294, - ); - let l1295 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1294), - match l1295 { - 0 => None, - 1 => { - let e = { - let l1296 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1296 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1297.push(e1297); - } - _rt::cabi_dealloc( - base1297, - len1297 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1297 - }; - V1321::VariantType(e1321) - } - 2 => { - let e1321 = { - let l1298 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1299 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1303 = l1298; - let len1303 = l1299; - let mut result1303 = _rt::Vec::with_capacity(len1303); - for i in 0..len1303 { - let base = base1303 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1303 = { - let l1300 = *base.add(0).cast::<*mut u8>(); - let l1301 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1302 = l1301; - let bytes1302 = _rt::Vec::from_raw_parts( - l1300.cast(), - len1302, - len1302, - ); - _rt::string_lift(bytes1302) - }; - result1303.push(e1303); - } - _rt::cabi_dealloc( - base1303, - len1303 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1303 - }; - V1321::EnumType(e1321) - } - 3 => { - let e1321 = { - let l1304 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1305 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1309 = l1304; - let len1309 = l1305; - let mut result1309 = _rt::Vec::with_capacity(len1309); - for i in 0..len1309 { - let base = base1309 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1309 = { - let l1306 = *base.add(0).cast::<*mut u8>(); - let l1307 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1308 = l1307; - let bytes1308 = _rt::Vec::from_raw_parts( - l1306.cast(), - len1308, - len1308, - ); - _rt::string_lift(bytes1308) - }; - result1309.push(e1309); - } - _rt::cabi_dealloc( - base1309, - len1309 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1309 - }; - V1321::FlagsType(e1321) - } - 4 => { - let e1321 = { - let l1310 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1311 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1312 = l1311; - _rt::Vec::from_raw_parts(l1310.cast(), len1312, len1312) - }; - V1321::TupleType(e1321) - } - 5 => { - let e1321 = { - let l1313 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1313 - }; - V1321::ListType(e1321) - } - 6 => { - let e1321 = { - let l1314 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1314 - }; - V1321::OptionType(e1321) - } - 7 => { - let e1321 = { - let l1315 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1317 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1315 { - 0 => None, - 1 => { - let e = { - let l1316 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1316 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1317 { - 0 => None, - 1 => { - let e = { - let l1318 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1318 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1321::ResultType(e1321) - } - 8 => V1321::PrimU8Type, - 9 => V1321::PrimU16Type, - 10 => V1321::PrimU32Type, - 11 => V1321::PrimU64Type, - 12 => V1321::PrimS8Type, - 13 => V1321::PrimS16Type, - 14 => V1321::PrimS32Type, - 15 => V1321::PrimS64Type, - 16 => V1321::PrimF32Type, - 17 => V1321::PrimF64Type, - 18 => V1321::PrimCharType, - 19 => V1321::PrimBoolType, - 20 => V1321::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1321 = { - let l1319 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1320 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1319 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1320 as u8, - ), - ) - }; - V1321::HandleType(e1321) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1274 { - 0 => None, - 1 => { - let e = { - let l1275 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1276 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1277 = l1276; - let bytes1277 = _rt::Vec::from_raw_parts( - l1275.cast(), - len1277, - len1277, - ); - _rt::string_lift(bytes1277) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1278 { - 0 => None, - 1 => { - let e = { - let l1279 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1280 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1281 = l1280; - let bytes1281 = _rt::Vec::from_raw_parts( - l1279.cast(), - len1281, - len1281, - ); - _rt::string_lift(bytes1281) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1321, - } - }; - result1322.push(e1322); - } - _rt::cabi_dealloc( - base1322, - len1322 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1322, - } - }; - V1337::ComponentModel(e1337) - } - 1 => { - let e1337 = { - let l1323 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1323 { - 0 => None, - 1 => { - let e = { - let l1324 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1325 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1329 = l1324; - let len1329 = l1325; - let mut result1329 = _rt::Vec::with_capacity(len1329); - for i in 0..len1329 { - let base = base1329 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1329 = { - let l1326 = *base.add(0).cast::<*mut u8>(); - let l1327 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1328 = l1327; - let bytes1328 = _rt::Vec::from_raw_parts( - l1326.cast(), - len1328, - len1328, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1328), - } - }; - result1329.push(e1329); - } - _rt::cabi_dealloc( - base1329, - len1329 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1329 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1337::UnstructuredText(e1337) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1337 = { - let l1330 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1330 { - 0 => None, - 1 => { - let e = { - let l1331 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1332 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1336 = l1331; - let len1336 = l1332; - let mut result1336 = _rt::Vec::with_capacity(len1336); - for i in 0..len1336 { - let base = base1336 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1336 = { - let l1333 = *base.add(0).cast::<*mut u8>(); - let l1334 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1335 = l1334; - let bytes1335 = _rt::Vec::from_raw_parts( - l1333.cast(), - len1335, - len1335, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1335), - } - }; - result1336.push(e1336); - } - _rt::cabi_dealloc( - base1336, - len1336 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1336 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1337::UnstructuredBinary(e1337) - } - }; - (_rt::string_lift(bytes1270), v1337) - }; - result1338.push(e1338); - } - _rt::cabi_dealloc( - base1338, - len1338 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1338 - }; - V1412::Tuple(e1412) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1412 = { - let l1339 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1340 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1411 = l1339; - let len1411 = l1340; - let mut result1411 = _rt::Vec::with_capacity(len1411); - for i in 0..len1411 { - let base = base1411 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1411 = { - let l1341 = *base.add(0).cast::<*mut u8>(); - let l1342 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1343 = l1342; - let bytes1343 = _rt::Vec::from_raw_parts( - l1341.cast(), - len1343, - len1343, - ); - let l1344 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1410; - let v1410 = match l1344 { - 0 => { - let e1410 = { - let l1345 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1346 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1395 = l1345; - let len1395 = l1346; - let mut result1395 = _rt::Vec::with_capacity(len1395); - for i in 0..len1395 { - let base = base1395 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1395 = { - let l1347 = i32::from(*base.add(0).cast::()); - let l1351 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1355 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1394; - let v1394 = match l1355 { - 0 => { - let e1394 = { - let l1356 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1357 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1362 = l1356; - let len1362 = l1357; - let mut result1362 = _rt::Vec::with_capacity(len1362); - for i in 0..len1362 { - let base = base1362 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1362 = { - let l1358 = *base.add(0).cast::<*mut u8>(); - let l1359 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1360 = l1359; - let bytes1360 = _rt::Vec::from_raw_parts( - l1358.cast(), - len1360, - len1360, - ); - let l1361 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1360), l1361) - }; - result1362.push(e1362); - } - _rt::cabi_dealloc( - base1362, - len1362 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1362 - }; - V1394::RecordType(e1394) - } - 1 => { - let e1394 = { - let l1363 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1364 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1370 = l1363; - let len1370 = l1364; - let mut result1370 = _rt::Vec::with_capacity(len1370); - for i in 0..len1370 { - let base = base1370 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1370 = { - let l1365 = *base.add(0).cast::<*mut u8>(); - let l1366 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1367 = l1366; - let bytes1367 = _rt::Vec::from_raw_parts( - l1365.cast(), - len1367, - len1367, - ); - let l1368 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1367), - match l1368 { - 0 => None, - 1 => { - let e = { - let l1369 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1369 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1370.push(e1370); - } - _rt::cabi_dealloc( - base1370, - len1370 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1370 - }; - V1394::VariantType(e1394) - } - 2 => { - let e1394 = { - let l1371 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1372 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1376 = l1371; - let len1376 = l1372; - let mut result1376 = _rt::Vec::with_capacity(len1376); - for i in 0..len1376 { - let base = base1376 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1376 = { - let l1373 = *base.add(0).cast::<*mut u8>(); - let l1374 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1375 = l1374; - let bytes1375 = _rt::Vec::from_raw_parts( - l1373.cast(), - len1375, - len1375, - ); - _rt::string_lift(bytes1375) - }; - result1376.push(e1376); - } - _rt::cabi_dealloc( - base1376, - len1376 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1376 - }; - V1394::EnumType(e1394) - } - 3 => { - let e1394 = { - let l1377 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1378 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1382 = l1377; - let len1382 = l1378; - let mut result1382 = _rt::Vec::with_capacity(len1382); - for i in 0..len1382 { - let base = base1382 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1382 = { - let l1379 = *base.add(0).cast::<*mut u8>(); - let l1380 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1381 = l1380; - let bytes1381 = _rt::Vec::from_raw_parts( - l1379.cast(), - len1381, - len1381, - ); - _rt::string_lift(bytes1381) - }; - result1382.push(e1382); - } - _rt::cabi_dealloc( - base1382, - len1382 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1382 - }; - V1394::FlagsType(e1394) - } - 4 => { - let e1394 = { - let l1383 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1384 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1385 = l1384; - _rt::Vec::from_raw_parts(l1383.cast(), len1385, len1385) - }; - V1394::TupleType(e1394) - } - 5 => { - let e1394 = { - let l1386 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1386 - }; - V1394::ListType(e1394) - } - 6 => { - let e1394 = { - let l1387 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1387 - }; - V1394::OptionType(e1394) - } - 7 => { - let e1394 = { - let l1388 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1390 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1388 { - 0 => None, - 1 => { - let e = { - let l1389 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1389 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1390 { - 0 => None, - 1 => { - let e = { - let l1391 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1391 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1394::ResultType(e1394) - } - 8 => V1394::PrimU8Type, - 9 => V1394::PrimU16Type, - 10 => V1394::PrimU32Type, - 11 => V1394::PrimU64Type, - 12 => V1394::PrimS8Type, - 13 => V1394::PrimS16Type, - 14 => V1394::PrimS32Type, - 15 => V1394::PrimS64Type, - 16 => V1394::PrimF32Type, - 17 => V1394::PrimF64Type, - 18 => V1394::PrimCharType, - 19 => V1394::PrimBoolType, - 20 => V1394::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1394 = { - let l1392 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1393 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1392 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1393 as u8, - ), - ) - }; - V1394::HandleType(e1394) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1347 { - 0 => None, - 1 => { - let e = { - let l1348 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1349 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1350 = l1349; - let bytes1350 = _rt::Vec::from_raw_parts( - l1348.cast(), - len1350, - len1350, - ); - _rt::string_lift(bytes1350) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1351 { - 0 => None, - 1 => { - let e = { - let l1352 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1353 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1354 = l1353; - let bytes1354 = _rt::Vec::from_raw_parts( - l1352.cast(), - len1354, - len1354, - ); - _rt::string_lift(bytes1354) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1394, - } - }; - result1395.push(e1395); - } - _rt::cabi_dealloc( - base1395, - len1395 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1395, - } - }; - V1410::ComponentModel(e1410) - } - 1 => { - let e1410 = { - let l1396 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1396 { - 0 => None, - 1 => { - let e = { - let l1397 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1398 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1402 = l1397; - let len1402 = l1398; - let mut result1402 = _rt::Vec::with_capacity(len1402); - for i in 0..len1402 { - let base = base1402 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1402 = { - let l1399 = *base.add(0).cast::<*mut u8>(); - let l1400 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1401 = l1400; - let bytes1401 = _rt::Vec::from_raw_parts( - l1399.cast(), - len1401, - len1401, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1401), - } - }; - result1402.push(e1402); - } - _rt::cabi_dealloc( - base1402, - len1402 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1402 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1410::UnstructuredText(e1410) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1410 = { - let l1403 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1403 { - 0 => None, - 1 => { - let e = { - let l1404 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1405 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1409 = l1404; - let len1409 = l1405; - let mut result1409 = _rt::Vec::with_capacity(len1409); - for i in 0..len1409 { - let base = base1409 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1409 = { - let l1406 = *base.add(0).cast::<*mut u8>(); - let l1407 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1408 = l1407; - let bytes1408 = _rt::Vec::from_raw_parts( - l1406.cast(), - len1408, - len1408, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1408), - } - }; - result1409.push(e1409); - } - _rt::cabi_dealloc( - base1409, - len1409 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1409 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1410::UnstructuredBinary(e1410) - } - }; - (_rt::string_lift(bytes1343), v1410) - }; - result1411.push(e1411); - } - _rt::cabi_dealloc( - base1411, - len1411 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1411 - }; - V1412::Multimodal(e1412) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1264, - schema: v1412, - }, - } - }; - AgentInvocationResult::AgentInitialization(e1732) - } - 1 => { - let e1732 = { - let l1413 = i32::from( - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1569; - let v1569 = match l1413 { - 0 => { - let e1569 = { - let l1414 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1415 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1489 = l1414; - let len1489 = l1415; - let mut result1489 = _rt::Vec::with_capacity(len1489); - for i in 0..len1489 { - let base = base1489 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1489 = { - let l1416 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1488; - let v1488 = match l1416 { - 0 => { - let e1488 = { - let l1417 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1418 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1464 = l1417; - let len1464 = l1418; - let mut result1464 = _rt::Vec::with_capacity(len1464); - for i in 0..len1464 { - let base = base1464 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1464 = { - let l1419 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1463; - let v1463 = match l1419 { - 0 => { - let e1463 = { - let l1420 = *base.add(8).cast::<*mut u8>(); - let l1421 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1422 = l1421; - _rt::Vec::from_raw_parts(l1420.cast(), len1422, len1422) - }; - V1463::RecordValue(e1463) - } - 1 => { - let e1463 = { - let l1423 = *base.add(8).cast::(); - let l1424 = i32::from(*base.add(12).cast::()); - ( - l1423 as u32, - match l1424 { - 0 => None, - 1 => { - let e = { - let l1425 = *base.add(16).cast::(); - l1425 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1463::VariantValue(e1463) - } - 2 => { - let e1463 = { - let l1426 = *base.add(8).cast::(); - l1426 as u32 - }; - V1463::EnumValue(e1463) - } - 3 => { - let e1463 = { - let l1427 = *base.add(8).cast::<*mut u8>(); - let l1428 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1430 = l1427; - let len1430 = l1428; - let mut result1430 = _rt::Vec::with_capacity(len1430); - for i in 0..len1430 { - let base = base1430.add(i * 1); - let e1430 = { - let l1429 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1429 as u8) - }; - result1430.push(e1430); - } - _rt::cabi_dealloc(base1430, len1430 * 1, 1); - result1430 - }; - V1463::FlagsValue(e1463) - } - 4 => { - let e1463 = { - let l1431 = *base.add(8).cast::<*mut u8>(); - let l1432 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1433 = l1432; - _rt::Vec::from_raw_parts(l1431.cast(), len1433, len1433) - }; - V1463::TupleValue(e1463) - } - 5 => { - let e1463 = { - let l1434 = *base.add(8).cast::<*mut u8>(); - let l1435 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1436 = l1435; - _rt::Vec::from_raw_parts(l1434.cast(), len1436, len1436) - }; - V1463::ListValue(e1463) - } - 6 => { - let e1463 = { - let l1437 = i32::from(*base.add(8).cast::()); - match l1437 { - 0 => None, - 1 => { - let e = { - let l1438 = *base.add(12).cast::(); - l1438 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1463::OptionValue(e1463) - } - 7 => { - let e1463 = { - let l1439 = i32::from(*base.add(8).cast::()); - match l1439 { - 0 => { - let e = { - let l1440 = i32::from(*base.add(12).cast::()); - match l1440 { - 0 => None, - 1 => { - let e = { - let l1441 = *base.add(16).cast::(); - l1441 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1442 = i32::from(*base.add(12).cast::()); - match l1442 { - 0 => None, - 1 => { - let e = { - let l1443 = *base.add(16).cast::(); - l1443 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1463::ResultValue(e1463) - } - 8 => { - let e1463 = { - let l1444 = i32::from(*base.add(8).cast::()); - l1444 as u8 - }; - V1463::PrimU8(e1463) - } - 9 => { - let e1463 = { - let l1445 = i32::from(*base.add(8).cast::()); - l1445 as u16 - }; - V1463::PrimU16(e1463) - } - 10 => { - let e1463 = { - let l1446 = *base.add(8).cast::(); - l1446 as u32 - }; - V1463::PrimU32(e1463) - } - 11 => { - let e1463 = { - let l1447 = *base.add(8).cast::(); - l1447 as u64 - }; - V1463::PrimU64(e1463) - } - 12 => { - let e1463 = { - let l1448 = i32::from(*base.add(8).cast::()); - l1448 as i8 - }; - V1463::PrimS8(e1463) - } - 13 => { - let e1463 = { - let l1449 = i32::from(*base.add(8).cast::()); - l1449 as i16 - }; - V1463::PrimS16(e1463) - } - 14 => { - let e1463 = { - let l1450 = *base.add(8).cast::(); - l1450 - }; - V1463::PrimS32(e1463) - } - 15 => { - let e1463 = { - let l1451 = *base.add(8).cast::(); - l1451 - }; - V1463::PrimS64(e1463) - } - 16 => { - let e1463 = { - let l1452 = *base.add(8).cast::(); - l1452 - }; - V1463::PrimFloat32(e1463) - } - 17 => { - let e1463 = { - let l1453 = *base.add(8).cast::(); - l1453 - }; - V1463::PrimFloat64(e1463) - } - 18 => { - let e1463 = { - let l1454 = *base.add(8).cast::(); - _rt::char_lift(l1454 as u32) - }; - V1463::PrimChar(e1463) - } - 19 => { - let e1463 = { - let l1455 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1455 as u8) - }; - V1463::PrimBool(e1463) - } - 20 => { - let e1463 = { - let l1456 = *base.add(8).cast::<*mut u8>(); - let l1457 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1458 = l1457; - let bytes1458 = _rt::Vec::from_raw_parts( - l1456.cast(), - len1458, - len1458, - ); - _rt::string_lift(bytes1458) - }; - V1463::PrimString(e1463) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1463 = { - let l1459 = *base.add(8).cast::<*mut u8>(); - let l1460 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1461 = l1460; - let bytes1461 = _rt::Vec::from_raw_parts( - l1459.cast(), - len1461, - len1461, - ); - let l1462 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1461), - }, - l1462 as u64, - ) - }; - V1463::Handle(e1463) - } - }; - v1463 - }; - result1464.push(e1464); - } - _rt::cabi_dealloc( - base1464, - len1464 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1464, - } - }; - V1488::ComponentModel(e1488) - } - 1 => { - let e1488 = { - let l1465 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1476; - let v1476 = match l1465 { - 0 => { - let e1476 = { - let l1466 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1467 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1468 = l1467; - let bytes1468 = _rt::Vec::from_raw_parts( - l1466.cast(), - len1468, - len1468, - ); - _rt::string_lift(bytes1468) - }; - V1476::Url(e1476) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1476 = { - let l1469 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1470 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1471 = l1470; - let bytes1471 = _rt::Vec::from_raw_parts( - l1469.cast(), - len1471, - len1471, - ); - let l1472 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1471), - text_type: match l1472 { - 0 => None, - 1 => { - let e = { - let l1473 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1474 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1475 = l1474; - let bytes1475 = _rt::Vec::from_raw_parts( - l1473.cast(), - len1475, - len1475, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1475), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1476::Inline(e1476) - } - }; - v1476 - }; - V1488::UnstructuredText(e1488) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1488 = { - let l1477 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1487; - let v1487 = match l1477 { - 0 => { - let e1487 = { - let l1478 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1479 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1480 = l1479; - let bytes1480 = _rt::Vec::from_raw_parts( - l1478.cast(), - len1480, - len1480, - ); - _rt::string_lift(bytes1480) - }; - V1487::Url(e1487) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1487 = { - let l1481 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1482 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1483 = l1482; - let l1484 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1485 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1486 = l1485; - let bytes1486 = _rt::Vec::from_raw_parts( - l1484.cast(), - len1486, - len1486, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1481.cast(), - len1483, - len1483, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1486), - }, - } - }; - V1487::Inline(e1487) - } - }; - v1487 - }; - V1488::UnstructuredBinary(e1488) - } - }; - v1488 - }; - result1489.push(e1489); - } - _rt::cabi_dealloc( - base1489, - len1489 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1489 - }; - V1569::Tuple(e1569) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1569 = { - let l1490 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1491 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1568 = l1490; - let len1568 = l1491; - let mut result1568 = _rt::Vec::with_capacity(len1568); - for i in 0..len1568 { - let base = base1568 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1568 = { - let l1492 = *base.add(0).cast::<*mut u8>(); - let l1493 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1494 = l1493; - let bytes1494 = _rt::Vec::from_raw_parts( - l1492.cast(), - len1494, - len1494, - ); - let l1495 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1567; - let v1567 = match l1495 { - 0 => { - let e1567 = { - let l1496 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1497 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1543 = l1496; - let len1543 = l1497; - let mut result1543 = _rt::Vec::with_capacity(len1543); - for i in 0..len1543 { - let base = base1543 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1543 = { - let l1498 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1542; - let v1542 = match l1498 { - 0 => { - let e1542 = { - let l1499 = *base.add(8).cast::<*mut u8>(); - let l1500 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1501 = l1500; - _rt::Vec::from_raw_parts(l1499.cast(), len1501, len1501) - }; - V1542::RecordValue(e1542) - } - 1 => { - let e1542 = { - let l1502 = *base.add(8).cast::(); - let l1503 = i32::from(*base.add(12).cast::()); - ( - l1502 as u32, - match l1503 { - 0 => None, - 1 => { - let e = { - let l1504 = *base.add(16).cast::(); - l1504 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1542::VariantValue(e1542) - } - 2 => { - let e1542 = { - let l1505 = *base.add(8).cast::(); - l1505 as u32 - }; - V1542::EnumValue(e1542) - } - 3 => { - let e1542 = { - let l1506 = *base.add(8).cast::<*mut u8>(); - let l1507 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1509 = l1506; - let len1509 = l1507; - let mut result1509 = _rt::Vec::with_capacity(len1509); - for i in 0..len1509 { - let base = base1509.add(i * 1); - let e1509 = { - let l1508 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1508 as u8) - }; - result1509.push(e1509); - } - _rt::cabi_dealloc(base1509, len1509 * 1, 1); - result1509 - }; - V1542::FlagsValue(e1542) - } - 4 => { - let e1542 = { - let l1510 = *base.add(8).cast::<*mut u8>(); - let l1511 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1512 = l1511; - _rt::Vec::from_raw_parts(l1510.cast(), len1512, len1512) - }; - V1542::TupleValue(e1542) - } - 5 => { - let e1542 = { - let l1513 = *base.add(8).cast::<*mut u8>(); - let l1514 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1515 = l1514; - _rt::Vec::from_raw_parts(l1513.cast(), len1515, len1515) - }; - V1542::ListValue(e1542) - } - 6 => { - let e1542 = { - let l1516 = i32::from(*base.add(8).cast::()); - match l1516 { - 0 => None, - 1 => { - let e = { - let l1517 = *base.add(12).cast::(); - l1517 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1542::OptionValue(e1542) - } - 7 => { - let e1542 = { - let l1518 = i32::from(*base.add(8).cast::()); - match l1518 { - 0 => { - let e = { - let l1519 = i32::from(*base.add(12).cast::()); - match l1519 { - 0 => None, - 1 => { - let e = { - let l1520 = *base.add(16).cast::(); - l1520 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1521 = i32::from(*base.add(12).cast::()); - match l1521 { - 0 => None, - 1 => { - let e = { - let l1522 = *base.add(16).cast::(); - l1522 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1542::ResultValue(e1542) - } - 8 => { - let e1542 = { - let l1523 = i32::from(*base.add(8).cast::()); - l1523 as u8 - }; - V1542::PrimU8(e1542) - } - 9 => { - let e1542 = { - let l1524 = i32::from(*base.add(8).cast::()); - l1524 as u16 - }; - V1542::PrimU16(e1542) - } - 10 => { - let e1542 = { - let l1525 = *base.add(8).cast::(); - l1525 as u32 - }; - V1542::PrimU32(e1542) - } - 11 => { - let e1542 = { - let l1526 = *base.add(8).cast::(); - l1526 as u64 - }; - V1542::PrimU64(e1542) - } - 12 => { - let e1542 = { - let l1527 = i32::from(*base.add(8).cast::()); - l1527 as i8 - }; - V1542::PrimS8(e1542) - } - 13 => { - let e1542 = { - let l1528 = i32::from(*base.add(8).cast::()); - l1528 as i16 - }; - V1542::PrimS16(e1542) - } - 14 => { - let e1542 = { - let l1529 = *base.add(8).cast::(); - l1529 - }; - V1542::PrimS32(e1542) - } - 15 => { - let e1542 = { - let l1530 = *base.add(8).cast::(); - l1530 - }; - V1542::PrimS64(e1542) - } - 16 => { - let e1542 = { - let l1531 = *base.add(8).cast::(); - l1531 - }; - V1542::PrimFloat32(e1542) - } - 17 => { - let e1542 = { - let l1532 = *base.add(8).cast::(); - l1532 - }; - V1542::PrimFloat64(e1542) - } - 18 => { - let e1542 = { - let l1533 = *base.add(8).cast::(); - _rt::char_lift(l1533 as u32) - }; - V1542::PrimChar(e1542) - } - 19 => { - let e1542 = { - let l1534 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1534 as u8) - }; - V1542::PrimBool(e1542) - } - 20 => { - let e1542 = { - let l1535 = *base.add(8).cast::<*mut u8>(); - let l1536 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1537 = l1536; - let bytes1537 = _rt::Vec::from_raw_parts( - l1535.cast(), - len1537, - len1537, - ); - _rt::string_lift(bytes1537) - }; - V1542::PrimString(e1542) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1542 = { - let l1538 = *base.add(8).cast::<*mut u8>(); - let l1539 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1540 = l1539; - let bytes1540 = _rt::Vec::from_raw_parts( - l1538.cast(), - len1540, - len1540, - ); - let l1541 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1540), - }, - l1541 as u64, - ) - }; - V1542::Handle(e1542) - } - }; - v1542 - }; - result1543.push(e1543); - } - _rt::cabi_dealloc( - base1543, - len1543 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1543, - } - }; - V1567::ComponentModel(e1567) - } - 1 => { - let e1567 = { - let l1544 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1555; - let v1555 = match l1544 { - 0 => { - let e1555 = { - let l1545 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1546 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1547 = l1546; - let bytes1547 = _rt::Vec::from_raw_parts( - l1545.cast(), - len1547, - len1547, - ); - _rt::string_lift(bytes1547) - }; - V1555::Url(e1555) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1555 = { - let l1548 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1549 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1550 = l1549; - let bytes1550 = _rt::Vec::from_raw_parts( - l1548.cast(), - len1550, - len1550, - ); - let l1551 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1550), - text_type: match l1551 { - 0 => None, - 1 => { - let e = { - let l1552 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1553 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1554 = l1553; - let bytes1554 = _rt::Vec::from_raw_parts( - l1552.cast(), - len1554, - len1554, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1554), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1555::Inline(e1555) - } - }; - v1555 - }; - V1567::UnstructuredText(e1567) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1567 = { - let l1556 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1566; - let v1566 = match l1556 { - 0 => { - let e1566 = { - let l1557 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1558 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1559 = l1558; - let bytes1559 = _rt::Vec::from_raw_parts( - l1557.cast(), - len1559, - len1559, - ); - _rt::string_lift(bytes1559) - }; - V1566::Url(e1566) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1566 = { - let l1560 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1561 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1562 = l1561; - let l1563 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1564 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1565 = l1564; - let bytes1565 = _rt::Vec::from_raw_parts( - l1563.cast(), - len1565, - len1565, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1560.cast(), - len1562, - len1562, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1565), - }, - } - }; - V1566::Inline(e1566) - } - }; - v1566 - }; - V1567::UnstructuredBinary(e1567) - } - }; - (_rt::string_lift(bytes1494), v1567) - }; - result1568.push(e1568); - } - _rt::cabi_dealloc( - base1568, - len1568 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1568 - }; - V1569::Multimodal(e1569) - } - }; - let l1570 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V1717; - let v1717 = match l1570 { - 0 => { - let e1717 = { - let l1571 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1572 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1643 = l1571; - let len1643 = l1572; - let mut result1643 = _rt::Vec::with_capacity(len1643); - for i in 0..len1643 { - let base = base1643 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1643 = { - let l1573 = *base.add(0).cast::<*mut u8>(); - let l1574 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1575 = l1574; - let bytes1575 = _rt::Vec::from_raw_parts( - l1573.cast(), - len1575, - len1575, - ); - let l1576 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1642; - let v1642 = match l1576 { - 0 => { - let e1642 = { - let l1577 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1578 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1627 = l1577; - let len1627 = l1578; - let mut result1627 = _rt::Vec::with_capacity(len1627); - for i in 0..len1627 { - let base = base1627 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1627 = { - let l1579 = i32::from(*base.add(0).cast::()); - let l1583 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1587 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1626; - let v1626 = match l1587 { - 0 => { - let e1626 = { - let l1588 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1589 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1594 = l1588; - let len1594 = l1589; - let mut result1594 = _rt::Vec::with_capacity(len1594); - for i in 0..len1594 { - let base = base1594 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1594 = { - let l1590 = *base.add(0).cast::<*mut u8>(); - let l1591 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1592 = l1591; - let bytes1592 = _rt::Vec::from_raw_parts( - l1590.cast(), - len1592, - len1592, - ); - let l1593 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1592), l1593) - }; - result1594.push(e1594); - } - _rt::cabi_dealloc( - base1594, - len1594 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1594 - }; - V1626::RecordType(e1626) - } - 1 => { - let e1626 = { - let l1595 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1596 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1602 = l1595; - let len1602 = l1596; - let mut result1602 = _rt::Vec::with_capacity(len1602); - for i in 0..len1602 { - let base = base1602 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1602 = { - let l1597 = *base.add(0).cast::<*mut u8>(); - let l1598 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1599 = l1598; - let bytes1599 = _rt::Vec::from_raw_parts( - l1597.cast(), - len1599, - len1599, - ); - let l1600 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1599), - match l1600 { - 0 => None, - 1 => { - let e = { - let l1601 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1601 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1602.push(e1602); - } - _rt::cabi_dealloc( - base1602, - len1602 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1602 - }; - V1626::VariantType(e1626) - } - 2 => { - let e1626 = { - let l1603 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1604 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1608 = l1603; - let len1608 = l1604; - let mut result1608 = _rt::Vec::with_capacity(len1608); - for i in 0..len1608 { - let base = base1608 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1608 = { - let l1605 = *base.add(0).cast::<*mut u8>(); - let l1606 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1607 = l1606; - let bytes1607 = _rt::Vec::from_raw_parts( - l1605.cast(), - len1607, - len1607, - ); - _rt::string_lift(bytes1607) - }; - result1608.push(e1608); - } - _rt::cabi_dealloc( - base1608, - len1608 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1608 - }; - V1626::EnumType(e1626) - } - 3 => { - let e1626 = { - let l1609 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1610 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1614 = l1609; - let len1614 = l1610; - let mut result1614 = _rt::Vec::with_capacity(len1614); - for i in 0..len1614 { - let base = base1614 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1614 = { - let l1611 = *base.add(0).cast::<*mut u8>(); - let l1612 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1613 = l1612; - let bytes1613 = _rt::Vec::from_raw_parts( - l1611.cast(), - len1613, - len1613, - ); - _rt::string_lift(bytes1613) - }; - result1614.push(e1614); - } - _rt::cabi_dealloc( - base1614, - len1614 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1614 - }; - V1626::FlagsType(e1626) - } - 4 => { - let e1626 = { - let l1615 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1616 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1617 = l1616; - _rt::Vec::from_raw_parts(l1615.cast(), len1617, len1617) - }; - V1626::TupleType(e1626) - } - 5 => { - let e1626 = { - let l1618 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1618 - }; - V1626::ListType(e1626) - } - 6 => { - let e1626 = { - let l1619 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1619 - }; - V1626::OptionType(e1626) - } - 7 => { - let e1626 = { - let l1620 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1622 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1620 { - 0 => None, - 1 => { - let e = { - let l1621 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1621 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1622 { - 0 => None, - 1 => { - let e = { - let l1623 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1623 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1626::ResultType(e1626) - } - 8 => V1626::PrimU8Type, - 9 => V1626::PrimU16Type, - 10 => V1626::PrimU32Type, - 11 => V1626::PrimU64Type, - 12 => V1626::PrimS8Type, - 13 => V1626::PrimS16Type, - 14 => V1626::PrimS32Type, - 15 => V1626::PrimS64Type, - 16 => V1626::PrimF32Type, - 17 => V1626::PrimF64Type, - 18 => V1626::PrimCharType, - 19 => V1626::PrimBoolType, - 20 => V1626::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1626 = { - let l1624 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1625 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1624 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1625 as u8, - ), - ) - }; - V1626::HandleType(e1626) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1579 { - 0 => None, - 1 => { - let e = { - let l1580 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1581 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1582 = l1581; - let bytes1582 = _rt::Vec::from_raw_parts( - l1580.cast(), - len1582, - len1582, - ); - _rt::string_lift(bytes1582) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1583 { - 0 => None, - 1 => { - let e = { - let l1584 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1585 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1586 = l1585; - let bytes1586 = _rt::Vec::from_raw_parts( - l1584.cast(), - len1586, - len1586, - ); - _rt::string_lift(bytes1586) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1626, - } - }; - result1627.push(e1627); - } - _rt::cabi_dealloc( - base1627, - len1627 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1627, - } - }; - V1642::ComponentModel(e1642) - } - 1 => { - let e1642 = { - let l1628 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1628 { - 0 => None, - 1 => { - let e = { - let l1629 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1630 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1634 = l1629; - let len1634 = l1630; - let mut result1634 = _rt::Vec::with_capacity(len1634); - for i in 0..len1634 { - let base = base1634 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1634 = { - let l1631 = *base.add(0).cast::<*mut u8>(); - let l1632 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1633 = l1632; - let bytes1633 = _rt::Vec::from_raw_parts( - l1631.cast(), - len1633, - len1633, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1633), - } - }; - result1634.push(e1634); - } - _rt::cabi_dealloc( - base1634, - len1634 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1634 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1642::UnstructuredText(e1642) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1642 = { - let l1635 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1635 { - 0 => None, - 1 => { - let e = { - let l1636 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1637 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1641 = l1636; - let len1641 = l1637; - let mut result1641 = _rt::Vec::with_capacity(len1641); - for i in 0..len1641 { - let base = base1641 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1641 = { - let l1638 = *base.add(0).cast::<*mut u8>(); - let l1639 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1640 = l1639; - let bytes1640 = _rt::Vec::from_raw_parts( - l1638.cast(), - len1640, - len1640, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1640), - } - }; - result1641.push(e1641); - } - _rt::cabi_dealloc( - base1641, - len1641 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1641 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1642::UnstructuredBinary(e1642) - } - }; - (_rt::string_lift(bytes1575), v1642) - }; - result1643.push(e1643); - } - _rt::cabi_dealloc( - base1643, - len1643 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1643 - }; - V1717::Tuple(e1717) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1717 = { - let l1644 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1645 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1716 = l1644; - let len1716 = l1645; - let mut result1716 = _rt::Vec::with_capacity(len1716); - for i in 0..len1716 { - let base = base1716 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e1716 = { - let l1646 = *base.add(0).cast::<*mut u8>(); - let l1647 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1648 = l1647; - let bytes1648 = _rt::Vec::from_raw_parts( - l1646.cast(), - len1648, - len1648, - ); - let l1649 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V1715; - let v1715 = match l1649 { - 0 => { - let e1715 = { - let l1650 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1651 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1700 = l1650; - let len1700 = l1651; - let mut result1700 = _rt::Vec::with_capacity(len1700); - for i in 0..len1700 { - let base = base1700 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1700 = { - let l1652 = i32::from(*base.add(0).cast::()); - let l1656 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1660 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1699; - let v1699 = match l1660 { - 0 => { - let e1699 = { - let l1661 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1662 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1667 = l1661; - let len1667 = l1662; - let mut result1667 = _rt::Vec::with_capacity(len1667); - for i in 0..len1667 { - let base = base1667 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1667 = { - let l1663 = *base.add(0).cast::<*mut u8>(); - let l1664 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1665 = l1664; - let bytes1665 = _rt::Vec::from_raw_parts( - l1663.cast(), - len1665, - len1665, - ); - let l1666 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1665), l1666) - }; - result1667.push(e1667); - } - _rt::cabi_dealloc( - base1667, - len1667 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1667 - }; - V1699::RecordType(e1699) - } - 1 => { - let e1699 = { - let l1668 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1669 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1675 = l1668; - let len1675 = l1669; - let mut result1675 = _rt::Vec::with_capacity(len1675); - for i in 0..len1675 { - let base = base1675 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1675 = { - let l1670 = *base.add(0).cast::<*mut u8>(); - let l1671 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1672 = l1671; - let bytes1672 = _rt::Vec::from_raw_parts( - l1670.cast(), - len1672, - len1672, - ); - let l1673 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1672), - match l1673 { - 0 => None, - 1 => { - let e = { - let l1674 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1674 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1675.push(e1675); - } - _rt::cabi_dealloc( - base1675, - len1675 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1675 - }; - V1699::VariantType(e1699) - } - 2 => { - let e1699 = { - let l1676 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1677 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1681 = l1676; - let len1681 = l1677; - let mut result1681 = _rt::Vec::with_capacity(len1681); - for i in 0..len1681 { - let base = base1681 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1681 = { - let l1678 = *base.add(0).cast::<*mut u8>(); - let l1679 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1680 = l1679; - let bytes1680 = _rt::Vec::from_raw_parts( - l1678.cast(), - len1680, - len1680, - ); - _rt::string_lift(bytes1680) - }; - result1681.push(e1681); - } - _rt::cabi_dealloc( - base1681, - len1681 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1681 - }; - V1699::EnumType(e1699) - } - 3 => { - let e1699 = { - let l1682 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1683 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1687 = l1682; - let len1687 = l1683; - let mut result1687 = _rt::Vec::with_capacity(len1687); - for i in 0..len1687 { - let base = base1687 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1687 = { - let l1684 = *base.add(0).cast::<*mut u8>(); - let l1685 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1686 = l1685; - let bytes1686 = _rt::Vec::from_raw_parts( - l1684.cast(), - len1686, - len1686, - ); - _rt::string_lift(bytes1686) - }; - result1687.push(e1687); - } - _rt::cabi_dealloc( - base1687, - len1687 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1687 - }; - V1699::FlagsType(e1699) - } - 4 => { - let e1699 = { - let l1688 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1689 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1690 = l1689; - _rt::Vec::from_raw_parts(l1688.cast(), len1690, len1690) - }; - V1699::TupleType(e1699) - } - 5 => { - let e1699 = { - let l1691 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1691 - }; - V1699::ListType(e1699) - } - 6 => { - let e1699 = { - let l1692 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1692 - }; - V1699::OptionType(e1699) - } - 7 => { - let e1699 = { - let l1693 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1695 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1693 { - 0 => None, - 1 => { - let e = { - let l1694 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1694 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1695 { - 0 => None, - 1 => { - let e = { - let l1696 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1696 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1699::ResultType(e1699) - } - 8 => V1699::PrimU8Type, - 9 => V1699::PrimU16Type, - 10 => V1699::PrimU32Type, - 11 => V1699::PrimU64Type, - 12 => V1699::PrimS8Type, - 13 => V1699::PrimS16Type, - 14 => V1699::PrimS32Type, - 15 => V1699::PrimS64Type, - 16 => V1699::PrimF32Type, - 17 => V1699::PrimF64Type, - 18 => V1699::PrimCharType, - 19 => V1699::PrimBoolType, - 20 => V1699::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1699 = { - let l1697 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1698 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1697 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1698 as u8, - ), - ) - }; - V1699::HandleType(e1699) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1652 { - 0 => None, - 1 => { - let e = { - let l1653 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1654 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1655 = l1654; - let bytes1655 = _rt::Vec::from_raw_parts( - l1653.cast(), - len1655, - len1655, - ); - _rt::string_lift(bytes1655) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1656 { - 0 => None, - 1 => { - let e = { - let l1657 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1658 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1659 = l1658; - let bytes1659 = _rt::Vec::from_raw_parts( - l1657.cast(), - len1659, - len1659, - ); - _rt::string_lift(bytes1659) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1699, - } - }; - result1700.push(e1700); - } - _rt::cabi_dealloc( - base1700, - len1700 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1700, - } - }; - V1715::ComponentModel(e1715) - } - 1 => { - let e1715 = { - let l1701 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1701 { - 0 => None, - 1 => { - let e = { - let l1702 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1703 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1707 = l1702; - let len1707 = l1703; - let mut result1707 = _rt::Vec::with_capacity(len1707); - for i in 0..len1707 { - let base = base1707 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1707 = { - let l1704 = *base.add(0).cast::<*mut u8>(); - let l1705 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1706 = l1705; - let bytes1706 = _rt::Vec::from_raw_parts( - l1704.cast(), - len1706, - len1706, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1706), - } - }; - result1707.push(e1707); - } - _rt::cabi_dealloc( - base1707, - len1707 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1707 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1715::UnstructuredText(e1715) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1715 = { - let l1708 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1708 { - 0 => None, - 1 => { - let e = { - let l1709 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1710 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1714 = l1709; - let len1714 = l1710; - let mut result1714 = _rt::Vec::with_capacity(len1714); - for i in 0..len1714 { - let base = base1714 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1714 = { - let l1711 = *base.add(0).cast::<*mut u8>(); - let l1712 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1713 = l1712; - let bytes1713 = _rt::Vec::from_raw_parts( - l1711.cast(), - len1713, - len1713, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1713), - } - }; - result1714.push(e1714); - } - _rt::cabi_dealloc( - base1714, - len1714 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1714 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1715::UnstructuredBinary(e1715) - } - }; - (_rt::string_lift(bytes1648), v1715) - }; - result1716.push(e1716); - } - _rt::cabi_dealloc( - base1716, - len1716 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1716 - }; - V1717::Multimodal(e1717) - } - }; - AgentInvocationOutputParameters { - output: TypedDataValue { - value: v1569, - schema: v1717, - }, - } - }; - AgentInvocationResult::AgentMethod(e1732) - } - 2 => AgentInvocationResult::ManualUpdate, - 3 => { - let e1732 = { - let l1718 = i32::from( - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1718 { - 0 => None, - 1 => { - let e = { - let l1719 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1720 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1721 = l1720; - let bytes1721 = _rt::Vec::from_raw_parts( - l1719.cast(), - len1721, - len1721, - ); - _rt::string_lift(bytes1721) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::LoadSnapshot(e1732) - } - 4 => { - let e1732 = { - let l1722 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1723 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1724 = l1723; - let l1725 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1726 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1727 = l1726; - let bytes1727 = _rt::Vec::from_raw_parts( - l1725.cast(), - len1727, - len1727, - ); - SaveSnapshotResultParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l1722.cast(), - len1724, - len1724, - ), - mime_type: _rt::string_lift(bytes1727), - }, - } - }; - AgentInvocationResult::SaveSnapshot(e1732) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e1732 = { - let l1728 = i32::from( - *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - FallibleResultParameters { - error: match l1728 { - 0 => None, - 1 => { - let e = { - let l1729 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1730 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1731 = l1730; - let bytes1731 = _rt::Vec::from_raw_parts( - l1729.cast(), - len1731, - len1731, - ); - _rt::string_lift(bytes1731) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - AgentInvocationResult::ProcessOplogEntries(e1732) - } - }; - let l1733 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1734 = *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - AgentInvocationFinishedParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1105 as u64, - nanoseconds: l1106 as u32, - }, - invocation_result: v1732, - consumed_fuel: l1733, - component_revision: l1734 as u64, - } - }; - PublicOplogEntry::AgentInvocationFinished(e2676) - } - 4 => { - let e2676 = { - let l1735 = *base.add(16).cast::(); - let l1736 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1735 as u64, - nanoseconds: l1736 as u32, - }, - } - }; - PublicOplogEntry::Suspend(e2676) - } - 5 => { - let e2676 = { - let l1737 = *base.add(16).cast::(); - let l1738 = *base.add(24).cast::(); - let l1739 = *base.add(32).cast::<*mut u8>(); - let l1740 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1741 = l1740; - let bytes1741 = _rt::Vec::from_raw_parts( - l1739.cast(), - len1741, - len1741, - ); - let l1742 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ErrorParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1737 as u64, - nanoseconds: l1738 as u32, - }, - error: _rt::string_lift(bytes1741), - retry_from: l1742 as u64, - } - }; - PublicOplogEntry::Error(e2676) - } - 6 => { - let e2676 = { - let l1743 = *base.add(16).cast::(); - let l1744 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1743 as u64, - nanoseconds: l1744 as u32, - }, - } - }; - PublicOplogEntry::NoOp(e2676) - } - 7 => { - let e2676 = { - let l1745 = *base.add(16).cast::(); - let l1746 = *base.add(24).cast::(); - let l1747 = *base.add(32).cast::(); - let l1748 = *base.add(40).cast::(); - JumpParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1745 as u64, - nanoseconds: l1746 as u32, - }, - jump: OplogRegion { - start: l1747 as u64, - end: l1748 as u64, - }, - } - }; - PublicOplogEntry::Jump(e2676) - } - 8 => { - let e2676 = { - let l1749 = *base.add(16).cast::(); - let l1750 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1749 as u64, - nanoseconds: l1750 as u32, - }, - } - }; - PublicOplogEntry::Interrupted(e2676) - } - 9 => { - let e2676 = { - let l1751 = *base.add(16).cast::(); - let l1752 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1751 as u64, - nanoseconds: l1752 as u32, - }, - } - }; - PublicOplogEntry::Exited(e2676) - } - 10 => { - let e2676 = { - let l1753 = *base.add(16).cast::(); - let l1754 = *base.add(24).cast::(); - let l1755 = *base.add(32).cast::(); - let l1756 = *base.add(40).cast::(); - let l1757 = *base.add(48).cast::(); - let l1758 = *base.add(56).cast::(); - let l1759 = i32::from(*base.add(64).cast::()); - ChangeRetryPolicyParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1753 as u64, - nanoseconds: l1754 as u32, - }, - new_policy: super::super::super::golem::api::host::RetryPolicy { - max_attempts: l1755 as u32, - min_delay: l1756 as u64, - max_delay: l1757 as u64, - multiplier: l1758, - max_jitter_factor: match l1759 { - 0 => None, - 1 => { - let e = { - let l1760 = *base.add(72).cast::(); - l1760 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - }, - } - }; - PublicOplogEntry::ChangeRetryPolicy(e2676) - } - 11 => { - let e2676 = { - let l1761 = *base.add(16).cast::(); - let l1762 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1761 as u64, - nanoseconds: l1762 as u32, - }, - } - }; - PublicOplogEntry::BeginAtomicRegion(e2676) - } - 12 => { - let e2676 = { - let l1763 = *base.add(16).cast::(); - let l1764 = *base.add(24).cast::(); - let l1765 = *base.add(32).cast::(); - EndAtomicRegionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1763 as u64, - nanoseconds: l1764 as u32, - }, - begin_index: l1765 as u64, - } - }; - PublicOplogEntry::EndAtomicRegion(e2676) - } - 13 => { - let e2676 = { - let l1766 = *base.add(16).cast::(); - let l1767 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1766 as u64, - nanoseconds: l1767 as u32, - }, - } - }; - PublicOplogEntry::BeginRemoteWrite(e2676) - } - 14 => { - let e2676 = { - let l1768 = *base.add(16).cast::(); - let l1769 = *base.add(24).cast::(); - let l1770 = *base.add(32).cast::(); - EndRemoteWriteParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1768 as u64, - nanoseconds: l1769 as u32, - }, - begin_index: l1770 as u64, - } - }; - PublicOplogEntry::EndRemoteWrite(e2676) - } - 15 => { - let e2676 = { - let l1771 = *base.add(16).cast::(); - let l1772 = *base.add(24).cast::(); - let l1773 = i32::from(*base.add(32).cast::()); - let v2489 = match l1773 { - 0 => { - let e2489 = { - let l1774 = *base.add(40).cast::<*mut u8>(); - let l1775 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1776 = l1775; - let bytes1776 = _rt::Vec::from_raw_parts( - l1774.cast(), - len1776, - len1776, - ); - let l1777 = i32::from( - *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V1933; - let v1933 = match l1777 { - 0 => { - let e1933 = { - let l1778 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1779 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1853 = l1778; - let len1853 = l1779; - let mut result1853 = _rt::Vec::with_capacity(len1853); - for i in 0..len1853 { - let base = base1853 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e1853 = { - let l1780 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V1852; - let v1852 = match l1780 { - 0 => { - let e1852 = { - let l1781 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1782 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1828 = l1781; - let len1828 = l1782; - let mut result1828 = _rt::Vec::with_capacity(len1828); - for i in 0..len1828 { - let base = base1828 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1828 = { - let l1783 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1827; - let v1827 = match l1783 { - 0 => { - let e1827 = { - let l1784 = *base.add(8).cast::<*mut u8>(); - let l1785 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1786 = l1785; - _rt::Vec::from_raw_parts(l1784.cast(), len1786, len1786) - }; - V1827::RecordValue(e1827) - } - 1 => { - let e1827 = { - let l1787 = *base.add(8).cast::(); - let l1788 = i32::from(*base.add(12).cast::()); - ( - l1787 as u32, - match l1788 { - 0 => None, - 1 => { - let e = { - let l1789 = *base.add(16).cast::(); - l1789 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1827::VariantValue(e1827) - } - 2 => { - let e1827 = { - let l1790 = *base.add(8).cast::(); - l1790 as u32 - }; - V1827::EnumValue(e1827) - } - 3 => { - let e1827 = { - let l1791 = *base.add(8).cast::<*mut u8>(); - let l1792 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1794 = l1791; - let len1794 = l1792; - let mut result1794 = _rt::Vec::with_capacity(len1794); - for i in 0..len1794 { - let base = base1794.add(i * 1); - let e1794 = { - let l1793 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1793 as u8) - }; - result1794.push(e1794); - } - _rt::cabi_dealloc(base1794, len1794 * 1, 1); - result1794 - }; - V1827::FlagsValue(e1827) - } - 4 => { - let e1827 = { - let l1795 = *base.add(8).cast::<*mut u8>(); - let l1796 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1797 = l1796; - _rt::Vec::from_raw_parts(l1795.cast(), len1797, len1797) - }; - V1827::TupleValue(e1827) - } - 5 => { - let e1827 = { - let l1798 = *base.add(8).cast::<*mut u8>(); - let l1799 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1800 = l1799; - _rt::Vec::from_raw_parts(l1798.cast(), len1800, len1800) - }; - V1827::ListValue(e1827) - } - 6 => { - let e1827 = { - let l1801 = i32::from(*base.add(8).cast::()); - match l1801 { - 0 => None, - 1 => { - let e = { - let l1802 = *base.add(12).cast::(); - l1802 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1827::OptionValue(e1827) - } - 7 => { - let e1827 = { - let l1803 = i32::from(*base.add(8).cast::()); - match l1803 { - 0 => { - let e = { - let l1804 = i32::from(*base.add(12).cast::()); - match l1804 { - 0 => None, - 1 => { - let e = { - let l1805 = *base.add(16).cast::(); - l1805 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1806 = i32::from(*base.add(12).cast::()); - match l1806 { - 0 => None, - 1 => { - let e = { - let l1807 = *base.add(16).cast::(); - l1807 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1827::ResultValue(e1827) - } - 8 => { - let e1827 = { - let l1808 = i32::from(*base.add(8).cast::()); - l1808 as u8 - }; - V1827::PrimU8(e1827) - } - 9 => { - let e1827 = { - let l1809 = i32::from(*base.add(8).cast::()); - l1809 as u16 - }; - V1827::PrimU16(e1827) - } - 10 => { - let e1827 = { - let l1810 = *base.add(8).cast::(); - l1810 as u32 - }; - V1827::PrimU32(e1827) - } - 11 => { - let e1827 = { - let l1811 = *base.add(8).cast::(); - l1811 as u64 - }; - V1827::PrimU64(e1827) - } - 12 => { - let e1827 = { - let l1812 = i32::from(*base.add(8).cast::()); - l1812 as i8 - }; - V1827::PrimS8(e1827) - } - 13 => { - let e1827 = { - let l1813 = i32::from(*base.add(8).cast::()); - l1813 as i16 - }; - V1827::PrimS16(e1827) - } - 14 => { - let e1827 = { - let l1814 = *base.add(8).cast::(); - l1814 - }; - V1827::PrimS32(e1827) - } - 15 => { - let e1827 = { - let l1815 = *base.add(8).cast::(); - l1815 - }; - V1827::PrimS64(e1827) - } - 16 => { - let e1827 = { - let l1816 = *base.add(8).cast::(); - l1816 - }; - V1827::PrimFloat32(e1827) - } - 17 => { - let e1827 = { - let l1817 = *base.add(8).cast::(); - l1817 - }; - V1827::PrimFloat64(e1827) - } - 18 => { - let e1827 = { - let l1818 = *base.add(8).cast::(); - _rt::char_lift(l1818 as u32) - }; - V1827::PrimChar(e1827) - } - 19 => { - let e1827 = { - let l1819 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1819 as u8) - }; - V1827::PrimBool(e1827) - } - 20 => { - let e1827 = { - let l1820 = *base.add(8).cast::<*mut u8>(); - let l1821 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1822 = l1821; - let bytes1822 = _rt::Vec::from_raw_parts( - l1820.cast(), - len1822, - len1822, - ); - _rt::string_lift(bytes1822) - }; - V1827::PrimString(e1827) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1827 = { - let l1823 = *base.add(8).cast::<*mut u8>(); - let l1824 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1825 = l1824; - let bytes1825 = _rt::Vec::from_raw_parts( - l1823.cast(), - len1825, - len1825, - ); - let l1826 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1825), - }, - l1826 as u64, - ) - }; - V1827::Handle(e1827) - } - }; - v1827 - }; - result1828.push(e1828); - } - _rt::cabi_dealloc( - base1828, - len1828 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1828, - } - }; - V1852::ComponentModel(e1852) - } - 1 => { - let e1852 = { - let l1829 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1840; - let v1840 = match l1829 { - 0 => { - let e1840 = { - let l1830 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1831 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1832 = l1831; - let bytes1832 = _rt::Vec::from_raw_parts( - l1830.cast(), - len1832, - len1832, - ); - _rt::string_lift(bytes1832) - }; - V1840::Url(e1840) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1840 = { - let l1833 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1834 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1835 = l1834; - let bytes1835 = _rt::Vec::from_raw_parts( - l1833.cast(), - len1835, - len1835, - ); - let l1836 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1835), - text_type: match l1836 { - 0 => None, - 1 => { - let e = { - let l1837 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1838 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1839 = l1838; - let bytes1839 = _rt::Vec::from_raw_parts( - l1837.cast(), - len1839, - len1839, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1839), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1840::Inline(e1840) - } - }; - v1840 - }; - V1852::UnstructuredText(e1852) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1852 = { - let l1841 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1851; - let v1851 = match l1841 { - 0 => { - let e1851 = { - let l1842 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1843 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1844 = l1843; - let bytes1844 = _rt::Vec::from_raw_parts( - l1842.cast(), - len1844, - len1844, - ); - _rt::string_lift(bytes1844) - }; - V1851::Url(e1851) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1851 = { - let l1845 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1846 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1847 = l1846; - let l1848 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1849 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1850 = l1849; - let bytes1850 = _rt::Vec::from_raw_parts( - l1848.cast(), - len1850, - len1850, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1845.cast(), - len1847, - len1847, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1850), - }, - } - }; - V1851::Inline(e1851) - } - }; - v1851 - }; - V1852::UnstructuredBinary(e1852) - } - }; - v1852 - }; - result1853.push(e1853); - } - _rt::cabi_dealloc( - base1853, - len1853 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1853 - }; - V1933::Tuple(e1933) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1933 = { - let l1854 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1855 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1932 = l1854; - let len1932 = l1855; - let mut result1932 = _rt::Vec::with_capacity(len1932); - for i in 0..len1932 { - let base = base1932 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e1932 = { - let l1856 = *base.add(0).cast::<*mut u8>(); - let l1857 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1858 = l1857; - let bytes1858 = _rt::Vec::from_raw_parts( - l1856.cast(), - len1858, - len1858, - ); - let l1859 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V1931; - let v1931 = match l1859 { - 0 => { - let e1931 = { - let l1860 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1861 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1907 = l1860; - let len1907 = l1861; - let mut result1907 = _rt::Vec::with_capacity(len1907); - for i in 0..len1907 { - let base = base1907 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e1907 = { - let l1862 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V1906; - let v1906 = match l1862 { - 0 => { - let e1906 = { - let l1863 = *base.add(8).cast::<*mut u8>(); - let l1864 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1865 = l1864; - _rt::Vec::from_raw_parts(l1863.cast(), len1865, len1865) - }; - V1906::RecordValue(e1906) - } - 1 => { - let e1906 = { - let l1866 = *base.add(8).cast::(); - let l1867 = i32::from(*base.add(12).cast::()); - ( - l1866 as u32, - match l1867 { - 0 => None, - 1 => { - let e = { - let l1868 = *base.add(16).cast::(); - l1868 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1906::VariantValue(e1906) - } - 2 => { - let e1906 = { - let l1869 = *base.add(8).cast::(); - l1869 as u32 - }; - V1906::EnumValue(e1906) - } - 3 => { - let e1906 = { - let l1870 = *base.add(8).cast::<*mut u8>(); - let l1871 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1873 = l1870; - let len1873 = l1871; - let mut result1873 = _rt::Vec::with_capacity(len1873); - for i in 0..len1873 { - let base = base1873.add(i * 1); - let e1873 = { - let l1872 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l1872 as u8) - }; - result1873.push(e1873); - } - _rt::cabi_dealloc(base1873, len1873 * 1, 1); - result1873 - }; - V1906::FlagsValue(e1906) - } - 4 => { - let e1906 = { - let l1874 = *base.add(8).cast::<*mut u8>(); - let l1875 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1876 = l1875; - _rt::Vec::from_raw_parts(l1874.cast(), len1876, len1876) - }; - V1906::TupleValue(e1906) - } - 5 => { - let e1906 = { - let l1877 = *base.add(8).cast::<*mut u8>(); - let l1878 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1879 = l1878; - _rt::Vec::from_raw_parts(l1877.cast(), len1879, len1879) - }; - V1906::ListValue(e1906) - } - 6 => { - let e1906 = { - let l1880 = i32::from(*base.add(8).cast::()); - match l1880 { - 0 => None, - 1 => { - let e = { - let l1881 = *base.add(12).cast::(); - l1881 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1906::OptionValue(e1906) - } - 7 => { - let e1906 = { - let l1882 = i32::from(*base.add(8).cast::()); - match l1882 { - 0 => { - let e = { - let l1883 = i32::from(*base.add(12).cast::()); - match l1883 { - 0 => None, - 1 => { - let e = { - let l1884 = *base.add(16).cast::(); - l1884 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l1885 = i32::from(*base.add(12).cast::()); - match l1885 { - 0 => None, - 1 => { - let e = { - let l1886 = *base.add(16).cast::(); - l1886 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V1906::ResultValue(e1906) - } - 8 => { - let e1906 = { - let l1887 = i32::from(*base.add(8).cast::()); - l1887 as u8 - }; - V1906::PrimU8(e1906) - } - 9 => { - let e1906 = { - let l1888 = i32::from(*base.add(8).cast::()); - l1888 as u16 - }; - V1906::PrimU16(e1906) - } - 10 => { - let e1906 = { - let l1889 = *base.add(8).cast::(); - l1889 as u32 - }; - V1906::PrimU32(e1906) - } - 11 => { - let e1906 = { - let l1890 = *base.add(8).cast::(); - l1890 as u64 - }; - V1906::PrimU64(e1906) - } - 12 => { - let e1906 = { - let l1891 = i32::from(*base.add(8).cast::()); - l1891 as i8 - }; - V1906::PrimS8(e1906) - } - 13 => { - let e1906 = { - let l1892 = i32::from(*base.add(8).cast::()); - l1892 as i16 - }; - V1906::PrimS16(e1906) - } - 14 => { - let e1906 = { - let l1893 = *base.add(8).cast::(); - l1893 - }; - V1906::PrimS32(e1906) - } - 15 => { - let e1906 = { - let l1894 = *base.add(8).cast::(); - l1894 - }; - V1906::PrimS64(e1906) - } - 16 => { - let e1906 = { - let l1895 = *base.add(8).cast::(); - l1895 - }; - V1906::PrimFloat32(e1906) - } - 17 => { - let e1906 = { - let l1896 = *base.add(8).cast::(); - l1896 - }; - V1906::PrimFloat64(e1906) - } - 18 => { - let e1906 = { - let l1897 = *base.add(8).cast::(); - _rt::char_lift(l1897 as u32) - }; - V1906::PrimChar(e1906) - } - 19 => { - let e1906 = { - let l1898 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l1898 as u8) - }; - V1906::PrimBool(e1906) - } - 20 => { - let e1906 = { - let l1899 = *base.add(8).cast::<*mut u8>(); - let l1900 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1901 = l1900; - let bytes1901 = _rt::Vec::from_raw_parts( - l1899.cast(), - len1901, - len1901, - ); - _rt::string_lift(bytes1901) - }; - V1906::PrimString(e1906) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1906 = { - let l1902 = *base.add(8).cast::<*mut u8>(); - let l1903 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1904 = l1903; - let bytes1904 = _rt::Vec::from_raw_parts( - l1902.cast(), - len1904, - len1904, - ); - let l1905 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes1904), - }, - l1905 as u64, - ) - }; - V1906::Handle(e1906) - } - }; - v1906 - }; - result1907.push(e1907); - } - _rt::cabi_dealloc( - base1907, - len1907 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result1907, - } - }; - V1931::ComponentModel(e1931) - } - 1 => { - let e1931 = { - let l1908 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V1919; - let v1919 = match l1908 { - 0 => { - let e1919 = { - let l1909 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1910 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1911 = l1910; - let bytes1911 = _rt::Vec::from_raw_parts( - l1909.cast(), - len1911, - len1911, - ); - _rt::string_lift(bytes1911) - }; - V1919::Url(e1919) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1919 = { - let l1912 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1913 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1914 = l1913; - let bytes1914 = _rt::Vec::from_raw_parts( - l1912.cast(), - len1914, - len1914, - ); - let l1915 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes1914), - text_type: match l1915 { - 0 => None, - 1 => { - let e = { - let l1916 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1917 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1918 = l1917; - let bytes1918 = _rt::Vec::from_raw_parts( - l1916.cast(), - len1918, - len1918, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1918), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V1919::Inline(e1919) - } - }; - v1919 - }; - V1931::UnstructuredText(e1931) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e1931 = { - let l1920 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V1930; - let v1930 = match l1920 { - 0 => { - let e1930 = { - let l1921 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1922 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1923 = l1922; - let bytes1923 = _rt::Vec::from_raw_parts( - l1921.cast(), - len1923, - len1923, - ); - _rt::string_lift(bytes1923) - }; - V1930::Url(e1930) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e1930 = { - let l1924 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1925 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1926 = l1925; - let l1927 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1928 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1929 = l1928; - let bytes1929 = _rt::Vec::from_raw_parts( - l1927.cast(), - len1929, - len1929, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l1924.cast(), - len1926, - len1926, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes1929), - }, - } - }; - V1930::Inline(e1930) - } - }; - v1930 - }; - V1931::UnstructuredBinary(e1931) - } - }; - (_rt::string_lift(bytes1858), v1931) - }; - result1932.push(e1932); - } - _rt::cabi_dealloc( - base1932, - len1932 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1932 - }; - V1933::Multimodal(e1933) - } - }; - let l1934 = i32::from( - *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2081; - let v2081 = match l1934 { - 0 => { - let e2081 = { - let l1935 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1936 = *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2007 = l1935; - let len2007 = l1936; - let mut result2007 = _rt::Vec::with_capacity(len2007); - for i in 0..len2007 { - let base = base2007 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2007 = { - let l1937 = *base.add(0).cast::<*mut u8>(); - let l1938 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1939 = l1938; - let bytes1939 = _rt::Vec::from_raw_parts( - l1937.cast(), - len1939, - len1939, - ); - let l1940 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2006; - let v2006 = match l1940 { - 0 => { - let e2006 = { - let l1941 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1942 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1991 = l1941; - let len1991 = l1942; - let mut result1991 = _rt::Vec::with_capacity(len1991); - for i in 0..len1991 { - let base = base1991 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e1991 = { - let l1943 = i32::from(*base.add(0).cast::()); - let l1947 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1951 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V1990; - let v1990 = match l1951 { - 0 => { - let e1990 = { - let l1952 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1953 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1958 = l1952; - let len1958 = l1953; - let mut result1958 = _rt::Vec::with_capacity(len1958); - for i in 0..len1958 { - let base = base1958 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e1958 = { - let l1954 = *base.add(0).cast::<*mut u8>(); - let l1955 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1956 = l1955; - let bytes1956 = _rt::Vec::from_raw_parts( - l1954.cast(), - len1956, - len1956, - ); - let l1957 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes1956), l1957) - }; - result1958.push(e1958); - } - _rt::cabi_dealloc( - base1958, - len1958 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1958 - }; - V1990::RecordType(e1990) - } - 1 => { - let e1990 = { - let l1959 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1960 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1966 = l1959; - let len1966 = l1960; - let mut result1966 = _rt::Vec::with_capacity(len1966); - for i in 0..len1966 { - let base = base1966 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e1966 = { - let l1961 = *base.add(0).cast::<*mut u8>(); - let l1962 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1963 = l1962; - let bytes1963 = _rt::Vec::from_raw_parts( - l1961.cast(), - len1963, - len1963, - ); - let l1964 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes1963), - match l1964 { - 0 => None, - 1 => { - let e = { - let l1965 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1965 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result1966.push(e1966); - } - _rt::cabi_dealloc( - base1966, - len1966 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1966 - }; - V1990::VariantType(e1990) - } - 2 => { - let e1990 = { - let l1967 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1968 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1972 = l1967; - let len1972 = l1968; - let mut result1972 = _rt::Vec::with_capacity(len1972); - for i in 0..len1972 { - let base = base1972 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1972 = { - let l1969 = *base.add(0).cast::<*mut u8>(); - let l1970 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1971 = l1970; - let bytes1971 = _rt::Vec::from_raw_parts( - l1969.cast(), - len1971, - len1971, - ); - _rt::string_lift(bytes1971) - }; - result1972.push(e1972); - } - _rt::cabi_dealloc( - base1972, - len1972 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1972 - }; - V1990::EnumType(e1990) - } - 3 => { - let e1990 = { - let l1973 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1974 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1978 = l1973; - let len1978 = l1974; - let mut result1978 = _rt::Vec::with_capacity(len1978); - for i in 0..len1978 { - let base = base1978 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1978 = { - let l1975 = *base.add(0).cast::<*mut u8>(); - let l1976 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1977 = l1976; - let bytes1977 = _rt::Vec::from_raw_parts( - l1975.cast(), - len1977, - len1977, - ); - _rt::string_lift(bytes1977) - }; - result1978.push(e1978); - } - _rt::cabi_dealloc( - base1978, - len1978 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1978 - }; - V1990::FlagsType(e1990) - } - 4 => { - let e1990 = { - let l1979 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1980 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1981 = l1980; - _rt::Vec::from_raw_parts(l1979.cast(), len1981, len1981) - }; - V1990::TupleType(e1990) - } - 5 => { - let e1990 = { - let l1982 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1982 - }; - V1990::ListType(e1990) - } - 6 => { - let e1990 = { - let l1983 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1983 - }; - V1990::OptionType(e1990) - } - 7 => { - let e1990 = { - let l1984 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l1986 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l1984 { - 0 => None, - 1 => { - let e = { - let l1985 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1985 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l1986 { - 0 => None, - 1 => { - let e = { - let l1987 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l1987 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V1990::ResultType(e1990) - } - 8 => V1990::PrimU8Type, - 9 => V1990::PrimU16Type, - 10 => V1990::PrimU32Type, - 11 => V1990::PrimU64Type, - 12 => V1990::PrimS8Type, - 13 => V1990::PrimS16Type, - 14 => V1990::PrimS32Type, - 15 => V1990::PrimS64Type, - 16 => V1990::PrimF32Type, - 17 => V1990::PrimF64Type, - 18 => V1990::PrimCharType, - 19 => V1990::PrimBoolType, - 20 => V1990::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e1990 = { - let l1988 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l1989 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l1988 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l1989 as u8, - ), - ) - }; - V1990::HandleType(e1990) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l1943 { - 0 => None, - 1 => { - let e = { - let l1944 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1945 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1946 = l1945; - let bytes1946 = _rt::Vec::from_raw_parts( - l1944.cast(), - len1946, - len1946, - ); - _rt::string_lift(bytes1946) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l1947 { - 0 => None, - 1 => { - let e = { - let l1948 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1949 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len1950 = l1949; - let bytes1950 = _rt::Vec::from_raw_parts( - l1948.cast(), - len1950, - len1950, - ); - _rt::string_lift(bytes1950) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v1990, - } - }; - result1991.push(e1991); - } - _rt::cabi_dealloc( - base1991, - len1991 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result1991, - } - }; - V2006::ComponentModel(e2006) - } - 1 => { - let e2006 = { - let l1992 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l1992 { - 0 => None, - 1 => { - let e = { - let l1993 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l1994 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base1998 = l1993; - let len1998 = l1994; - let mut result1998 = _rt::Vec::with_capacity(len1998); - for i in 0..len1998 { - let base = base1998 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e1998 = { - let l1995 = *base.add(0).cast::<*mut u8>(); - let l1996 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len1997 = l1996; - let bytes1997 = _rt::Vec::from_raw_parts( - l1995.cast(), - len1997, - len1997, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes1997), - } - }; - result1998.push(e1998); - } - _rt::cabi_dealloc( - base1998, - len1998 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result1998 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2006::UnstructuredText(e2006) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2006 = { - let l1999 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l1999 { - 0 => None, - 1 => { - let e = { - let l2000 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2001 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2005 = l2000; - let len2005 = l2001; - let mut result2005 = _rt::Vec::with_capacity(len2005); - for i in 0..len2005 { - let base = base2005 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2005 = { - let l2002 = *base.add(0).cast::<*mut u8>(); - let l2003 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2004 = l2003; - let bytes2004 = _rt::Vec::from_raw_parts( - l2002.cast(), - len2004, - len2004, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2004), - } - }; - result2005.push(e2005); - } - _rt::cabi_dealloc( - base2005, - len2005 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2005 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2006::UnstructuredBinary(e2006) - } - }; - (_rt::string_lift(bytes1939), v2006) - }; - result2007.push(e2007); - } - _rt::cabi_dealloc( - base2007, - len2007 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2007 - }; - V2081::Tuple(e2081) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2081 = { - let l2008 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2009 = *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2080 = l2008; - let len2080 = l2009; - let mut result2080 = _rt::Vec::with_capacity(len2080); - for i in 0..len2080 { - let base = base2080 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2080 = { - let l2010 = *base.add(0).cast::<*mut u8>(); - let l2011 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2012 = l2011; - let bytes2012 = _rt::Vec::from_raw_parts( - l2010.cast(), - len2012, - len2012, - ); - let l2013 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2079; - let v2079 = match l2013 { - 0 => { - let e2079 = { - let l2014 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2015 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2064 = l2014; - let len2064 = l2015; - let mut result2064 = _rt::Vec::with_capacity(len2064); - for i in 0..len2064 { - let base = base2064 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2064 = { - let l2016 = i32::from(*base.add(0).cast::()); - let l2020 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2024 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2063; - let v2063 = match l2024 { - 0 => { - let e2063 = { - let l2025 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2026 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2031 = l2025; - let len2031 = l2026; - let mut result2031 = _rt::Vec::with_capacity(len2031); - for i in 0..len2031 { - let base = base2031 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2031 = { - let l2027 = *base.add(0).cast::<*mut u8>(); - let l2028 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2029 = l2028; - let bytes2029 = _rt::Vec::from_raw_parts( - l2027.cast(), - len2029, - len2029, - ); - let l2030 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2029), l2030) - }; - result2031.push(e2031); - } - _rt::cabi_dealloc( - base2031, - len2031 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2031 - }; - V2063::RecordType(e2063) - } - 1 => { - let e2063 = { - let l2032 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2033 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2039 = l2032; - let len2039 = l2033; - let mut result2039 = _rt::Vec::with_capacity(len2039); - for i in 0..len2039 { - let base = base2039 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2039 = { - let l2034 = *base.add(0).cast::<*mut u8>(); - let l2035 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2036 = l2035; - let bytes2036 = _rt::Vec::from_raw_parts( - l2034.cast(), - len2036, - len2036, - ); - let l2037 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2036), - match l2037 { - 0 => None, - 1 => { - let e = { - let l2038 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2038 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2039.push(e2039); - } - _rt::cabi_dealloc( - base2039, - len2039 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2039 - }; - V2063::VariantType(e2063) - } - 2 => { - let e2063 = { - let l2040 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2041 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2045 = l2040; - let len2045 = l2041; - let mut result2045 = _rt::Vec::with_capacity(len2045); - for i in 0..len2045 { - let base = base2045 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2045 = { - let l2042 = *base.add(0).cast::<*mut u8>(); - let l2043 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2044 = l2043; - let bytes2044 = _rt::Vec::from_raw_parts( - l2042.cast(), - len2044, - len2044, - ); - _rt::string_lift(bytes2044) - }; - result2045.push(e2045); - } - _rt::cabi_dealloc( - base2045, - len2045 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2045 - }; - V2063::EnumType(e2063) - } - 3 => { - let e2063 = { - let l2046 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2047 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2051 = l2046; - let len2051 = l2047; - let mut result2051 = _rt::Vec::with_capacity(len2051); - for i in 0..len2051 { - let base = base2051 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2051 = { - let l2048 = *base.add(0).cast::<*mut u8>(); - let l2049 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2050 = l2049; - let bytes2050 = _rt::Vec::from_raw_parts( - l2048.cast(), - len2050, - len2050, - ); - _rt::string_lift(bytes2050) - }; - result2051.push(e2051); - } - _rt::cabi_dealloc( - base2051, - len2051 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2051 - }; - V2063::FlagsType(e2063) - } - 4 => { - let e2063 = { - let l2052 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2053 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2054 = l2053; - _rt::Vec::from_raw_parts(l2052.cast(), len2054, len2054) - }; - V2063::TupleType(e2063) - } - 5 => { - let e2063 = { - let l2055 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2055 - }; - V2063::ListType(e2063) - } - 6 => { - let e2063 = { - let l2056 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2056 - }; - V2063::OptionType(e2063) - } - 7 => { - let e2063 = { - let l2057 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2059 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2057 { - 0 => None, - 1 => { - let e = { - let l2058 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2058 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2059 { - 0 => None, - 1 => { - let e = { - let l2060 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2060 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2063::ResultType(e2063) - } - 8 => V2063::PrimU8Type, - 9 => V2063::PrimU16Type, - 10 => V2063::PrimU32Type, - 11 => V2063::PrimU64Type, - 12 => V2063::PrimS8Type, - 13 => V2063::PrimS16Type, - 14 => V2063::PrimS32Type, - 15 => V2063::PrimS64Type, - 16 => V2063::PrimF32Type, - 17 => V2063::PrimF64Type, - 18 => V2063::PrimCharType, - 19 => V2063::PrimBoolType, - 20 => V2063::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2063 = { - let l2061 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2062 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2061 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2062 as u8, - ), - ) - }; - V2063::HandleType(e2063) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2016 { - 0 => None, - 1 => { - let e = { - let l2017 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2018 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2019 = l2018; - let bytes2019 = _rt::Vec::from_raw_parts( - l2017.cast(), - len2019, - len2019, - ); - _rt::string_lift(bytes2019) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2020 { - 0 => None, - 1 => { - let e = { - let l2021 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2022 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2023 = l2022; - let bytes2023 = _rt::Vec::from_raw_parts( - l2021.cast(), - len2023, - len2023, - ); - _rt::string_lift(bytes2023) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2063, - } - }; - result2064.push(e2064); - } - _rt::cabi_dealloc( - base2064, - len2064 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2064, - } - }; - V2079::ComponentModel(e2079) - } - 1 => { - let e2079 = { - let l2065 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2065 { - 0 => None, - 1 => { - let e = { - let l2066 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2067 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2071 = l2066; - let len2071 = l2067; - let mut result2071 = _rt::Vec::with_capacity(len2071); - for i in 0..len2071 { - let base = base2071 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2071 = { - let l2068 = *base.add(0).cast::<*mut u8>(); - let l2069 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2070 = l2069; - let bytes2070 = _rt::Vec::from_raw_parts( - l2068.cast(), - len2070, - len2070, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2070), - } - }; - result2071.push(e2071); - } - _rt::cabi_dealloc( - base2071, - len2071 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2071 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2079::UnstructuredText(e2079) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2079 = { - let l2072 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2072 { - 0 => None, - 1 => { - let e = { - let l2073 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2074 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2078 = l2073; - let len2078 = l2074; - let mut result2078 = _rt::Vec::with_capacity(len2078); - for i in 0..len2078 { - let base = base2078 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2078 = { - let l2075 = *base.add(0).cast::<*mut u8>(); - let l2076 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2077 = l2076; - let bytes2077 = _rt::Vec::from_raw_parts( - l2075.cast(), - len2077, - len2077, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2077), - } - }; - result2078.push(e2078); - } - _rt::cabi_dealloc( - base2078, - len2078 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2078 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2079::UnstructuredBinary(e2079) - } - }; - (_rt::string_lift(bytes2012), v2079) - }; - result2080.push(e2080); - } - _rt::cabi_dealloc( - base2080, - len2080 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2080 - }; - V2081::Multimodal(e2081) - } - }; - let l2082 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2083 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2084 = l2083; - let bytes2084 = _rt::Vec::from_raw_parts( - l2082.cast(), - len2084, - len2084, - ); - let l2085 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2086 = *base - .add(40 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2090 = l2085; - let len2090 = l2086; - let mut result2090 = _rt::Vec::with_capacity(len2090); - for i in 0..len2090 { - let base = base2090 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2090 = { - let l2087 = *base.add(0).cast::<*mut u8>(); - let l2088 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2089 = l2088; - let bytes2089 = _rt::Vec::from_raw_parts( - l2087.cast(), - len2089, - len2089, - ); - _rt::string_lift(bytes2089) - }; - result2090.push(e2090); - } - _rt::cabi_dealloc( - base2090, - len2090 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2091 = *base - .add(40 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2092 = *base - .add(40 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2124 = l2091; - let len2124 = l2092; - let mut result2124 = _rt::Vec::with_capacity(len2124); - for i in 0..len2124 { - let base = base2124 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2124 = { - let l2093 = *base.add(0).cast::<*mut u8>(); - let l2094 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2123 = l2093; - let len2123 = l2094; - let mut result2123 = _rt::Vec::with_capacity(len2123); - for i in 0..len2123 { - let base = base2123 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2123 = { - let l2095 = i32::from(*base.add(0).cast::()); - let v2122 = match l2095 { - 0 => { - let e2122 = { - let l2096 = *base.add(8).cast::<*mut u8>(); - let l2097 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2098 = l2097; - let bytes2098 = _rt::Vec::from_raw_parts( - l2096.cast(), - len2098, - len2098, - ); - let l2099 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2100 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2101 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2105 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2107 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2108 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2117 = l2107; - let len2117 = l2108; - let mut result2117 = _rt::Vec::with_capacity(len2117); - for i in 0..len2117 { - let base = base2117 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2117 = { - let l2109 = *base.add(0).cast::<*mut u8>(); - let l2110 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2111 = l2110; - let bytes2111 = _rt::Vec::from_raw_parts( - l2109.cast(), - len2111, - len2111, - ); - let l2112 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2116; - let v2116 = match l2112 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2116 = { - let l2113 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2114 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2115 = l2114; - let bytes2115 = _rt::Vec::from_raw_parts( - l2113.cast(), - len2115, - len2115, - ); - _rt::string_lift(bytes2115) - }; - V2116::String(e2116) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2111), - value: v2116, - } - }; - result2117.push(e2117); - } - _rt::cabi_dealloc( - base2117, - len2117 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2118 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2098), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2099 as u64, - nanoseconds: l2100 as u32, - }, - parent: match l2101 { - 0 => None, - 1 => { - let e = { - let l2102 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2103 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2104 = l2103; - let bytes2104 = _rt::Vec::from_raw_parts( - l2102.cast(), - len2104, - len2104, - ); - _rt::string_lift(bytes2104) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2105 { - 0 => None, - 1 => { - let e = { - let l2106 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2106 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2117, - inherited: _rt::bool_lift(l2118 as u8), - } - }; - SpanData::LocalSpan(e2122) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2122 = { - let l2119 = *base.add(8).cast::<*mut u8>(); - let l2120 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2121 = l2120; - let bytes2121 = _rt::Vec::from_raw_parts( - l2119.cast(), - len2121, - len2121, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2121), - } - }; - SpanData::ExternalSpan(e2122) - } - }; - v2122 - }; - result2123.push(e2123); - } - _rt::cabi_dealloc( - base2123, - len2123 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2123 - }; - result2124.push(e2124); - } - _rt::cabi_dealloc( - base2124, - len2124 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentInitializationParameters { - idempotency_key: _rt::string_lift(bytes1776), - constructor_parameters: TypedDataValue { - value: v1933, - schema: v2081, - }, - trace_id: _rt::string_lift(bytes2084), - trace_states: result2090, - invocation_context: result2124, - } - }; - AgentInvocation::AgentInitialization(e2489) - } - 1 => { - let e2489 = { - let l2125 = *base.add(40).cast::<*mut u8>(); - let l2126 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2127 = l2126; - let bytes2127 = _rt::Vec::from_raw_parts( - l2125.cast(), - len2127, - len2127, - ); - let l2128 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2129 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2130 = l2129; - let bytes2130 = _rt::Vec::from_raw_parts( - l2128.cast(), - len2130, - len2130, - ); - let l2131 = i32::from( - *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataValue as V2287; - let v2287 = match l2131 { - 0 => { - let e2287 = { - let l2132 = *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2133 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2207 = l2132; - let len2207 = l2133; - let mut result2207 = _rt::Vec::with_capacity(len2207); - for i in 0..len2207 { - let base = base2207 - .add(i * (7 * ::core::mem::size_of::<*const u8>())); - let e2207 = { - let l2134 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::ElementValue as V2206; - let v2206 = match l2134 { - 0 => { - let e2206 = { - let l2135 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2136 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2182 = l2135; - let len2182 = l2136; - let mut result2182 = _rt::Vec::with_capacity(len2182); - for i in 0..len2182 { - let base = base2182 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2182 = { - let l2137 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2181; - let v2181 = match l2137 { - 0 => { - let e2181 = { - let l2138 = *base.add(8).cast::<*mut u8>(); - let l2139 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2140 = l2139; - _rt::Vec::from_raw_parts(l2138.cast(), len2140, len2140) - }; - V2181::RecordValue(e2181) - } - 1 => { - let e2181 = { - let l2141 = *base.add(8).cast::(); - let l2142 = i32::from(*base.add(12).cast::()); - ( - l2141 as u32, - match l2142 { - 0 => None, - 1 => { - let e = { - let l2143 = *base.add(16).cast::(); - l2143 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2181::VariantValue(e2181) - } - 2 => { - let e2181 = { - let l2144 = *base.add(8).cast::(); - l2144 as u32 - }; - V2181::EnumValue(e2181) - } - 3 => { - let e2181 = { - let l2145 = *base.add(8).cast::<*mut u8>(); - let l2146 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2148 = l2145; - let len2148 = l2146; - let mut result2148 = _rt::Vec::with_capacity(len2148); - for i in 0..len2148 { - let base = base2148.add(i * 1); - let e2148 = { - let l2147 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2147 as u8) - }; - result2148.push(e2148); - } - _rt::cabi_dealloc(base2148, len2148 * 1, 1); - result2148 - }; - V2181::FlagsValue(e2181) - } - 4 => { - let e2181 = { - let l2149 = *base.add(8).cast::<*mut u8>(); - let l2150 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2151 = l2150; - _rt::Vec::from_raw_parts(l2149.cast(), len2151, len2151) - }; - V2181::TupleValue(e2181) - } - 5 => { - let e2181 = { - let l2152 = *base.add(8).cast::<*mut u8>(); - let l2153 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2154 = l2153; - _rt::Vec::from_raw_parts(l2152.cast(), len2154, len2154) - }; - V2181::ListValue(e2181) - } - 6 => { - let e2181 = { - let l2155 = i32::from(*base.add(8).cast::()); - match l2155 { - 0 => None, - 1 => { - let e = { - let l2156 = *base.add(12).cast::(); - l2156 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2181::OptionValue(e2181) - } - 7 => { - let e2181 = { - let l2157 = i32::from(*base.add(8).cast::()); - match l2157 { - 0 => { - let e = { - let l2158 = i32::from(*base.add(12).cast::()); - match l2158 { - 0 => None, - 1 => { - let e = { - let l2159 = *base.add(16).cast::(); - l2159 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2160 = i32::from(*base.add(12).cast::()); - match l2160 { - 0 => None, - 1 => { - let e = { - let l2161 = *base.add(16).cast::(); - l2161 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2181::ResultValue(e2181) - } - 8 => { - let e2181 = { - let l2162 = i32::from(*base.add(8).cast::()); - l2162 as u8 - }; - V2181::PrimU8(e2181) - } - 9 => { - let e2181 = { - let l2163 = i32::from(*base.add(8).cast::()); - l2163 as u16 - }; - V2181::PrimU16(e2181) - } - 10 => { - let e2181 = { - let l2164 = *base.add(8).cast::(); - l2164 as u32 - }; - V2181::PrimU32(e2181) - } - 11 => { - let e2181 = { - let l2165 = *base.add(8).cast::(); - l2165 as u64 - }; - V2181::PrimU64(e2181) - } - 12 => { - let e2181 = { - let l2166 = i32::from(*base.add(8).cast::()); - l2166 as i8 - }; - V2181::PrimS8(e2181) - } - 13 => { - let e2181 = { - let l2167 = i32::from(*base.add(8).cast::()); - l2167 as i16 - }; - V2181::PrimS16(e2181) - } - 14 => { - let e2181 = { - let l2168 = *base.add(8).cast::(); - l2168 - }; - V2181::PrimS32(e2181) - } - 15 => { - let e2181 = { - let l2169 = *base.add(8).cast::(); - l2169 - }; - V2181::PrimS64(e2181) - } - 16 => { - let e2181 = { - let l2170 = *base.add(8).cast::(); - l2170 - }; - V2181::PrimFloat32(e2181) - } - 17 => { - let e2181 = { - let l2171 = *base.add(8).cast::(); - l2171 - }; - V2181::PrimFloat64(e2181) - } - 18 => { - let e2181 = { - let l2172 = *base.add(8).cast::(); - _rt::char_lift(l2172 as u32) - }; - V2181::PrimChar(e2181) - } - 19 => { - let e2181 = { - let l2173 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2173 as u8) - }; - V2181::PrimBool(e2181) - } - 20 => { - let e2181 = { - let l2174 = *base.add(8).cast::<*mut u8>(); - let l2175 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2176 = l2175; - let bytes2176 = _rt::Vec::from_raw_parts( - l2174.cast(), - len2176, - len2176, - ); - _rt::string_lift(bytes2176) - }; - V2181::PrimString(e2181) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2181 = { - let l2177 = *base.add(8).cast::<*mut u8>(); - let l2178 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2179 = l2178; - let bytes2179 = _rt::Vec::from_raw_parts( - l2177.cast(), - len2179, - len2179, - ); - let l2180 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2179), - }, - l2180 as u64, - ) - }; - V2181::Handle(e2181) - } - }; - v2181 - }; - result2182.push(e2182); - } - _rt::cabi_dealloc( - base2182, - len2182 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2182, - } - }; - V2206::ComponentModel(e2206) - } - 1 => { - let e2206 = { - let l2183 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2194; - let v2194 = match l2183 { - 0 => { - let e2194 = { - let l2184 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2185 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2186 = l2185; - let bytes2186 = _rt::Vec::from_raw_parts( - l2184.cast(), - len2186, - len2186, - ); - _rt::string_lift(bytes2186) - }; - V2194::Url(e2194) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2194 = { - let l2187 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2188 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2189 = l2188; - let bytes2189 = _rt::Vec::from_raw_parts( - l2187.cast(), - len2189, - len2189, - ); - let l2190 = i32::from( - *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2189), - text_type: match l2190 { - 0 => None, - 1 => { - let e = { - let l2191 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2192 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2193 = l2192; - let bytes2193 = _rt::Vec::from_raw_parts( - l2191.cast(), - len2193, - len2193, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2193), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2194::Inline(e2194) - } - }; - v2194 - }; - V2206::UnstructuredText(e2206) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2206 = { - let l2195 = i32::from( - *base.add(::core::mem::size_of::<*const u8>()).cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2205; - let v2205 = match l2195 { - 0 => { - let e2205 = { - let l2196 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2197 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2198 = l2197; - let bytes2198 = _rt::Vec::from_raw_parts( - l2196.cast(), - len2198, - len2198, - ); - _rt::string_lift(bytes2198) - }; - V2205::Url(e2205) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2205 = { - let l2199 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2200 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2201 = l2200; - let l2202 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2203 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2204 = l2203; - let bytes2204 = _rt::Vec::from_raw_parts( - l2202.cast(), - len2204, - len2204, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2199.cast(), - len2201, - len2201, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2204), - }, - } - }; - V2205::Inline(e2205) - } - }; - v2205 - }; - V2206::UnstructuredBinary(e2206) - } - }; - v2206 - }; - result2207.push(e2207); - } - _rt::cabi_dealloc( - base2207, - len2207 * (7 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2207 - }; - V2287::Tuple(e2287) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2287 = { - let l2208 = *base - .add(40 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2209 = *base - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2286 = l2208; - let len2286 = l2209; - let mut result2286 = _rt::Vec::with_capacity(len2286); - for i in 0..len2286 { - let base = base2286 - .add(i * (9 * ::core::mem::size_of::<*const u8>())); - let e2286 = { - let l2210 = *base.add(0).cast::<*mut u8>(); - let l2211 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2212 = l2211; - let bytes2212 = _rt::Vec::from_raw_parts( - l2210.cast(), - len2212, - len2212, - ); - let l2213 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementValue as V2285; - let v2285 = match l2213 { - 0 => { - let e2285 = { - let l2214 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2215 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2261 = l2214; - let len2261 = l2215; - let mut result2261 = _rt::Vec::with_capacity(len2261); - for i in 0..len2261 { - let base = base2261 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e2261 = { - let l2216 = i32::from(*base.add(0).cast::()); - use super::super::super::golem::core::types::WitNode as V2260; - let v2260 = match l2216 { - 0 => { - let e2260 = { - let l2217 = *base.add(8).cast::<*mut u8>(); - let l2218 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2219 = l2218; - _rt::Vec::from_raw_parts(l2217.cast(), len2219, len2219) - }; - V2260::RecordValue(e2260) - } - 1 => { - let e2260 = { - let l2220 = *base.add(8).cast::(); - let l2221 = i32::from(*base.add(12).cast::()); - ( - l2220 as u32, - match l2221 { - 0 => None, - 1 => { - let e = { - let l2222 = *base.add(16).cast::(); - l2222 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2260::VariantValue(e2260) - } - 2 => { - let e2260 = { - let l2223 = *base.add(8).cast::(); - l2223 as u32 - }; - V2260::EnumValue(e2260) - } - 3 => { - let e2260 = { - let l2224 = *base.add(8).cast::<*mut u8>(); - let l2225 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2227 = l2224; - let len2227 = l2225; - let mut result2227 = _rt::Vec::with_capacity(len2227); - for i in 0..len2227 { - let base = base2227.add(i * 1); - let e2227 = { - let l2226 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l2226 as u8) - }; - result2227.push(e2227); - } - _rt::cabi_dealloc(base2227, len2227 * 1, 1); - result2227 - }; - V2260::FlagsValue(e2260) - } - 4 => { - let e2260 = { - let l2228 = *base.add(8).cast::<*mut u8>(); - let l2229 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2230 = l2229; - _rt::Vec::from_raw_parts(l2228.cast(), len2230, len2230) - }; - V2260::TupleValue(e2260) - } - 5 => { - let e2260 = { - let l2231 = *base.add(8).cast::<*mut u8>(); - let l2232 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2233 = l2232; - _rt::Vec::from_raw_parts(l2231.cast(), len2233, len2233) - }; - V2260::ListValue(e2260) - } - 6 => { - let e2260 = { - let l2234 = i32::from(*base.add(8).cast::()); - match l2234 { - 0 => None, - 1 => { - let e = { - let l2235 = *base.add(12).cast::(); - l2235 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2260::OptionValue(e2260) - } - 7 => { - let e2260 = { - let l2236 = i32::from(*base.add(8).cast::()); - match l2236 { - 0 => { - let e = { - let l2237 = i32::from(*base.add(12).cast::()); - match l2237 { - 0 => None, - 1 => { - let e = { - let l2238 = *base.add(16).cast::(); - l2238 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l2239 = i32::from(*base.add(12).cast::()); - match l2239 { - 0 => None, - 1 => { - let e = { - let l2240 = *base.add(16).cast::(); - l2240 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V2260::ResultValue(e2260) - } - 8 => { - let e2260 = { - let l2241 = i32::from(*base.add(8).cast::()); - l2241 as u8 - }; - V2260::PrimU8(e2260) - } - 9 => { - let e2260 = { - let l2242 = i32::from(*base.add(8).cast::()); - l2242 as u16 - }; - V2260::PrimU16(e2260) - } - 10 => { - let e2260 = { - let l2243 = *base.add(8).cast::(); - l2243 as u32 - }; - V2260::PrimU32(e2260) - } - 11 => { - let e2260 = { - let l2244 = *base.add(8).cast::(); - l2244 as u64 - }; - V2260::PrimU64(e2260) - } - 12 => { - let e2260 = { - let l2245 = i32::from(*base.add(8).cast::()); - l2245 as i8 - }; - V2260::PrimS8(e2260) - } - 13 => { - let e2260 = { - let l2246 = i32::from(*base.add(8).cast::()); - l2246 as i16 - }; - V2260::PrimS16(e2260) - } - 14 => { - let e2260 = { - let l2247 = *base.add(8).cast::(); - l2247 - }; - V2260::PrimS32(e2260) - } - 15 => { - let e2260 = { - let l2248 = *base.add(8).cast::(); - l2248 - }; - V2260::PrimS64(e2260) - } - 16 => { - let e2260 = { - let l2249 = *base.add(8).cast::(); - l2249 - }; - V2260::PrimFloat32(e2260) - } - 17 => { - let e2260 = { - let l2250 = *base.add(8).cast::(); - l2250 - }; - V2260::PrimFloat64(e2260) - } - 18 => { - let e2260 = { - let l2251 = *base.add(8).cast::(); - _rt::char_lift(l2251 as u32) - }; - V2260::PrimChar(e2260) - } - 19 => { - let e2260 = { - let l2252 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l2252 as u8) - }; - V2260::PrimBool(e2260) - } - 20 => { - let e2260 = { - let l2253 = *base.add(8).cast::<*mut u8>(); - let l2254 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2255 = l2254; - let bytes2255 = _rt::Vec::from_raw_parts( - l2253.cast(), - len2255, - len2255, - ); - _rt::string_lift(bytes2255) - }; - V2260::PrimString(e2260) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2260 = { - let l2256 = *base.add(8).cast::<*mut u8>(); - let l2257 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2258 = l2257; - let bytes2258 = _rt::Vec::from_raw_parts( - l2256.cast(), - len2258, - len2258, - ); - let l2259 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes2258), - }, - l2259 as u64, - ) - }; - V2260::Handle(e2260) - } - }; - v2260 - }; - result2261.push(e2261); - } - _rt::cabi_dealloc( - base2261, - len2261 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitValue { - nodes: result2261, - } - }; - V2285::ComponentModel(e2285) - } - 1 => { - let e2285 = { - let l2262 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::TextReference as V2273; - let v2273 = match l2262 { - 0 => { - let e2273 = { - let l2263 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2264 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2265 = l2264; - let bytes2265 = _rt::Vec::from_raw_parts( - l2263.cast(), - len2265, - len2265, - ); - _rt::string_lift(bytes2265) - }; - V2273::Url(e2273) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2273 = { - let l2266 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2267 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2268 = l2267; - let bytes2268 = _rt::Vec::from_raw_parts( - l2266.cast(), - len2268, - len2268, - ); - let l2269 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextSource { - data: _rt::string_lift(bytes2268), - text_type: match l2269 { - 0 => None, - 1 => { - let e = { - let l2270 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2271 = *base - .add(8 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2272 = l2271; - let bytes2272 = _rt::Vec::from_raw_parts( - l2270.cast(), - len2272, - len2272, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2272), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2273::Inline(e2273) - } - }; - v2273 - }; - V2285::UnstructuredText(e2285) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2285 = { - let l2274 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::BinaryReference as V2284; - let v2284 = match l2274 { - 0 => { - let e2284 = { - let l2275 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2276 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2277 = l2276; - let bytes2277 = _rt::Vec::from_raw_parts( - l2275.cast(), - len2277, - len2277, - ); - _rt::string_lift(bytes2277) - }; - V2284::Url(e2284) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2284 = { - let l2278 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2279 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2280 = l2279; - let l2281 = *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2282 = *base - .add(7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2283 = l2282; - let bytes2283 = _rt::Vec::from_raw_parts( - l2281.cast(), - len2283, - len2283, - ); - super::super::super::golem::core::types::BinarySource { - data: _rt::Vec::from_raw_parts( - l2278.cast(), - len2280, - len2280, - ), - binary_type: super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2283), - }, - } - }; - V2284::Inline(e2284) - } - }; - v2284 - }; - V2285::UnstructuredBinary(e2285) - } - }; - (_rt::string_lift(bytes2212), v2285) - }; - result2286.push(e2286); - } - _rt::cabi_dealloc( - base2286, - len2286 * (9 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2286 - }; - V2287::Multimodal(e2287) - } - }; - let l2288 = i32::from( - *base - .add(40 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::DataSchema as V2435; - let v2435 = match l2288 { - 0 => { - let e2435 = { - let l2289 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2290 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2361 = l2289; - let len2361 = l2290; - let mut result2361 = _rt::Vec::with_capacity(len2361); - for i in 0..len2361 { - let base = base2361 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2361 = { - let l2291 = *base.add(0).cast::<*mut u8>(); - let l2292 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2293 = l2292; - let bytes2293 = _rt::Vec::from_raw_parts( - l2291.cast(), - len2293, - len2293, - ); - let l2294 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2360; - let v2360 = match l2294 { - 0 => { - let e2360 = { - let l2295 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2296 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2345 = l2295; - let len2345 = l2296; - let mut result2345 = _rt::Vec::with_capacity(len2345); - for i in 0..len2345 { - let base = base2345 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2345 = { - let l2297 = i32::from(*base.add(0).cast::()); - let l2301 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2305 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2344; - let v2344 = match l2305 { - 0 => { - let e2344 = { - let l2306 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2307 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2312 = l2306; - let len2312 = l2307; - let mut result2312 = _rt::Vec::with_capacity(len2312); - for i in 0..len2312 { - let base = base2312 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2312 = { - let l2308 = *base.add(0).cast::<*mut u8>(); - let l2309 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2310 = l2309; - let bytes2310 = _rt::Vec::from_raw_parts( - l2308.cast(), - len2310, - len2310, - ); - let l2311 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2310), l2311) - }; - result2312.push(e2312); - } - _rt::cabi_dealloc( - base2312, - len2312 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2312 - }; - V2344::RecordType(e2344) - } - 1 => { - let e2344 = { - let l2313 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2314 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2320 = l2313; - let len2320 = l2314; - let mut result2320 = _rt::Vec::with_capacity(len2320); - for i in 0..len2320 { - let base = base2320 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2320 = { - let l2315 = *base.add(0).cast::<*mut u8>(); - let l2316 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2317 = l2316; - let bytes2317 = _rt::Vec::from_raw_parts( - l2315.cast(), - len2317, - len2317, - ); - let l2318 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2317), - match l2318 { - 0 => None, - 1 => { - let e = { - let l2319 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2319 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2320.push(e2320); - } - _rt::cabi_dealloc( - base2320, - len2320 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2320 - }; - V2344::VariantType(e2344) - } - 2 => { - let e2344 = { - let l2321 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2322 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2326 = l2321; - let len2326 = l2322; - let mut result2326 = _rt::Vec::with_capacity(len2326); - for i in 0..len2326 { - let base = base2326 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2326 = { - let l2323 = *base.add(0).cast::<*mut u8>(); - let l2324 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2325 = l2324; - let bytes2325 = _rt::Vec::from_raw_parts( - l2323.cast(), - len2325, - len2325, - ); - _rt::string_lift(bytes2325) - }; - result2326.push(e2326); - } - _rt::cabi_dealloc( - base2326, - len2326 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2326 - }; - V2344::EnumType(e2344) - } - 3 => { - let e2344 = { - let l2327 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2328 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2332 = l2327; - let len2332 = l2328; - let mut result2332 = _rt::Vec::with_capacity(len2332); - for i in 0..len2332 { - let base = base2332 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2332 = { - let l2329 = *base.add(0).cast::<*mut u8>(); - let l2330 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2331 = l2330; - let bytes2331 = _rt::Vec::from_raw_parts( - l2329.cast(), - len2331, - len2331, - ); - _rt::string_lift(bytes2331) - }; - result2332.push(e2332); - } - _rt::cabi_dealloc( - base2332, - len2332 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2332 - }; - V2344::FlagsType(e2344) - } - 4 => { - let e2344 = { - let l2333 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2334 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2335 = l2334; - _rt::Vec::from_raw_parts(l2333.cast(), len2335, len2335) - }; - V2344::TupleType(e2344) - } - 5 => { - let e2344 = { - let l2336 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2336 - }; - V2344::ListType(e2344) - } - 6 => { - let e2344 = { - let l2337 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2337 - }; - V2344::OptionType(e2344) - } - 7 => { - let e2344 = { - let l2338 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2340 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2338 { - 0 => None, - 1 => { - let e = { - let l2339 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2339 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2340 { - 0 => None, - 1 => { - let e = { - let l2341 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2341 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2344::ResultType(e2344) - } - 8 => V2344::PrimU8Type, - 9 => V2344::PrimU16Type, - 10 => V2344::PrimU32Type, - 11 => V2344::PrimU64Type, - 12 => V2344::PrimS8Type, - 13 => V2344::PrimS16Type, - 14 => V2344::PrimS32Type, - 15 => V2344::PrimS64Type, - 16 => V2344::PrimF32Type, - 17 => V2344::PrimF64Type, - 18 => V2344::PrimCharType, - 19 => V2344::PrimBoolType, - 20 => V2344::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2344 = { - let l2342 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2343 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2342 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2343 as u8, - ), - ) - }; - V2344::HandleType(e2344) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2297 { - 0 => None, - 1 => { - let e = { - let l2298 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2299 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2300 = l2299; - let bytes2300 = _rt::Vec::from_raw_parts( - l2298.cast(), - len2300, - len2300, - ); - _rt::string_lift(bytes2300) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2301 { - 0 => None, - 1 => { - let e = { - let l2302 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2303 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2304 = l2303; - let bytes2304 = _rt::Vec::from_raw_parts( - l2302.cast(), - len2304, - len2304, - ); - _rt::string_lift(bytes2304) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2344, - } - }; - result2345.push(e2345); - } - _rt::cabi_dealloc( - base2345, - len2345 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2345, - } - }; - V2360::ComponentModel(e2360) - } - 1 => { - let e2360 = { - let l2346 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2346 { - 0 => None, - 1 => { - let e = { - let l2347 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2348 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2352 = l2347; - let len2352 = l2348; - let mut result2352 = _rt::Vec::with_capacity(len2352); - for i in 0..len2352 { - let base = base2352 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2352 = { - let l2349 = *base.add(0).cast::<*mut u8>(); - let l2350 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2351 = l2350; - let bytes2351 = _rt::Vec::from_raw_parts( - l2349.cast(), - len2351, - len2351, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2351), - } - }; - result2352.push(e2352); - } - _rt::cabi_dealloc( - base2352, - len2352 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2352 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2360::UnstructuredText(e2360) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2360 = { - let l2353 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2353 { - 0 => None, - 1 => { - let e = { - let l2354 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2355 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2359 = l2354; - let len2359 = l2355; - let mut result2359 = _rt::Vec::with_capacity(len2359); - for i in 0..len2359 { - let base = base2359 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2359 = { - let l2356 = *base.add(0).cast::<*mut u8>(); - let l2357 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2358 = l2357; - let bytes2358 = _rt::Vec::from_raw_parts( - l2356.cast(), - len2358, - len2358, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2358), - } - }; - result2359.push(e2359); - } - _rt::cabi_dealloc( - base2359, - len2359 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2359 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2360::UnstructuredBinary(e2360) - } - }; - (_rt::string_lift(bytes2293), v2360) - }; - result2361.push(e2361); - } - _rt::cabi_dealloc( - base2361, - len2361 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2361 - }; - V2435::Tuple(e2435) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2435 = { - let l2362 = *base - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2363 = *base - .add(40 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2434 = l2362; - let len2434 = l2363; - let mut result2434 = _rt::Vec::with_capacity(len2434); - for i in 0..len2434 { - let base = base2434 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2434 = { - let l2364 = *base.add(0).cast::<*mut u8>(); - let l2365 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2366 = l2365; - let bytes2366 = _rt::Vec::from_raw_parts( - l2364.cast(), - len2366, - len2366, - ); - let l2367 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::ElementSchema as V2433; - let v2433 = match l2367 { - 0 => { - let e2433 = { - let l2368 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2369 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2418 = l2368; - let len2418 = l2369; - let mut result2418 = _rt::Vec::with_capacity(len2418); - for i in 0..len2418 { - let base = base2418 - .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); - let e2418 = { - let l2370 = i32::from(*base.add(0).cast::()); - let l2374 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2378 = i32::from( - *base - .add(6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::core::types::WitTypeNode as V2417; - let v2417 = match l2378 { - 0 => { - let e2417 = { - let l2379 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2380 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2385 = l2379; - let len2385 = l2380; - let mut result2385 = _rt::Vec::with_capacity(len2385); - for i in 0..len2385 { - let base = base2385 - .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e2385 = { - let l2381 = *base.add(0).cast::<*mut u8>(); - let l2382 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2383 = l2382; - let bytes2383 = _rt::Vec::from_raw_parts( - l2381.cast(), - len2383, - len2383, - ); - let l2384 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - (_rt::string_lift(bytes2383), l2384) - }; - result2385.push(e2385); - } - _rt::cabi_dealloc( - base2385, - len2385 * (3 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2385 - }; - V2417::RecordType(e2417) - } - 1 => { - let e2417 = { - let l2386 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2387 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2393 = l2386; - let len2393 = l2387; - let mut result2393 = _rt::Vec::with_capacity(len2393); - for i in 0..len2393 { - let base = base2393 - .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e2393 = { - let l2388 = *base.add(0).cast::<*mut u8>(); - let l2389 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2390 = l2389; - let bytes2390 = _rt::Vec::from_raw_parts( - l2388.cast(), - len2390, - len2390, - ); - let l2391 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - _rt::string_lift(bytes2390), - match l2391 { - 0 => None, - 1 => { - let e = { - let l2392 = *base - .add(4 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2392 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - result2393.push(e2393); - } - _rt::cabi_dealloc( - base2393, - len2393 * (8 + 2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2393 - }; - V2417::VariantType(e2417) - } - 2 => { - let e2417 = { - let l2394 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2395 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2399 = l2394; - let len2399 = l2395; - let mut result2399 = _rt::Vec::with_capacity(len2399); - for i in 0..len2399 { - let base = base2399 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2399 = { - let l2396 = *base.add(0).cast::<*mut u8>(); - let l2397 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2398 = l2397; - let bytes2398 = _rt::Vec::from_raw_parts( - l2396.cast(), - len2398, - len2398, - ); - _rt::string_lift(bytes2398) - }; - result2399.push(e2399); - } - _rt::cabi_dealloc( - base2399, - len2399 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2399 - }; - V2417::EnumType(e2417) - } - 3 => { - let e2417 = { - let l2400 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2401 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2405 = l2400; - let len2405 = l2401; - let mut result2405 = _rt::Vec::with_capacity(len2405); - for i in 0..len2405 { - let base = base2405 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2405 = { - let l2402 = *base.add(0).cast::<*mut u8>(); - let l2403 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2404 = l2403; - let bytes2404 = _rt::Vec::from_raw_parts( - l2402.cast(), - len2404, - len2404, - ); - _rt::string_lift(bytes2404) - }; - result2405.push(e2405); - } - _rt::cabi_dealloc( - base2405, - len2405 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2405 - }; - V2417::FlagsType(e2417) - } - 4 => { - let e2417 = { - let l2406 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2407 = *base - .add(8 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2408 = l2407; - _rt::Vec::from_raw_parts(l2406.cast(), len2408, len2408) - }; - V2417::TupleType(e2417) - } - 5 => { - let e2417 = { - let l2409 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2409 - }; - V2417::ListType(e2417) - } - 6 => { - let e2417 = { - let l2410 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2410 - }; - V2417::OptionType(e2417) - } - 7 => { - let e2417 = { - let l2411 = i32::from( - *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2413 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - match l2411 { - 0 => None, - 1 => { - let e = { - let l2412 = *base - .add(12 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2412 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - match l2413 { - 0 => None, - 1 => { - let e = { - let l2414 = *base - .add(20 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2414 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V2417::ResultType(e2417) - } - 8 => V2417::PrimU8Type, - 9 => V2417::PrimU16Type, - 10 => V2417::PrimU32Type, - 11 => V2417::PrimU64Type, - 12 => V2417::PrimS8Type, - 13 => V2417::PrimS16Type, - 14 => V2417::PrimS32Type, - 15 => V2417::PrimS64Type, - 16 => V2417::PrimF32Type, - 17 => V2417::PrimF64Type, - 18 => V2417::PrimCharType, - 19 => V2417::PrimBoolType, - 20 => V2417::PrimStringType, - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e2417 = { - let l2415 = *base - .add(8 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2416 = i32::from( - *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - ( - l2415 as u64, - super::super::super::golem::core::types::ResourceMode::_lift( - l2416 as u8, - ), - ) - }; - V2417::HandleType(e2417) - } - }; - super::super::super::golem::core::types::NamedWitTypeNode { - name: match l2370 { - 0 => None, - 1 => { - let e = { - let l2371 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2372 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2373 = l2372; - let bytes2373 = _rt::Vec::from_raw_parts( - l2371.cast(), - len2373, - len2373, - ); - _rt::string_lift(bytes2373) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - owner: match l2374 { - 0 => None, - 1 => { - let e = { - let l2375 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2376 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2377 = l2376; - let bytes2377 = _rt::Vec::from_raw_parts( - l2375.cast(), - len2377, - len2377, - ); - _rt::string_lift(bytes2377) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - type_: v2417, - } - }; - result2418.push(e2418); - } - _rt::cabi_dealloc( - base2418, - len2418 * (24 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::golem::core::types::WitType { - nodes: result2418, - } - }; - V2433::ComponentModel(e2433) - } - 1 => { - let e2433 = { - let l2419 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::TextDescriptor { - restrictions: match l2419 { - 0 => None, - 1 => { - let e = { - let l2420 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2421 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2425 = l2420; - let len2425 = l2421; - let mut result2425 = _rt::Vec::with_capacity(len2425); - for i in 0..len2425 { - let base = base2425 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2425 = { - let l2422 = *base.add(0).cast::<*mut u8>(); - let l2423 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2424 = l2423; - let bytes2424 = _rt::Vec::from_raw_parts( - l2422.cast(), - len2424, - len2424, - ); - super::super::super::golem::core::types::TextType { - language_code: _rt::string_lift(bytes2424), - } - }; - result2425.push(e2425); - } - _rt::cabi_dealloc( - base2425, - len2425 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2425 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2433::UnstructuredText(e2433) - } - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - let e2433 = { - let l2426 = i32::from( - *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::golem::core::types::BinaryDescriptor { - restrictions: match l2426 { - 0 => None, - 1 => { - let e = { - let l2427 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2428 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2432 = l2427; - let len2432 = l2428; - let mut result2432 = _rt::Vec::with_capacity(len2432); - for i in 0..len2432 { - let base = base2432 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2432 = { - let l2429 = *base.add(0).cast::<*mut u8>(); - let l2430 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2431 = l2430; - let bytes2431 = _rt::Vec::from_raw_parts( - l2429.cast(), - len2431, - len2431, - ); - super::super::super::golem::core::types::BinaryType { - mime_type: _rt::string_lift(bytes2431), - } - }; - result2432.push(e2432); - } - _rt::cabi_dealloc( - base2432, - len2432 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2432 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V2433::UnstructuredBinary(e2433) - } - }; - (_rt::string_lift(bytes2366), v2433) - }; - result2434.push(e2434); - } - _rt::cabi_dealloc( - base2434, - len2434 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - result2434 - }; - V2435::Multimodal(e2435) - } - }; - let l2436 = *base - .add(40 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2437 = *base - .add(40 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2438 = l2437; - let bytes2438 = _rt::Vec::from_raw_parts( - l2436.cast(), - len2438, - len2438, - ); - let l2439 = *base - .add(40 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2440 = *base - .add(40 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2444 = l2439; - let len2444 = l2440; - let mut result2444 = _rt::Vec::with_capacity(len2444); - for i in 0..len2444 { - let base = base2444 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2444 = { - let l2441 = *base.add(0).cast::<*mut u8>(); - let l2442 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2443 = l2442; - let bytes2443 = _rt::Vec::from_raw_parts( - l2441.cast(), - len2443, - len2443, - ); - _rt::string_lift(bytes2443) - }; - result2444.push(e2444); - } - _rt::cabi_dealloc( - base2444, - len2444 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2445 = *base - .add(40 + 14 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2446 = *base - .add(40 + 15 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2478 = l2445; - let len2478 = l2446; - let mut result2478 = _rt::Vec::with_capacity(len2478); - for i in 0..len2478 { - let base = base2478 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e2478 = { - let l2447 = *base.add(0).cast::<*mut u8>(); - let l2448 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base2477 = l2447; - let len2477 = l2448; - let mut result2477 = _rt::Vec::with_capacity(len2477); - for i in 0..len2477 { - let base = base2477 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e2477 = { - let l2449 = i32::from(*base.add(0).cast::()); - let v2476 = match l2449 { - 0 => { - let e2476 = { - let l2450 = *base.add(8).cast::<*mut u8>(); - let l2451 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2452 = l2451; - let bytes2452 = _rt::Vec::from_raw_parts( - l2450.cast(), - len2452, - len2452, - ); - let l2453 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2454 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l2455 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2459 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2461 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2462 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2471 = l2461; - let len2471 = l2462; - let mut result2471 = _rt::Vec::with_capacity(len2471); - for i in 0..len2471 { - let base = base2471 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2471 = { - let l2463 = *base.add(0).cast::<*mut u8>(); - let l2464 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2465 = l2464; - let bytes2465 = _rt::Vec::from_raw_parts( - l2463.cast(), - len2465, - len2465, - ); - let l2466 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2470; - let v2470 = match l2466 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2470 = { - let l2467 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2468 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2469 = l2468; - let bytes2469 = _rt::Vec::from_raw_parts( - l2467.cast(), - len2469, - len2469, - ); - _rt::string_lift(bytes2469) - }; - V2470::String(e2470) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2465), - value: v2470, - } - }; - result2471.push(e2471); - } - _rt::cabi_dealloc( - base2471, - len2471 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l2472 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - LocalSpanData { - span_id: _rt::string_lift(bytes2452), - start: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2453 as u64, - nanoseconds: l2454 as u32, - }, - parent: match l2455 { - 0 => None, - 1 => { - let e = { - let l2456 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2457 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2458 = l2457; - let bytes2458 = _rt::Vec::from_raw_parts( - l2456.cast(), - len2458, - len2458, - ); - _rt::string_lift(bytes2458) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l2459 { - 0 => None, - 1 => { - let e = { - let l2460 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l2460 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2471, - inherited: _rt::bool_lift(l2472 as u8), - } - }; - SpanData::LocalSpan(e2476) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2476 = { - let l2473 = *base.add(8).cast::<*mut u8>(); - let l2474 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2475 = l2474; - let bytes2475 = _rt::Vec::from_raw_parts( - l2473.cast(), - len2475, - len2475, - ); - ExternalSpanData { - span_id: _rt::string_lift(bytes2475), - } - }; - SpanData::ExternalSpan(e2476) - } - }; - v2476 - }; - result2477.push(e2477); - } - _rt::cabi_dealloc( - base2477, - len2477 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2477 - }; - result2478.push(e2478); - } - _rt::cabi_dealloc( - base2478, - len2478 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - AgentMethodInvocationParameters { - idempotency_key: _rt::string_lift(bytes2127), - method_name: _rt::string_lift(bytes2130), - function_input: TypedDataValue { - value: v2287, - schema: v2435, - }, - trace_id: _rt::string_lift(bytes2438), - trace_states: result2444, - invocation_context: result2478, - } - }; - AgentInvocation::AgentMethodInvocation(e2489) - } - 2 => AgentInvocation::SaveSnapshot, - 3 => { - let e2489 = { - let l2479 = *base.add(40).cast::<*mut u8>(); - let l2480 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2481 = l2480; - let l2482 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2483 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2484 = l2483; - let bytes2484 = _rt::Vec::from_raw_parts( - l2482.cast(), - len2484, - len2484, - ); - LoadSnapshotParameters { - snapshot: super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2479.cast(), - len2481, - len2481, - ), - mime_type: _rt::string_lift(bytes2484), - }, - } - }; - AgentInvocation::LoadSnapshot(e2489) - } - 4 => { - let e2489 = { - let l2485 = *base.add(40).cast::<*mut u8>(); - let l2486 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2487 = l2486; - let bytes2487 = _rt::Vec::from_raw_parts( - l2485.cast(), - len2487, - len2487, - ); - ProcessOplogEntriesParameters { - idempotency_key: _rt::string_lift(bytes2487), - } - }; - AgentInvocation::ProcessOplogEntries(e2489) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e2489 = { - let l2488 = *base.add(40).cast::(); - ManualUpdateParameters { - target_revision: l2488 as u64, - } - }; - AgentInvocation::ManualUpdate(e2489) - } - }; - PendingAgentInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l1771 as u64, - nanoseconds: l1772 as u32, - }, - invocation: v2489, - } - }; - PublicOplogEntry::PendingAgentInvocation(e2676) - } - 16 => { - let e2676 = { - let l2490 = *base.add(16).cast::(); - let l2491 = *base.add(24).cast::(); - let l2492 = *base.add(32).cast::(); - let l2493 = i32::from(*base.add(40).cast::()); - let v2500 = match l2493 { - 0 => UpdateDescription::AutoUpdate, - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e2500 = { - let l2494 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2495 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2496 = l2495; - let l2497 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2498 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2499 = l2498; - let bytes2499 = _rt::Vec::from_raw_parts( - l2497.cast(), - len2499, - len2499, - ); - super::super::super::golem::api::host::Snapshot { - data: _rt::Vec::from_raw_parts( - l2494.cast(), - len2496, - len2496, - ), - mime_type: _rt::string_lift(bytes2499), - } - }; - UpdateDescription::SnapshotBased(e2500) - } - }; - PendingUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2490 as u64, - nanoseconds: l2491 as u32, - }, - target_revision: l2492 as u64, - update_description: v2500, - } - }; - PublicOplogEntry::PendingUpdate(e2676) - } - 17 => { - let e2676 = { - let l2501 = *base.add(16).cast::(); - let l2502 = *base.add(24).cast::(); - let l2503 = *base.add(32).cast::(); - let l2504 = *base.add(40).cast::(); - let l2505 = *base.add(48).cast::<*mut u8>(); - let l2506 = *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2522 = l2505; - let len2522 = l2506; - let mut result2522 = _rt::Vec::with_capacity(len2522); - for i in 0..len2522 { - let base = base2522 - .add(i * (6 * ::core::mem::size_of::<*const u8>())); - let e2522 = { - let l2507 = *base.add(0).cast::<*mut u8>(); - let l2508 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2509 = l2508; - let bytes2509 = _rt::Vec::from_raw_parts( - l2507.cast(), - len2509, - len2509, - ); - let l2510 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2511 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2512 = l2511; - let bytes2512 = _rt::Vec::from_raw_parts( - l2510.cast(), - len2512, - len2512, - ); - let l2513 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2514 = *base - .add(5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2521 = l2513; - let len2521 = l2514; - let mut result2521 = _rt::Vec::with_capacity(len2521); - for i in 0..len2521 { - let base = base2521 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2521 = { - let l2515 = *base.add(0).cast::<*mut u8>(); - let l2516 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2517 = l2516; - let bytes2517 = _rt::Vec::from_raw_parts( - l2515.cast(), - len2517, - len2517, - ); - let l2518 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2519 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2520 = l2519; - let bytes2520 = _rt::Vec::from_raw_parts( - l2518.cast(), - len2520, - len2520, - ); - (_rt::string_lift(bytes2517), _rt::string_lift(bytes2520)) - }; - result2521.push(e2521); - } - _rt::cabi_dealloc( - base2521, - len2521 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - PluginInstallationDescription { - name: _rt::string_lift(bytes2509), - version: _rt::string_lift(bytes2512), - parameters: result2521, - } - }; - result2522.push(e2522); - } - _rt::cabi_dealloc( - base2522, - len2522 * (6 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - SuccessfulUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2501 as u64, - nanoseconds: l2502 as u32, - }, - target_revision: l2503 as u64, - new_component_size: l2504 as u64, - new_active_plugins: result2522, - } - }; - PublicOplogEntry::SuccessfulUpdate(e2676) - } - 18 => { - let e2676 = { - let l2523 = *base.add(16).cast::(); - let l2524 = *base.add(24).cast::(); - let l2525 = *base.add(32).cast::(); - let l2526 = i32::from(*base.add(40).cast::()); - FailedUpdateParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2523 as u64, - nanoseconds: l2524 as u32, - }, - target_revision: l2525 as u64, - details: match l2526 { - 0 => None, - 1 => { - let e = { - let l2527 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2528 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2529 = l2528; - let bytes2529 = _rt::Vec::from_raw_parts( - l2527.cast(), - len2529, - len2529, - ); - _rt::string_lift(bytes2529) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - PublicOplogEntry::FailedUpdate(e2676) - } - 19 => { - let e2676 = { - let l2530 = *base.add(16).cast::(); - let l2531 = *base.add(24).cast::(); - let l2532 = *base.add(32).cast::(); - GrowMemoryParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2530 as u64, - nanoseconds: l2531 as u32, - }, - delta: l2532 as u64, - } - }; - PublicOplogEntry::GrowMemory(e2676) - } - 20 => { - let e2676 = { - let l2533 = *base.add(16).cast::(); - let l2534 = *base.add(24).cast::(); - let l2535 = *base.add(32).cast::(); - let l2536 = *base.add(40).cast::<*mut u8>(); - let l2537 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2538 = l2537; - let bytes2538 = _rt::Vec::from_raw_parts( - l2536.cast(), - len2538, - len2538, - ); - let l2539 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2540 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2541 = l2540; - let bytes2541 = _rt::Vec::from_raw_parts( - l2539.cast(), - len2541, - len2541, - ); - CreateResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2533 as u64, - nanoseconds: l2534 as u32, - }, - resource_id: l2535 as u64, - name: _rt::string_lift(bytes2538), - owner: _rt::string_lift(bytes2541), - } - }; - PublicOplogEntry::CreateResource(e2676) - } - 21 => { - let e2676 = { - let l2542 = *base.add(16).cast::(); - let l2543 = *base.add(24).cast::(); - let l2544 = *base.add(32).cast::(); - let l2545 = *base.add(40).cast::<*mut u8>(); - let l2546 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2547 = l2546; - let bytes2547 = _rt::Vec::from_raw_parts( - l2545.cast(), - len2547, - len2547, - ); - let l2548 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2549 = *base - .add(40 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2550 = l2549; - let bytes2550 = _rt::Vec::from_raw_parts( - l2548.cast(), - len2550, - len2550, - ); - DropResourceParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2542 as u64, - nanoseconds: l2543 as u32, - }, - resource_id: l2544 as u64, - name: _rt::string_lift(bytes2547), - owner: _rt::string_lift(bytes2550), - } - }; - PublicOplogEntry::DropResource(e2676) - } - 22 => { - let e2676 = { - let l2551 = *base.add(16).cast::(); - let l2552 = *base.add(24).cast::(); - let l2553 = i32::from(*base.add(32).cast::()); - let l2554 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2555 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2556 = l2555; - let bytes2556 = _rt::Vec::from_raw_parts( - l2554.cast(), - len2556, - len2556, - ); - let l2557 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2558 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2559 = l2558; - let bytes2559 = _rt::Vec::from_raw_parts( - l2557.cast(), - len2559, - len2559, - ); - LogParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2551 as u64, - nanoseconds: l2552 as u32, - }, - level: LogLevel::_lift(l2553 as u8), - context: _rt::string_lift(bytes2556), - message: _rt::string_lift(bytes2559), - } - }; - PublicOplogEntry::Log(e2676) - } - 23 => { - let e2676 = { - let l2560 = *base.add(16).cast::(); - let l2561 = *base.add(24).cast::(); - Timestamp { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2560 as u64, - nanoseconds: l2561 as u32, - }, - } - }; - PublicOplogEntry::Restart(e2676) - } - 24 => { - let e2676 = { - let l2562 = *base.add(16).cast::(); - let l2563 = *base.add(24).cast::(); - let l2564 = *base.add(32).cast::<*mut u8>(); - let l2565 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2566 = l2565; - let bytes2566 = _rt::Vec::from_raw_parts( - l2564.cast(), - len2566, - len2566, - ); - let l2567 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2568 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2569 = l2568; - let bytes2569 = _rt::Vec::from_raw_parts( - l2567.cast(), - len2569, - len2569, - ); - let l2570 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2571 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2578 = l2570; - let len2578 = l2571; - let mut result2578 = _rt::Vec::with_capacity(len2578); - for i in 0..len2578 { - let base = base2578 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2578 = { - let l2572 = *base.add(0).cast::<*mut u8>(); - let l2573 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2574 = l2573; - let bytes2574 = _rt::Vec::from_raw_parts( - l2572.cast(), - len2574, - len2574, - ); - let l2575 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2576 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2577 = l2576; - let bytes2577 = _rt::Vec::from_raw_parts( - l2575.cast(), - len2577, - len2577, - ); - (_rt::string_lift(bytes2574), _rt::string_lift(bytes2577)) - }; - result2578.push(e2578); - } - _rt::cabi_dealloc( - base2578, - len2578 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - ActivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2562 as u64, - nanoseconds: l2563 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2566), - version: _rt::string_lift(bytes2569), - parameters: result2578, - }, - } - }; - PublicOplogEntry::ActivatePlugin(e2676) - } - 25 => { - let e2676 = { - let l2579 = *base.add(16).cast::(); - let l2580 = *base.add(24).cast::(); - let l2581 = *base.add(32).cast::<*mut u8>(); - let l2582 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2583 = l2582; - let bytes2583 = _rt::Vec::from_raw_parts( - l2581.cast(), - len2583, - len2583, - ); - let l2584 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2585 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2586 = l2585; - let bytes2586 = _rt::Vec::from_raw_parts( - l2584.cast(), - len2586, - len2586, - ); - let l2587 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2588 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2595 = l2587; - let len2595 = l2588; - let mut result2595 = _rt::Vec::with_capacity(len2595); - for i in 0..len2595 { - let base = base2595 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e2595 = { - let l2589 = *base.add(0).cast::<*mut u8>(); - let l2590 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2591 = l2590; - let bytes2591 = _rt::Vec::from_raw_parts( - l2589.cast(), - len2591, - len2591, - ); - let l2592 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2593 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2594 = l2593; - let bytes2594 = _rt::Vec::from_raw_parts( - l2592.cast(), - len2594, - len2594, - ); - (_rt::string_lift(bytes2591), _rt::string_lift(bytes2594)) - }; - result2595.push(e2595); - } - _rt::cabi_dealloc( - base2595, - len2595 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - DeactivatePluginParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2579 as u64, - nanoseconds: l2580 as u32, - }, - plugin: PluginInstallationDescription { - name: _rt::string_lift(bytes2583), - version: _rt::string_lift(bytes2586), - parameters: result2595, - }, - } - }; - PublicOplogEntry::DeactivatePlugin(e2676) - } - 26 => { - let e2676 = { - let l2596 = *base.add(16).cast::(); - let l2597 = *base.add(24).cast::(); - let l2598 = *base.add(32).cast::(); - let l2599 = *base.add(40).cast::(); - RevertParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2596 as u64, - nanoseconds: l2597 as u32, - }, - dropped_region: OplogRegion { - start: l2598 as u64, - end: l2599 as u64, - }, - } - }; - PublicOplogEntry::Revert(e2676) - } - 27 => { - let e2676 = { - let l2600 = *base.add(16).cast::(); - let l2601 = *base.add(24).cast::(); - let l2602 = *base.add(32).cast::<*mut u8>(); - let l2603 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2604 = l2603; - let bytes2604 = _rt::Vec::from_raw_parts( - l2602.cast(), - len2604, - len2604, - ); - CancelPendingInvocationParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2600 as u64, - nanoseconds: l2601 as u32, - }, - idempotency_key: _rt::string_lift(bytes2604), - } - }; - PublicOplogEntry::CancelPendingInvocation(e2676) - } - 28 => { - let e2676 = { - let l2605 = *base.add(16).cast::(); - let l2606 = *base.add(24).cast::(); - let l2607 = *base.add(32).cast::<*mut u8>(); - let l2608 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2609 = l2608; - let bytes2609 = _rt::Vec::from_raw_parts( - l2607.cast(), - len2609, - len2609, - ); - let l2610 = i32::from( - *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2614 = i32::from( - *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l2618 = *base - .add(32 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2619 = *base - .add(32 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base2628 = l2618; - let len2628 = l2619; - let mut result2628 = _rt::Vec::with_capacity(len2628); - for i in 0..len2628 { - let base = base2628 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e2628 = { - let l2620 = *base.add(0).cast::<*mut u8>(); - let l2621 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len2622 = l2621; - let bytes2622 = _rt::Vec::from_raw_parts( - l2620.cast(), - len2622, - len2622, - ); - let l2623 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2627; - let v2627 = match l2623 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2627 = { - let l2624 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2625 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2626 = l2625; - let bytes2626 = _rt::Vec::from_raw_parts( - l2624.cast(), - len2626, - len2626, - ); - _rt::string_lift(bytes2626) - }; - V2627::String(e2627) - } - }; - super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes2622), - value: v2627, - } - }; - result2628.push(e2628); - } - _rt::cabi_dealloc( - base2628, - len2628 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - StartSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2605 as u64, - nanoseconds: l2606 as u32, - }, - span_id: _rt::string_lift(bytes2609), - parent: match l2610 { - 0 => None, - 1 => { - let e = { - let l2611 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2612 = *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2613 = l2612; - let bytes2613 = _rt::Vec::from_raw_parts( - l2611.cast(), - len2613, - len2613, - ); - _rt::string_lift(bytes2613) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context_id: match l2614 { - 0 => None, - 1 => { - let e = { - let l2615 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2616 = *base - .add(32 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2617 = l2616; - let bytes2617 = _rt::Vec::from_raw_parts( - l2615.cast(), - len2617, - len2617, - ); - _rt::string_lift(bytes2617) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result2628, - } - }; - PublicOplogEntry::StartSpan(e2676) - } - 29 => { - let e2676 = { - let l2629 = *base.add(16).cast::(); - let l2630 = *base.add(24).cast::(); - let l2631 = *base.add(32).cast::<*mut u8>(); - let l2632 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2633 = l2632; - let bytes2633 = _rt::Vec::from_raw_parts( - l2631.cast(), - len2633, - len2633, - ); - FinishSpanParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2629 as u64, - nanoseconds: l2630 as u32, - }, - span_id: _rt::string_lift(bytes2633), - } - }; - PublicOplogEntry::FinishSpan(e2676) - } - 30 => { - let e2676 = { - let l2634 = *base.add(16).cast::(); - let l2635 = *base.add(24).cast::(); - let l2636 = *base.add(32).cast::<*mut u8>(); - let l2637 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2638 = l2637; - let bytes2638 = _rt::Vec::from_raw_parts( - l2636.cast(), - len2638, - len2638, - ); - let l2639 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2640 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2641 = l2640; - let bytes2641 = _rt::Vec::from_raw_parts( - l2639.cast(), - len2641, - len2641, - ); - let l2642 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::golem::api::context::AttributeValue as V2646; - let v2646 = match l2642 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e2646 = { - let l2643 = *base - .add(32 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2644 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2645 = l2644; - let bytes2645 = _rt::Vec::from_raw_parts( - l2643.cast(), - len2645, - len2645, - ); - _rt::string_lift(bytes2645) - }; - V2646::String(e2646) - } - }; - SetSpanAttributeParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2634 as u64, - nanoseconds: l2635 as u32, - }, - span_id: _rt::string_lift(bytes2638), - key: _rt::string_lift(bytes2641), - value: v2646, - } - }; - PublicOplogEntry::SetSpanAttribute(e2676) - } - 31 => { - let e2676 = { - let l2647 = *base.add(16).cast::(); - let l2648 = *base.add(24).cast::(); - let l2649 = i32::from(*base.add(32).cast::()); - use super::super::super::golem::api::host::PersistenceLevel as V2650; - let v2650 = match l2649 { - 0 => V2650::PersistNothing, - 1 => V2650::PersistRemoteSideEffects, - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - V2650::Smart - } - }; - ChangePersistenceLevelParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2647 as u64, - nanoseconds: l2648 as u32, - }, - persistence_level: v2650, - } - }; - PublicOplogEntry::ChangePersistenceLevel(e2676) - } - 32 => { - let e2676 = { - let l2651 = *base.add(16).cast::(); - let l2652 = *base.add(24).cast::(); - let l2653 = *base.add(32).cast::<*mut u8>(); - let l2654 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2655 = l2654; - let bytes2655 = _rt::Vec::from_raw_parts( - l2653.cast(), - len2655, - len2655, - ); - BeginRemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2651 as u64, - nanoseconds: l2652 as u32, - }, - transaction_id: _rt::string_lift(bytes2655), - } - }; - PublicOplogEntry::BeginRemoteTransaction(e2676) - } - 33 => { - let e2676 = { - let l2656 = *base.add(16).cast::(); - let l2657 = *base.add(24).cast::(); - let l2658 = *base.add(32).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2656 as u64, - nanoseconds: l2657 as u32, - }, - begin_index: l2658 as u64, - } - }; - PublicOplogEntry::PreCommitRemoteTransaction(e2676) - } - 34 => { - let e2676 = { - let l2659 = *base.add(16).cast::(); - let l2660 = *base.add(24).cast::(); - let l2661 = *base.add(32).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2659 as u64, - nanoseconds: l2660 as u32, - }, - begin_index: l2661 as u64, - } - }; - PublicOplogEntry::PreRollbackRemoteTransaction(e2676) - } - 35 => { - let e2676 = { - let l2662 = *base.add(16).cast::(); - let l2663 = *base.add(24).cast::(); - let l2664 = *base.add(32).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2662 as u64, - nanoseconds: l2663 as u32, - }, - begin_index: l2664 as u64, - } - }; - PublicOplogEntry::CommittedRemoteTransaction(e2676) - } - 36 => { - let e2676 = { - let l2665 = *base.add(16).cast::(); - let l2666 = *base.add(24).cast::(); - let l2667 = *base.add(32).cast::(); - RemoteTransactionParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2665 as u64, - nanoseconds: l2666 as u32, - }, - begin_index: l2667 as u64, - } - }; - PublicOplogEntry::RolledBackRemoteTransaction(e2676) - } - n => { - debug_assert_eq!(n, 37, "invalid enum discriminant"); - let e2676 = { - let l2668 = *base.add(16).cast::(); - let l2669 = *base.add(24).cast::(); - let l2670 = *base.add(32).cast::<*mut u8>(); - let l2671 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2672 = l2671; - let l2673 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2674 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len2675 = l2674; - let bytes2675 = _rt::Vec::from_raw_parts( - l2673.cast(), - len2675, - len2675, - ); - SnapshotParameters { - timestamp: super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l2668 as u64, - nanoseconds: l2669 as u32, - }, - data: _rt::Vec::from_raw_parts( - l2670.cast(), - len2672, - len2672, - ), - mime_type: _rt::string_lift(bytes2675), - } - }; - PublicOplogEntry::Snapshot(e2676) - } - }; - (l5 as u64, v2676) - }; - result2677.push(e2677); - } - _rt::cabi_dealloc( - base2677, - len2677 * (128 + 14 * ::core::mem::size_of::<*const u8>()), - 8, - ); - result2677 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result2678 - } - } - } - } - } - pub mod core { - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod types { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - /// UUID - #[repr(C)] - #[derive(Clone, Copy)] - pub struct Uuid { - pub high_bits: u64, - pub low_bits: u64, - } - impl ::core::fmt::Debug for Uuid { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Uuid") - .field("high-bits", &self.high_bits) - .field("low-bits", &self.low_bits) - .finish() - } - } - /// Represents a Golem component - #[repr(C)] - #[derive(Clone, Copy)] - pub struct ComponentId { - pub uuid: Uuid, - } - impl ::core::fmt::Debug for ComponentId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ComponentId").field("uuid", &self.uuid).finish() - } - } - /// Represents a Golem agent - #[derive(Clone)] - pub struct AgentId { - /// Identifies the component the agent belongs to - pub component_id: ComponentId, - /// String representation of the agent ID (agent type and constructor parameters) - pub agent_id: _rt::String, - } - impl ::core::fmt::Debug for AgentId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AgentId") - .field("component-id", &self.component_id) - .field("agent-id", &self.agent_id) - .finish() - } - } - /// Represents a Golem account - #[repr(C)] - #[derive(Clone, Copy)] - pub struct AccountId { - pub uuid: Uuid, - } - impl ::core::fmt::Debug for AccountId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AccountId").field("uuid", &self.uuid).finish() - } - } - /// An index into the persistent log storing all performed operations of an agent - pub type OplogIndex = u64; - /// A promise ID is a value that can be passed to an external Golem API to complete that promise - /// from an arbitrary external source, while Golem agents can await for this completion. - #[derive(Clone)] - pub struct PromiseId { - pub agent_id: AgentId, - pub oplog_idx: OplogIndex, - } - impl ::core::fmt::Debug for PromiseId { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("PromiseId") - .field("agent-id", &self.agent_id) - .field("oplog-idx", &self.oplog_idx) - .finish() - } - } - /// The index type used in `wit-value` and `wit-type` to identify nodes - pub type NodeIndex = i32; - /// Represents a WIT resource in an instance - pub type ResourceId = u64; - /// Resource handle modes - #[repr(u8)] - #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] - pub enum ResourceMode { - /// The resource is owned by this handle - Owned, - /// The resource is owned by someone else, and this handle is just a borrow - Borrowed, - } - impl ::core::fmt::Debug for ResourceMode { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - ResourceMode::Owned => { - f.debug_tuple("ResourceMode::Owned").finish() - } - ResourceMode::Borrowed => { - f.debug_tuple("ResourceMode::Borrowed").finish() - } - } - } - } - impl ResourceMode { - #[doc(hidden)] - pub unsafe fn _lift(val: u8) -> ResourceMode { - if !cfg!(debug_assertions) { - return ::core::mem::transmute(val); - } - match val { - 0 => ResourceMode::Owned, - 1 => ResourceMode::Borrowed, - _ => panic!("invalid enum discriminant"), - } - } - } - /// Represents a type within a `wit-type` definition. `node-index` values are indices into the - /// parent `wit-type`'s `nodes` list. - #[derive(Clone)] - pub enum WitTypeNode { - /// Record type, defined by a list of name-type pairs. - RecordType(_rt::Vec<(_rt::String, NodeIndex)>), - /// Variant type, defined by a list of name-type pairs. The type is optional, in case it is not defined, the case - /// is a unit case. - VariantType(_rt::Vec<(_rt::String, Option)>), - /// Enum type, defined by a list of its cases. - EnumType(_rt::Vec<_rt::String>), - /// Flags type, defined by a list of its flags. - FlagsType(_rt::Vec<_rt::String>), - /// Tuple type, defined by a list of its field's types. - TupleType(_rt::Vec), - /// List type, defined by the element type - ListType(NodeIndex), - /// Option type, defined by the element type - OptionType(NodeIndex), - /// Result type, defined by the success and error types. Both types are optional, in case they are not defined, the - /// ok or error case is a unit case. - ResultType((Option, Option)), - /// Unsigned 8-bit integer - PrimU8Type, - /// Unsigned 16-bit integer - PrimU16Type, - /// Unsigned 32-bit integer - PrimU32Type, - /// Unsigned 64-bit integer - PrimU64Type, - /// Signed 8-bit integer - PrimS8Type, - /// Signed 16-bit integer - PrimS16Type, - /// Signed 32-bit integer - PrimS32Type, - /// Signed 64-bit integer - PrimS64Type, - /// 32-bit floating point number - PrimF32Type, - /// 64-bit floating point number - PrimF64Type, - /// Unicode character - PrimCharType, - /// Boolean value - PrimBoolType, - /// String value - PrimStringType, - /// Handle type, defined by a resource ID and borrowing mode - HandleType((ResourceId, ResourceMode)), - } - impl ::core::fmt::Debug for WitTypeNode { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - WitTypeNode::RecordType(e) => { - f.debug_tuple("WitTypeNode::RecordType").field(e).finish() - } - WitTypeNode::VariantType(e) => { - f.debug_tuple("WitTypeNode::VariantType").field(e).finish() - } - WitTypeNode::EnumType(e) => { - f.debug_tuple("WitTypeNode::EnumType").field(e).finish() - } - WitTypeNode::FlagsType(e) => { - f.debug_tuple("WitTypeNode::FlagsType").field(e).finish() - } - WitTypeNode::TupleType(e) => { - f.debug_tuple("WitTypeNode::TupleType").field(e).finish() - } - WitTypeNode::ListType(e) => { - f.debug_tuple("WitTypeNode::ListType").field(e).finish() - } - WitTypeNode::OptionType(e) => { - f.debug_tuple("WitTypeNode::OptionType").field(e).finish() - } - WitTypeNode::ResultType(e) => { - f.debug_tuple("WitTypeNode::ResultType").field(e).finish() - } - WitTypeNode::PrimU8Type => { - f.debug_tuple("WitTypeNode::PrimU8Type").finish() - } - WitTypeNode::PrimU16Type => { - f.debug_tuple("WitTypeNode::PrimU16Type").finish() - } - WitTypeNode::PrimU32Type => { - f.debug_tuple("WitTypeNode::PrimU32Type").finish() - } - WitTypeNode::PrimU64Type => { - f.debug_tuple("WitTypeNode::PrimU64Type").finish() - } - WitTypeNode::PrimS8Type => { - f.debug_tuple("WitTypeNode::PrimS8Type").finish() - } - WitTypeNode::PrimS16Type => { - f.debug_tuple("WitTypeNode::PrimS16Type").finish() - } - WitTypeNode::PrimS32Type => { - f.debug_tuple("WitTypeNode::PrimS32Type").finish() - } - WitTypeNode::PrimS64Type => { - f.debug_tuple("WitTypeNode::PrimS64Type").finish() - } - WitTypeNode::PrimF32Type => { - f.debug_tuple("WitTypeNode::PrimF32Type").finish() - } - WitTypeNode::PrimF64Type => { - f.debug_tuple("WitTypeNode::PrimF64Type").finish() - } - WitTypeNode::PrimCharType => { - f.debug_tuple("WitTypeNode::PrimCharType").finish() - } - WitTypeNode::PrimBoolType => { - f.debug_tuple("WitTypeNode::PrimBoolType").finish() - } - WitTypeNode::PrimStringType => { - f.debug_tuple("WitTypeNode::PrimStringType").finish() - } - WitTypeNode::HandleType(e) => { - f.debug_tuple("WitTypeNode::HandleType").field(e).finish() - } - } - } - } - /// Represents a node of `wit-type`, with attached metadata - #[derive(Clone)] - pub struct NamedWitTypeNode { - /// Name of the type - pub name: Option<_rt::String>, - /// Owner of the type (usually pointing to a WIT package and interface) - pub owner: Option<_rt::String>, - /// The node representing a type - pub type_: WitTypeNode, - } - impl ::core::fmt::Debug for NamedWitTypeNode { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("NamedWitTypeNode") - .field("name", &self.name) - .field("owner", &self.owner) - .field("type", &self.type_) - .finish() - } - } - /// Describes a type of a `wit-value` - #[derive(Clone)] - pub struct WitType { - /// The nodes consisting of the type definition. Because WIT does not support recursive types, the nodes are represented as a list of named nodes. - /// The list is always non-empty, and the first item is the root node. - pub nodes: _rt::Vec, - } - impl ::core::fmt::Debug for WitType { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("WitType").field("nodes", &self.nodes).finish() - } - } - /// URI value - #[derive(Clone)] - pub struct Uri { - pub value: _rt::String, - } - impl ::core::fmt::Debug for Uri { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Uri").field("value", &self.value).finish() - } - } - /// One node of a `wit-value` - #[derive(Clone)] - pub enum WitNode { - /// A record value defined by a list of its field values - RecordValue(_rt::Vec), - /// A variant value defined by a pair of the case index and its inner value - VariantValue((u32, Option)), - /// An enum value defined by a case index - EnumValue(u32), - /// A flags value defined by a list of its flag states - FlagsValue(_rt::Vec), - /// A tuple value defined by a list of its item values - TupleValue(_rt::Vec), - /// A list value defined by a list of its item values - ListValue(_rt::Vec), - /// An option value defined by an optional inner value - OptionValue(Option), - /// A result value defined by either an ok value or an error value. Both values are optional, - /// where the `none` case represents the absence of a value. - ResultValue(Result, Option>), - /// Primitive unsigned 8-bit integer - PrimU8(u8), - /// Primitive unsigned 16-bit integer - PrimU16(u16), - /// Primitive unsigned 32-bit integer - PrimU32(u32), - /// Primitive unsigned 64-bit integer - PrimU64(u64), - /// Primitive signed 8-bit integer - PrimS8(i8), - /// Primitive signed 16-bit integer - PrimS16(i16), - /// Primitive signed 32-bit integer - PrimS32(i32), - /// Primitive signed 64-bit integer - PrimS64(i64), - /// Primitive 32-bit floating point number - PrimFloat32(f32), - /// Primitive 64-bit floating point number - PrimFloat64(f64), - /// Primitive character - PrimChar(char), - /// Primitive boolean - PrimBool(bool), - /// Primitive string - PrimString(_rt::String), - /// Resource handle pointing to a URI and a resource ID - Handle((Uri, u64)), - } - impl ::core::fmt::Debug for WitNode { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - WitNode::RecordValue(e) => { - f.debug_tuple("WitNode::RecordValue").field(e).finish() - } - WitNode::VariantValue(e) => { - f.debug_tuple("WitNode::VariantValue").field(e).finish() - } - WitNode::EnumValue(e) => { - f.debug_tuple("WitNode::EnumValue").field(e).finish() - } - WitNode::FlagsValue(e) => { - f.debug_tuple("WitNode::FlagsValue").field(e).finish() - } - WitNode::TupleValue(e) => { - f.debug_tuple("WitNode::TupleValue").field(e).finish() - } - WitNode::ListValue(e) => { - f.debug_tuple("WitNode::ListValue").field(e).finish() - } - WitNode::OptionValue(e) => { - f.debug_tuple("WitNode::OptionValue").field(e).finish() - } - WitNode::ResultValue(e) => { - f.debug_tuple("WitNode::ResultValue").field(e).finish() - } - WitNode::PrimU8(e) => { - f.debug_tuple("WitNode::PrimU8").field(e).finish() - } - WitNode::PrimU16(e) => { - f.debug_tuple("WitNode::PrimU16").field(e).finish() - } - WitNode::PrimU32(e) => { - f.debug_tuple("WitNode::PrimU32").field(e).finish() - } - WitNode::PrimU64(e) => { - f.debug_tuple("WitNode::PrimU64").field(e).finish() - } - WitNode::PrimS8(e) => { - f.debug_tuple("WitNode::PrimS8").field(e).finish() - } - WitNode::PrimS16(e) => { - f.debug_tuple("WitNode::PrimS16").field(e).finish() - } - WitNode::PrimS32(e) => { - f.debug_tuple("WitNode::PrimS32").field(e).finish() - } - WitNode::PrimS64(e) => { - f.debug_tuple("WitNode::PrimS64").field(e).finish() - } - WitNode::PrimFloat32(e) => { - f.debug_tuple("WitNode::PrimFloat32").field(e).finish() - } - WitNode::PrimFloat64(e) => { - f.debug_tuple("WitNode::PrimFloat64").field(e).finish() - } - WitNode::PrimChar(e) => { - f.debug_tuple("WitNode::PrimChar").field(e).finish() - } - WitNode::PrimBool(e) => { - f.debug_tuple("WitNode::PrimBool").field(e).finish() - } - WitNode::PrimString(e) => { - f.debug_tuple("WitNode::PrimString").field(e).finish() - } - WitNode::Handle(e) => { - f.debug_tuple("WitNode::Handle").field(e).finish() - } - } - } - } - /// Describes an arbitrary value - #[derive(Clone)] - pub struct WitValue { - /// The list of `wit-node` values that make up the value. The list is always non-empty, - /// and the first element is the root node describing the value. Because WIT does not support - /// recursive types, further nodes are pushed into this list, and referenced by index from their parent node. - pub nodes: _rt::Vec, - } - impl ::core::fmt::Debug for WitValue { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("WitValue").field("nodes", &self.nodes).finish() - } - } - /// A value and its type - #[derive(Clone)] - pub struct ValueAndType { - /// Value - pub value: WitValue, - /// Type of `value` - pub typ: WitType, - } - impl ::core::fmt::Debug for ValueAndType { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("ValueAndType") - .field("value", &self.value) - .field("typ", &self.typ) - .finish() - } - } - /// URL alias - pub type Url = _rt::String; - /// Text type descriptor - #[derive(Clone)] - pub struct TextType { - pub language_code: _rt::String, - } - impl ::core::fmt::Debug for TextType { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("TextType") - .field("language-code", &self.language_code) - .finish() - } - } - /// Inline text source - #[derive(Clone)] - pub struct TextSource { - pub data: _rt::String, - pub text_type: Option, - } - impl ::core::fmt::Debug for TextSource { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("TextSource") - .field("data", &self.data) - .field("text-type", &self.text_type) - .finish() - } - } - /// Reference to a text value - #[derive(Clone)] - pub enum TextReference { - Url(_rt::String), - Inline(TextSource), - } - impl ::core::fmt::Debug for TextReference { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - TextReference::Url(e) => { - f.debug_tuple("TextReference::Url").field(e).finish() - } - TextReference::Inline(e) => { - f.debug_tuple("TextReference::Inline").field(e).finish() - } - } - } - } - /// Binary type descriptor - #[derive(Clone)] - pub struct BinaryType { - pub mime_type: _rt::String, - } - impl ::core::fmt::Debug for BinaryType { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("BinaryType") - .field("mime-type", &self.mime_type) - .finish() - } - } - /// Inline binary source - #[derive(Clone)] - pub struct BinarySource { - pub data: _rt::Vec, - pub binary_type: BinaryType, - } - impl ::core::fmt::Debug for BinarySource { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("BinarySource") - .field("data", &self.data) - .field("binary-type", &self.binary_type) - .finish() - } - } - /// Reference to a binary value - #[derive(Clone)] - pub enum BinaryReference { - Url(Url), - Inline(BinarySource), - } - impl ::core::fmt::Debug for BinaryReference { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - BinaryReference::Url(e) => { - f.debug_tuple("BinaryReference::Url").field(e).finish() - } - BinaryReference::Inline(e) => { - f.debug_tuple("BinaryReference::Inline").field(e).finish() - } - } - } - } - /// Descriptor for text-type element schemas - #[derive(Clone)] - pub struct TextDescriptor { - pub restrictions: Option<_rt::Vec>, - } - impl ::core::fmt::Debug for TextDescriptor { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("TextDescriptor") - .field("restrictions", &self.restrictions) - .finish() - } - } - /// Descriptor for binary-type element schemas - #[derive(Clone)] - pub struct BinaryDescriptor { - pub restrictions: Option<_rt::Vec>, - } - impl ::core::fmt::Debug for BinaryDescriptor { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("BinaryDescriptor") - .field("restrictions", &self.restrictions) - .finish() - } - } - /// Schema for a single element within a data-schema - #[derive(Clone)] - pub enum ElementSchema { - ComponentModel(WitType), - UnstructuredText(TextDescriptor), - UnstructuredBinary(BinaryDescriptor), - } - impl ::core::fmt::Debug for ElementSchema { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - ElementSchema::ComponentModel(e) => { - f.debug_tuple("ElementSchema::ComponentModel") - .field(e) - .finish() - } - ElementSchema::UnstructuredText(e) => { - f.debug_tuple("ElementSchema::UnstructuredText") - .field(e) - .finish() - } - ElementSchema::UnstructuredBinary(e) => { - f.debug_tuple("ElementSchema::UnstructuredBinary") - .field(e) - .finish() - } - } - } - } - /// Value of a single element within a data-value - #[derive(Clone)] - pub enum ElementValue { - ComponentModel(WitValue), - UnstructuredText(TextReference), - UnstructuredBinary(BinaryReference), - } - impl ::core::fmt::Debug for ElementValue { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - ElementValue::ComponentModel(e) => { - f.debug_tuple("ElementValue::ComponentModel") - .field(e) - .finish() - } - ElementValue::UnstructuredText(e) => { - f.debug_tuple("ElementValue::UnstructuredText") - .field(e) - .finish() - } - ElementValue::UnstructuredBinary(e) => { - f.debug_tuple("ElementValue::UnstructuredBinary") - .field(e) - .finish() - } - } - } - } - /// Schema describing the structure of a data-value - #[derive(Clone)] - pub enum DataSchema { - /// List of named elements - Tuple(_rt::Vec<(_rt::String, ElementSchema)>), - /// List of named variants that can be used 0 or more times in a multimodal data-value - Multimodal(_rt::Vec<(_rt::String, ElementSchema)>), - } - impl ::core::fmt::Debug for DataSchema { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - DataSchema::Tuple(e) => { - f.debug_tuple("DataSchema::Tuple").field(e).finish() - } - DataSchema::Multimodal(e) => { - f.debug_tuple("DataSchema::Multimodal").field(e).finish() - } - } - } - } - /// A structured value consisting of typed elements - #[derive(Clone)] - pub enum DataValue { - /// List of element values, each corresponding to an element of the tuple data-schema - Tuple(_rt::Vec), - /// List of element values and their schema names; each name points to one named element of the corresponding - /// multimodal data-schema. - Multimodal(_rt::Vec<(_rt::String, ElementValue)>), - } - impl ::core::fmt::Debug for DataValue { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - match self { - DataValue::Tuple(e) => { - f.debug_tuple("DataValue::Tuple").field(e).finish() - } - DataValue::Multimodal(e) => { - f.debug_tuple("DataValue::Multimodal").field(e).finish() - } - } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Parses a UUID from a string - pub fn parse_uuid(uuid: &str) -> Result { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 24]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); - let vec0 = uuid; - let ptr0 = vec0.as_ptr().cast::(); - let len0 = vec0.len(); - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:core/types@1.5.0")] - unsafe extern "C" { - #[link_name = "parse-uuid"] - fn wit_import2(_: *mut u8, _: usize, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8) { - unreachable!() - } - unsafe { wit_import2(ptr0.cast_mut(), len0, ptr1) }; - let l3 = i32::from(*ptr1.add(0).cast::()); - let result9 = match l3 { - 0 => { - let e = { - let l4 = *ptr1.add(8).cast::(); - let l5 = *ptr1.add(16).cast::(); - Uuid { - high_bits: l4 as u64, - low_bits: l5 as u64, - } - }; - Ok(e) - } - 1 => { - let e = { - let l6 = *ptr1.add(8).cast::<*mut u8>(); - let l7 = *ptr1 - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len8 = l7; - let bytes8 = _rt::Vec::from_raw_parts( - l6.cast(), - len8, - len8, - ); - _rt::string_lift(bytes8) - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - }; - result9 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Converts a UUID to a string - pub fn uuid_to_string(uuid: Uuid) -> _rt::String { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let Uuid { high_bits: high_bits0, low_bits: low_bits0 } = uuid; - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "golem:core/types@1.5.0")] - unsafe extern "C" { - #[link_name = "uuid-to-string"] - fn wit_import2(_: i64, _: i64, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2(_: i64, _: i64, _: *mut u8) { - unreachable!() - } - unsafe { - wit_import2( - _rt::as_i64(high_bits0), - _rt::as_i64(low_bits0), - ptr1, - ) - }; - let l3 = *ptr1.add(0).cast::<*mut u8>(); - let l4 = *ptr1 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len5 = l4; - let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); - let result6 = _rt::string_lift(bytes5); - result6 - } - } - } - } -} -#[rustfmt::skip] -#[allow(dead_code, clippy::all)] -pub mod wasi { - pub mod clocks { - /// WASI Wall Clock is a clock API intended to let users query the current - /// time. The name "wall" makes an analogy to a "clock on the wall", which - /// is not necessarily monotonic as it may be reset. - /// - /// It is intended to be portable at least between Unix-family platforms and - /// Windows. - /// - /// A wall clock is a clock which measures the date and time according to - /// some external reference. - /// - /// External references may be reset, so this clock is not necessarily - /// monotonic, making it unsuitable for measuring elapsed time. - /// - /// It is intended for reporting the current date and time for humans. - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod wall_clock { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - /// A time and date in seconds plus nanoseconds. - #[repr(C)] - #[derive(Clone, Copy)] - pub struct Datetime { - pub seconds: u64, - pub nanoseconds: u32, - } - impl ::core::fmt::Debug for Datetime { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("Datetime") - .field("seconds", &self.seconds) - .field("nanoseconds", &self.nanoseconds) - .finish() - } - } - #[allow(unused_unsafe, clippy::all)] - /// Read the current value of the clock. - /// - /// This clock is not monotonic, therefore calling this function repeatedly - /// will not necessarily produce a sequence of non-decreasing values. - /// - /// The returned timestamps represent the number of seconds since - /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch], - /// also known as [Unix Time]. - /// - /// The nanoseconds field of the output is always less than 1000000000. - /// - /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16 - /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time - pub fn now() -> Datetime { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 16]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 16]); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/wall-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "now"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let result4 = Datetime { - seconds: l2 as u64, - nanoseconds: l3 as u32, - }; - result4 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Query the resolution of the clock. - /// - /// The nanoseconds field of the output is always less than 1000000000. - pub fn resolution() -> Datetime { - unsafe { - #[repr(align(8))] - struct RetArea([::core::mem::MaybeUninit; 16]); - let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 16]); - let ptr0 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/wall-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "resolution"] - fn wit_import1(_: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import1(_: *mut u8) { - unreachable!() - } - unsafe { wit_import1(ptr0) }; - let l2 = *ptr0.add(0).cast::(); - let l3 = *ptr0.add(8).cast::(); - let result4 = Datetime { - seconds: l2 as u64, - nanoseconds: l3 as u32, - }; - result4 - } - } - } - /// WASI Monotonic Clock is a clock API intended to let users measure elapsed - /// time. - /// - /// It is intended to be portable at least between Unix-family platforms and - /// Windows. - /// - /// A monotonic clock is a clock which has an unspecified initial value, and - /// successive reads of the clock will produce non-decreasing values. - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod monotonic_clock { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - pub type Pollable = super::super::super::wasi::io::poll::Pollable; - /// An instant in time, in nanoseconds. An instant is relative to an - /// unspecified initial value, and can only be compared to instances from - /// the same monotonic-clock. - pub type Instant = u64; - /// A duration of time, in nanoseconds. - pub type Duration = u64; - #[allow(unused_unsafe, clippy::all)] - /// Read the current value of the clock. - /// - /// The clock is monotonic, therefore calling this function repeatedly will - /// produce a sequence of non-decreasing values. - pub fn now() -> Instant { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "now"] - fn wit_import0() -> i64; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i64 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - ret as u64 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Query the resolution of the clock. Returns the duration of time - /// corresponding to a clock tick. - pub fn resolution() -> Duration { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "resolution"] - fn wit_import0() -> i64; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0() -> i64 { - unreachable!() - } - let ret = unsafe { wit_import0() }; - ret as u64 - } - } - #[allow(unused_unsafe, clippy::all)] - /// Create a `pollable` which will resolve once the specified instant - /// has occurred. - pub fn subscribe_instant(when: Instant) -> Pollable { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "subscribe-instant"] - fn wit_import0(_: i64) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i64) -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0(_rt::as_i64(when)) }; - unsafe { - super::super::super::wasi::io::poll::Pollable::from_handle( - ret as u32, - ) - } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Create a `pollable` that will resolve after the specified duration has - /// elapsed from the time this function is invoked. - pub fn subscribe_duration(when: Duration) -> Pollable { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.3")] - unsafe extern "C" { - #[link_name = "subscribe-duration"] - fn wit_import0(_: i64) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i64) -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0(_rt::as_i64(when)) }; - unsafe { - super::super::super::wasi::io::poll::Pollable::from_handle( - ret as u32, - ) - } - } - } - } - } - pub mod io { - /// A poll API intended to let users wait for I/O events on multiple handles - /// at once. - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod poll { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; - use super::super::super::_rt; - /// `pollable` represents a single I/O event which may be ready, or not. - #[derive(Debug)] - #[repr(transparent)] - pub struct Pollable { - handle: _rt::Resource, - } - impl Pollable { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - Self { - handle: unsafe { _rt::Resource::from_handle(handle) }, - } - } - #[doc(hidden)] - pub fn take_handle(&self) -> u32 { - _rt::Resource::take_handle(&self.handle) - } - #[doc(hidden)] - pub fn handle(&self) -> u32 { - _rt::Resource::handle(&self.handle) - } - } - unsafe impl _rt::WasmResource for Pollable { - #[inline] - unsafe fn drop(_handle: u32) { - #[cfg(not(target_arch = "wasm32"))] - unreachable!(); - #[cfg(target_arch = "wasm32")] - { - #[link(wasm_import_module = "wasi:io/poll@0.2.3")] - unsafe extern "C" { - #[link_name = "[resource-drop]pollable"] - fn drop(_: u32); - } - unsafe { drop(_handle) }; - } - } - } - impl Pollable { - #[allow(unused_unsafe, clippy::all)] - /// Return the readiness of a pollable. This function never blocks. - /// - /// Returns `true` when the pollable is ready, and `false` otherwise. - pub fn ready(&self) -> bool { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:io/poll@0.2.3")] - unsafe extern "C" { - #[link_name = "[method]pollable.ready"] - fn wit_import0(_: i32) -> i32; - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) -> i32 { - unreachable!() - } - let ret = unsafe { wit_import0((self).handle() as i32) }; - _rt::bool_lift(ret as u8) - } - } - } - impl Pollable { - #[allow(unused_unsafe, clippy::all)] - /// `block` returns immediately if the pollable is ready, and otherwise - /// blocks until ready. - /// - /// This function is equivalent to calling `poll.poll` on a list - /// containing only this pollable. - pub fn block(&self) -> () { - unsafe { - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:io/poll@0.2.3")] - unsafe extern "C" { - #[link_name = "[method]pollable.block"] - fn wit_import0(_: i32); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import0(_: i32) { - unreachable!() - } - unsafe { wit_import0((self).handle() as i32) }; - } - } - } - #[allow(unused_unsafe, clippy::all)] - /// Poll for completion on a set of pollables. - /// - /// This function takes a list of pollables, which identify I/O sources of - /// interest, and waits until one or more of the events is ready for I/O. - /// - /// The result `list` contains one or more indices of handles in the - /// argument list that is ready for I/O. - /// - /// This function traps if either: - /// - the list is empty, or: - /// - the list contains more elements than can be indexed with a `u32` value. - /// - /// A timeout can be implemented by adding a pollable from the - /// wasi-clocks API to the list. - /// - /// This function does not return a `result`; polling in itself does not - /// do any I/O so it doesn't fail. If any of the I/O sources identified by - /// the pollables has an error, it is indicated by marking the source as - /// being ready for I/O. - pub fn poll(in_: &[&Pollable]) -> _rt::Vec { - unsafe { - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - let mut ret_area = RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - let vec0 = in_; - let len0 = vec0.len(); - let layout0 = _rt::alloc::Layout::from_size_align_unchecked( - vec0.len() * 4, - 4, - ); - let result0 = if layout0.size() != 0 { - let ptr = _rt::alloc::alloc(layout0).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout0); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec0.into_iter().enumerate() { - let base = result0.add(i * 4); - { - *base.add(0).cast::() = (e).handle() as i32; - } - } - let ptr1 = ret_area.0.as_mut_ptr().cast::(); - #[cfg(target_arch = "wasm32")] - #[link(wasm_import_module = "wasi:io/poll@0.2.3")] - unsafe extern "C" { - #[link_name = "poll"] - fn wit_import2(_: *mut u8, _: usize, _: *mut u8); - } - #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8) { - unreachable!() - } - unsafe { wit_import2(result0, len0, ptr1) }; - let l3 = *ptr1.add(0).cast::<*mut u8>(); - let l4 = *ptr1 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len5 = l4; - let result6 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); - if layout0.size() != 0 { - _rt::alloc::dealloc(result0.cast(), layout0); - } - result6 - } - } - } - } -} -#[rustfmt::skip] -#[allow(dead_code, clippy::all)] -pub mod exports { - pub mod golem { - pub mod api { - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod oplog_processor { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_custom_section_describing_imports; - use super::super::super::super::_rt; - pub type Datetime = super::super::super::super::wasi::clocks::wall_clock::Datetime; - pub type WitValue = super::super::super::super::golem::core::types::WitValue; - pub type AccountId = super::super::super::super::golem::core::types::AccountId; - pub type ComponentId = super::super::super::super::golem::core::types::ComponentId; - pub type AgentId = super::super::super::super::golem::core::types::AgentId; - pub type OplogIndex = super::super::super::super::golem::api::host::OplogIndex; - pub type AgentMetadata = super::super::super::super::golem::api::host::AgentMetadata; - pub type OplogEntry = super::super::super::super::golem::api::oplog::OplogEntry; - #[repr(C)] - #[derive(Clone, Copy)] - pub struct AccountInfo { - pub account_id: AccountId, - } - impl ::core::fmt::Debug for AccountInfo { - fn fmt( - &self, - f: &mut ::core::fmt::Formatter<'_>, - ) -> ::core::fmt::Result { - f.debug_struct("AccountInfo") - .field("account-id", &self.account_id) - .finish() - } - } - #[doc(hidden)] - #[allow(non_snake_case)] - pub unsafe fn _export_process_cabi(arg0: *mut u8) -> *mut u8 { - #[cfg(target_arch = "wasm32")] _rt::run_ctors_once(); - let l0 = *arg0.add(0).cast::(); - let l1 = *arg0.add(8).cast::(); - let l2 = *arg0.add(16).cast::<*mut u8>(); - let l3 = *arg0 - .add(16 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base10 = l2; - let len10 = l3; - let mut result10 = _rt::Vec::with_capacity(len10); - for i in 0..len10 { - let base = base10 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e10 = { - let l4 = *base.add(0).cast::<*mut u8>(); - let l5 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len6 = l5; - let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); - let l7 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l8 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len9 = l8; - let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); - (_rt::string_lift(bytes6), _rt::string_lift(bytes9)) - }; - result10.push(e10); - } - _rt::cabi_dealloc( - base10, - len10 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l11 = *arg0 - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l12 = *arg0 - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l13 = *arg0 - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l14 = *arg0 - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l15 = *arg0 - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l16 = *arg0 - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len17 = l16; - let bytes17 = _rt::Vec::from_raw_parts(l15.cast(), len17, len17); - let l18 = *arg0 - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l19 = *arg0 - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l20 = *arg0 - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l21 = *arg0 - .add(64 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len22 = l21; - let bytes22 = _rt::Vec::from_raw_parts(l20.cast(), len22, len22); - let l23 = *arg0 - .add(64 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l24 = *arg0 - .add(64 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base28 = l23; - let len28 = l24; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e28 = { - let l25 = *base.add(0).cast::<*mut u8>(); - let l26 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len27 = l26; - let bytes27 = _rt::Vec::from_raw_parts( - l25.cast(), - len27, - len27, - ); - _rt::string_lift(bytes27) - }; - result28.push(e28); - } - _rt::cabi_dealloc( - base28, - len28 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l29 = *arg0 - .add(64 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l30 = *arg0 - .add(64 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base37 = l29; - let len37 = l30; - let mut result37 = _rt::Vec::with_capacity(len37); - for i in 0..len37 { - let base = base37 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e37 = { - let l31 = *base.add(0).cast::<*mut u8>(); - let l32 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len33 = l32; - let bytes33 = _rt::Vec::from_raw_parts( - l31.cast(), - len33, - len33, - ); - let l34 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l35 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, - ); - (_rt::string_lift(bytes33), _rt::string_lift(bytes36)) - }; - result37.push(e37); - } - _rt::cabi_dealloc( - base37, - len37 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l38 = *arg0 - .add(64 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l39 = *arg0 - .add(64 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base46 = l38; - let len46 = l39; - let mut result46 = _rt::Vec::with_capacity(len46); - for i in 0..len46 { - let base = base46 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e46 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, - ); - let l43 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l44 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len45 = l44; - let bytes45 = _rt::Vec::from_raw_parts( - l43.cast(), - len45, - len45, - ); - (_rt::string_lift(bytes42), _rt::string_lift(bytes45)) - }; - result46.push(e46); - } - _rt::cabi_dealloc( - base46, - len46 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l47 = i32::from( - *arg0 - .add(64 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l48 = *arg0 - .add(72 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l49 = *arg0 - .add(80 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l50 = *arg0 - .add(88 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l51 = *arg0 - .add(96 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l52 = *arg0 - .add(104 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l53 = *arg0 - .add(112 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l54 = *arg0 - .add(112 + 13 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base517 = l53; - let len517 = l54; - let mut result517 = _rt::Vec::with_capacity(len517); - for i in 0..len517 { - let base = base517 - .add(i * (144 + 12 * ::core::mem::size_of::<*const u8>())); - let e517 = { - let l55 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::oplog::OplogEntry as V516; - let v516 = match l55 { - 0 => { - let e516 = { - let l56 = *base.add(8).cast::(); - let l57 = *base.add(16).cast::(); - let l58 = *base.add(24).cast::(); - let l59 = *base.add(32).cast::(); - let l60 = *base.add(40).cast::<*mut u8>(); - let l61 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len62 = l61; - let bytes62 = _rt::Vec::from_raw_parts( - l60.cast(), - len62, - len62, - ); - let l63 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l64 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l65 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base72 = l64; - let len72 = l65; - let mut result72 = _rt::Vec::with_capacity(len72); - for i in 0..len72 { - let base = base72 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e72 = { - let l66 = *base.add(0).cast::<*mut u8>(); - let l67 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len68 = l67; - let bytes68 = _rt::Vec::from_raw_parts( - l66.cast(), - len68, - len68, - ); - let l69 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l70 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len71 = l70; - let bytes71 = _rt::Vec::from_raw_parts( - l69.cast(), - len71, - len71, - ); - (_rt::string_lift(bytes68), _rt::string_lift(bytes71)) - }; - result72.push(e72); - } - _rt::cabi_dealloc( - base72, - len72 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l73 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l74 = *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l75 = *base - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l76 = *base - .add(72 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l77 = i32::from( - *base - .add(80 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l83 = *base - .add(104 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l84 = *base - .add(112 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l85 = *base - .add(120 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l86 = *base - .add(120 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len87 = l86; - let l88 = *base - .add(120 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l89 = *base - .add(120 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base96 = l88; - let len96 = l89; - let mut result96 = _rt::Vec::with_capacity(len96); - for i in 0..len96 { - let base = base96 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e96 = { - let l90 = *base.add(0).cast::<*mut u8>(); - let l91 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len92 = l91; - let bytes92 = _rt::Vec::from_raw_parts( - l90.cast(), - len92, - len92, - ); - let l93 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l94 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len95 = l94; - let bytes95 = _rt::Vec::from_raw_parts( - l93.cast(), - len95, - len95, - ); - (_rt::string_lift(bytes92), _rt::string_lift(bytes95)) - }; - result96.push(e96); - } - _rt::cabi_dealloc( - base96, - len96 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l97 = *base - .add(120 + 10 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l98 = *base - .add(120 + 11 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base153 = l97; - let len153 = l98; - let mut result153 = _rt::Vec::with_capacity(len153); - for i in 0..len153 { - let base = base153 - .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e153 = { - let l99 = *base.add(0).cast::<*mut u8>(); - let l100 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base104 = l99; - let len104 = l100; - let mut result104 = _rt::Vec::with_capacity(len104); - for i in 0..len104 { - let base = base104 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e104 = { - let l101 = *base.add(0).cast::<*mut u8>(); - let l102 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len103 = l102; - let bytes103 = _rt::Vec::from_raw_parts( - l101.cast(), - len103, - len103, - ); - _rt::string_lift(bytes103) - }; - result104.push(e104); - } - _rt::cabi_dealloc( - base104, - len104 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l105 = *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l106 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base152 = l105; - let len152 = l106; - let mut result152 = _rt::Vec::with_capacity(len152); - for i in 0..len152 { - let base = base152 - .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e152 = { - let l107 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::core::types::WitNode as V151; - let v151 = match l107 { - 0 => { - let e151 = { - let l108 = *base.add(8).cast::<*mut u8>(); - let l109 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len110 = l109; - _rt::Vec::from_raw_parts(l108.cast(), len110, len110) - }; - V151::RecordValue(e151) - } - 1 => { - let e151 = { - let l111 = *base.add(8).cast::(); - let l112 = i32::from(*base.add(12).cast::()); - ( - l111 as u32, - match l112 { - 0 => None, - 1 => { - let e = { - let l113 = *base.add(16).cast::(); - l113 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - ) - }; - V151::VariantValue(e151) - } - 2 => { - let e151 = { - let l114 = *base.add(8).cast::(); - l114 as u32 - }; - V151::EnumValue(e151) - } - 3 => { - let e151 = { - let l115 = *base.add(8).cast::<*mut u8>(); - let l116 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base118 = l115; - let len118 = l116; - let mut result118 = _rt::Vec::with_capacity(len118); - for i in 0..len118 { - let base = base118.add(i * 1); - let e118 = { - let l117 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l117 as u8) - }; - result118.push(e118); - } - _rt::cabi_dealloc(base118, len118 * 1, 1); - result118 - }; - V151::FlagsValue(e151) - } - 4 => { - let e151 = { - let l119 = *base.add(8).cast::<*mut u8>(); - let l120 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len121 = l120; - _rt::Vec::from_raw_parts(l119.cast(), len121, len121) - }; - V151::TupleValue(e151) - } - 5 => { - let e151 = { - let l122 = *base.add(8).cast::<*mut u8>(); - let l123 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len124 = l123; - _rt::Vec::from_raw_parts(l122.cast(), len124, len124) - }; - V151::ListValue(e151) - } - 6 => { - let e151 = { - let l125 = i32::from(*base.add(8).cast::()); - match l125 { - 0 => None, - 1 => { - let e = { - let l126 = *base.add(12).cast::(); - l126 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V151::OptionValue(e151) - } - 7 => { - let e151 = { - let l127 = i32::from(*base.add(8).cast::()); - match l127 { - 0 => { - let e = { - let l128 = i32::from(*base.add(12).cast::()); - match l128 { - 0 => None, - 1 => { - let e = { - let l129 = *base.add(16).cast::(); - l129 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Ok(e) - } - 1 => { - let e = { - let l130 = i32::from(*base.add(12).cast::()); - match l130 { - 0 => None, - 1 => { - let e = { - let l131 = *base.add(16).cast::(); - l131 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - Err(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V151::ResultValue(e151) - } - 8 => { - let e151 = { - let l132 = i32::from(*base.add(8).cast::()); - l132 as u8 - }; - V151::PrimU8(e151) - } - 9 => { - let e151 = { - let l133 = i32::from(*base.add(8).cast::()); - l133 as u16 - }; - V151::PrimU16(e151) - } - 10 => { - let e151 = { - let l134 = *base.add(8).cast::(); - l134 as u32 - }; - V151::PrimU32(e151) - } - 11 => { - let e151 = { - let l135 = *base.add(8).cast::(); - l135 as u64 - }; - V151::PrimU64(e151) - } - 12 => { - let e151 = { - let l136 = i32::from(*base.add(8).cast::()); - l136 as i8 - }; - V151::PrimS8(e151) - } - 13 => { - let e151 = { - let l137 = i32::from(*base.add(8).cast::()); - l137 as i16 - }; - V151::PrimS16(e151) - } - 14 => { - let e151 = { - let l138 = *base.add(8).cast::(); - l138 - }; - V151::PrimS32(e151) - } - 15 => { - let e151 = { - let l139 = *base.add(8).cast::(); - l139 - }; - V151::PrimS64(e151) - } - 16 => { - let e151 = { - let l140 = *base.add(8).cast::(); - l140 - }; - V151::PrimFloat32(e151) - } - 17 => { - let e151 = { - let l141 = *base.add(8).cast::(); - l141 - }; - V151::PrimFloat64(e151) - } - 18 => { - let e151 = { - let l142 = *base.add(8).cast::(); - _rt::char_lift(l142 as u32) - }; - V151::PrimChar(e151) - } - 19 => { - let e151 = { - let l143 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l143 as u8) - }; - V151::PrimBool(e151) - } - 20 => { - let e151 = { - let l144 = *base.add(8).cast::<*mut u8>(); - let l145 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len146 = l145; - let bytes146 = _rt::Vec::from_raw_parts( - l144.cast(), - len146, - len146, - ); - _rt::string_lift(bytes146) - }; - V151::PrimString(e151) - } - n => { - debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e151 = { - let l147 = *base.add(8).cast::<*mut u8>(); - let l148 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len149 = l148; - let bytes149 = _rt::Vec::from_raw_parts( - l147.cast(), - len149, - len149, - ); - let l150 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - ( - super::super::super::super::golem::core::types::Uri { - value: _rt::string_lift(bytes149), - }, - l150 as u64, - ) - }; - V151::Handle(e151) - } - }; - v151 - }; - result152.push(e152); - } - _rt::cabi_dealloc( - base152, - len152 * (16 + 2 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::super::golem::api::oplog::RawLocalAgentConfigEntry { - path: result104, - value: super::super::super::super::golem::core::types::WitValue { - nodes: result152, - }, - } - }; - result153.push(e153); - } - _rt::cabi_dealloc( - base153, - len153 * (4 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l154 = i32::from( - *base - .add(120 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::super::golem::api::oplog::RawCreateParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l56 as u64, - nanoseconds: l57 as u32, - }, - agent_id: super::super::super::super::golem::core::types::AgentId { - component_id: super::super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l58 as u64, - low_bits: l59 as u64, - }, - }, - agent_id: _rt::string_lift(bytes62), - }, - component_revision: l63 as u64, - env: result72, - environment_id: super::super::super::super::golem::api::host::EnvironmentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l73 as u64, - low_bits: l74 as u64, - }, - }, - created_by: super::super::super::super::golem::core::types::AccountId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l75 as u64, - low_bits: l76 as u64, - }, - }, - parent: match l77 { - 0 => None, - 1 => { - let e = { - let l78 = *base - .add(88 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l79 = *base - .add(96 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l80 = *base - .add(104 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l81 = *base - .add(104 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len82 = l81; - let bytes82 = _rt::Vec::from_raw_parts( - l80.cast(), - len82, - len82, - ); - super::super::super::super::golem::core::types::AgentId { - component_id: super::super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l78 as u64, - low_bits: l79 as u64, - }, - }, - agent_id: _rt::string_lift(bytes82), - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - component_size: l83 as u64, - initial_total_linear_memory_size: l84 as u64, - initial_active_plugins: _rt::Vec::from_raw_parts( - l85.cast(), - len87, - len87, - ), - config_vars: result96, - local_agent_config: result153, - original_phantom_id: match l154 { - 0 => None, - 1 => { - let e = { - let l155 = *base - .add(128 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l156 = *base - .add(136 + 12 * ::core::mem::size_of::<*const u8>()) - .cast::(); - super::super::super::super::golem::core::types::Uuid { - high_bits: l155 as u64, - low_bits: l156 as u64, - } - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V516::Create(e516) - } - 1 => { - let e516 = { - let l157 = *base.add(8).cast::(); - let l158 = *base.add(16).cast::(); - let l159 = *base.add(24).cast::<*mut u8>(); - let l160 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len161 = l160; - let bytes161 = _rt::Vec::from_raw_parts( - l159.cast(), - len161, - len161, - ); - let l162 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::oplog::OplogPayload as V171; - let v171 = match l162 { - 0 => { - let e171 = { - let l163 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l164 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len165 = l164; - _rt::Vec::from_raw_parts(l163.cast(), len165, len165) - }; - V171::Inline(e171) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e171 = { - let l166 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l167 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l168 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l169 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len170 = l169; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l166 as u64, - low_bits: l167 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l168.cast(), - len170, - len170, - ), - } - }; - V171::External(e171) - } - }; - let l172 = i32::from( - *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::oplog::OplogPayload as V181; - let v181 = match l172 { - 0 => { - let e181 = { - let l173 = *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l174 = *base - .add(56 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len175 = l174; - _rt::Vec::from_raw_parts(l173.cast(), len175, len175) - }; - V181::Inline(e181) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e181 = { - let l176 = *base - .add(56 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l177 = *base - .add(64 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l178 = *base - .add(72 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l179 = *base - .add(72 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len180 = l179; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l176 as u64, - low_bits: l177 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l178.cast(), - len180, - len180, - ), - } - }; - V181::External(e181) - } - }; - let l182 = i32::from( - *base - .add(72 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::oplog::WrappedFunctionType as V187; - let v187 = match l182 { - 0 => V187::ReadLocal, - 1 => V187::WriteLocal, - 2 => V187::ReadRemote, - 3 => V187::WriteRemote, - 4 => { - let e187 = { - let l183 = i32::from( - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l183 { - 0 => None, - 1 => { - let e = { - let l184 = *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l184 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V187::WriteRemoteBatched(e187) - } - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e187 = { - let l185 = i32::from( - *base - .add(80 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - match l185 { - 0 => None, - 1 => { - let e = { - let l186 = *base - .add(88 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l186 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - } - }; - V187::WriteRemoteTransaction(e187) - } - }; - super::super::super::super::golem::api::oplog::RawHostCallParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l157 as u64, - nanoseconds: l158 as u32, - }, - function_name: _rt::string_lift(bytes161), - request: v171, - response: v181, - durable_function_type: v187, - } - }; - V516::HostCall(e516) - } - 2 => { - let e516 = { - let l188 = *base.add(8).cast::(); - let l189 = *base.add(16).cast::(); - let l190 = *base.add(24).cast::<*mut u8>(); - let l191 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len192 = l191; - let bytes192 = _rt::Vec::from_raw_parts( - l190.cast(), - len192, - len192, - ); - let l193 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::oplog::OplogPayload as V202; - let v202 = match l193 { - 0 => { - let e202 = { - let l194 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l195 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len196 = l195; - _rt::Vec::from_raw_parts(l194.cast(), len196, len196) - }; - V202::Inline(e202) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e202 = { - let l197 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l198 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l199 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l200 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len201 = l200; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l197 as u64, - low_bits: l198 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l199.cast(), - len201, - len201, - ), - } - }; - V202::External(e202) - } - }; - let l203 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l204 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len205 = l204; - let bytes205 = _rt::Vec::from_raw_parts( - l203.cast(), - len205, - len205, - ); - let l206 = *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l207 = *base - .add(48 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base211 = l206; - let len211 = l207; - let mut result211 = _rt::Vec::with_capacity(len211); - for i in 0..len211 { - let base = base211 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e211 = { - let l208 = *base.add(0).cast::<*mut u8>(); - let l209 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len210 = l209; - let bytes210 = _rt::Vec::from_raw_parts( - l208.cast(), - len210, - len210, - ); - _rt::string_lift(bytes210) - }; - result211.push(e211); - } - _rt::cabi_dealloc( - base211, - len211 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l212 = *base - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l213 = *base - .add(48 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base242 = l212; - let len242 = l213; - let mut result242 = _rt::Vec::with_capacity(len242); - for i in 0..len242 { - let base = base242 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e242 = { - let l214 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::oplog::SpanData as V241; - let v241 = match l214 { - 0 => { - let e241 = { - let l215 = *base.add(8).cast::<*mut u8>(); - let l216 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len217 = l216; - let bytes217 = _rt::Vec::from_raw_parts( - l215.cast(), - len217, - len217, - ); - let l218 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l219 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l220 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l224 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l226 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l227 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base236 = l226; - let len236 = l227; - let mut result236 = _rt::Vec::with_capacity(len236); - for i in 0..len236 { - let base = base236 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e236 = { - let l228 = *base.add(0).cast::<*mut u8>(); - let l229 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len230 = l229; - let bytes230 = _rt::Vec::from_raw_parts( - l228.cast(), - len230, - len230, - ); - let l231 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::context::AttributeValue as V235; - let v235 = match l231 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e235 = { - let l232 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l233 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len234 = l233; - let bytes234 = _rt::Vec::from_raw_parts( - l232.cast(), - len234, - len234, - ); - _rt::string_lift(bytes234) - }; - V235::String(e235) - } - }; - super::super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes230), - value: v235, - } - }; - result236.push(e236); - } - _rt::cabi_dealloc( - base236, - len236 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l237 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::super::golem::api::oplog::LocalSpanData { - span_id: _rt::string_lift(bytes217), - start: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l218 as u64, - nanoseconds: l219 as u32, - }, - parent: match l220 { - 0 => None, - 1 => { - let e = { - let l221 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l222 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len223 = l222; - let bytes223 = _rt::Vec::from_raw_parts( - l221.cast(), - len223, - len223, - ); - _rt::string_lift(bytes223) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l224 { - 0 => None, - 1 => { - let e = { - let l225 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l225 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result236, - inherited: _rt::bool_lift(l237 as u8), - } - }; - V241::LocalSpan(e241) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e241 = { - let l238 = *base.add(8).cast::<*mut u8>(); - let l239 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len240 = l239; - let bytes240 = _rt::Vec::from_raw_parts( - l238.cast(), - len240, - len240, - ); - super::super::super::super::golem::api::oplog::ExternalSpanData { - span_id: _rt::string_lift(bytes240), - } - }; - V241::ExternalSpan(e241) - } - }; - v241 - }; - result242.push(e242); - } - _rt::cabi_dealloc( - base242, - len242 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::super::golem::api::oplog::RawAgentInvocationStartedParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l188 as u64, - nanoseconds: l189 as u32, - }, - idempotency_key: _rt::string_lift(bytes192), - payload: v202, - trace_id: _rt::string_lift(bytes205), - trace_states: result211, - invocation_context: result242, - } - }; - V516::AgentInvocationStarted(e516) - } - 3 => { - let e516 = { - let l243 = *base.add(8).cast::(); - let l244 = *base.add(16).cast::(); - let l245 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::oplog::OplogPayload as V254; - let v254 = match l245 { - 0 => { - let e254 = { - let l246 = *base.add(32).cast::<*mut u8>(); - let l247 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len248 = l247; - _rt::Vec::from_raw_parts(l246.cast(), len248, len248) - }; - V254::Inline(e254) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e254 = { - let l249 = *base.add(32).cast::(); - let l250 = *base.add(40).cast::(); - let l251 = *base.add(48).cast::<*mut u8>(); - let l252 = *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len253 = l252; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l249 as u64, - low_bits: l250 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l251.cast(), - len253, - len253, - ), - } - }; - V254::External(e254) - } - }; - let l255 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l256 = *base - .add(56 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - super::super::super::super::golem::api::oplog::RawAgentInvocationFinishedParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l243 as u64, - nanoseconds: l244 as u32, - }, - result: v254, - consumed_fuel: l255, - component_revision: l256 as u64, - } - }; - V516::AgentInvocationFinished(e516) - } - 4 => { - let e516 = { - let l257 = *base.add(8).cast::(); - let l258 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l257 as u64, - nanoseconds: l258 as u32, - }, - } - }; - V516::Suspend(e516) - } - 5 => { - let e516 = { - let l259 = *base.add(8).cast::(); - let l260 = *base.add(16).cast::(); - let l261 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::oplog::WorkerError as V271; - let v271 = match l261 { - 0 => { - let e271 = { - let l262 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l263 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len264 = l263; - let bytes264 = _rt::Vec::from_raw_parts( - l262.cast(), - len264, - len264, - ); - _rt::string_lift(bytes264) - }; - V271::Unknown(e271) - } - 1 => { - let e271 = { - let l265 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l266 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len267 = l266; - let bytes267 = _rt::Vec::from_raw_parts( - l265.cast(), - len267, - len267, - ); - _rt::string_lift(bytes267) - }; - V271::InvalidRequest(e271) - } - 2 => V271::StackOverflow, - 3 => V271::OutOfMemory, - 4 => V271::ExceededMemoryLimit, - n => { - debug_assert_eq!(n, 5, "invalid enum discriminant"); - let e271 = { - let l268 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l269 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len270 = l269; - let bytes270 = _rt::Vec::from_raw_parts( - l268.cast(), - len270, - len270, - ); - _rt::string_lift(bytes270) - }; - V271::InternalError(e271) - } - }; - let l272 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - super::super::super::super::golem::api::oplog::RawErrorParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l259 as u64, - nanoseconds: l260 as u32, - }, - error: v271, - retry_from: l272 as u64, - } - }; - V516::Error(e516) - } - 6 => { - let e516 = { - let l273 = *base.add(8).cast::(); - let l274 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l273 as u64, - nanoseconds: l274 as u32, - }, - } - }; - V516::NoOp(e516) - } - 7 => { - let e516 = { - let l275 = *base.add(8).cast::(); - let l276 = *base.add(16).cast::(); - let l277 = *base.add(24).cast::(); - let l278 = *base.add(32).cast::(); - super::super::super::super::golem::api::oplog::JumpParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l275 as u64, - nanoseconds: l276 as u32, - }, - jump: super::super::super::super::golem::api::oplog::OplogRegion { - start: l277 as u64, - end: l278 as u64, - }, - } - }; - V516::Jump(e516) - } - 8 => { - let e516 = { - let l279 = *base.add(8).cast::(); - let l280 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l279 as u64, - nanoseconds: l280 as u32, - }, - } - }; - V516::Interrupted(e516) - } - 9 => { - let e516 = { - let l281 = *base.add(8).cast::(); - let l282 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l281 as u64, - nanoseconds: l282 as u32, - }, - } - }; - V516::Exited(e516) - } - 10 => { - let e516 = { - let l283 = *base.add(8).cast::(); - let l284 = *base.add(16).cast::(); - let l285 = *base.add(24).cast::(); - let l286 = *base.add(32).cast::(); - let l287 = *base.add(40).cast::(); - let l288 = *base.add(48).cast::(); - let l289 = i32::from(*base.add(56).cast::()); - super::super::super::super::golem::api::oplog::ChangeRetryPolicyParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l283 as u64, - nanoseconds: l284 as u32, - }, - new_policy: super::super::super::super::golem::api::host::RetryPolicy { - max_attempts: l285 as u32, - min_delay: l286 as u64, - max_delay: l287 as u64, - multiplier: l288, - max_jitter_factor: match l289 { - 0 => None, - 1 => { - let e = { - let l290 = *base.add(64).cast::(); - l290 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - }, - } - }; - V516::ChangeRetryPolicy(e516) - } - 11 => { - let e516 = { - let l291 = *base.add(8).cast::(); - let l292 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l291 as u64, - nanoseconds: l292 as u32, - }, - } - }; - V516::BeginAtomicRegion(e516) - } - 12 => { - let e516 = { - let l293 = *base.add(8).cast::(); - let l294 = *base.add(16).cast::(); - let l295 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::EndAtomicRegionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l293 as u64, - nanoseconds: l294 as u32, - }, - begin_index: l295 as u64, - } - }; - V516::EndAtomicRegion(e516) - } - 13 => { - let e516 = { - let l296 = *base.add(8).cast::(); - let l297 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l296 as u64, - nanoseconds: l297 as u32, - }, - } - }; - V516::BeginRemoteWrite(e516) - } - 14 => { - let e516 = { - let l298 = *base.add(8).cast::(); - let l299 = *base.add(16).cast::(); - let l300 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::EndRemoteWriteParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l298 as u64, - nanoseconds: l299 as u32, - }, - begin_index: l300 as u64, - } - }; - V516::EndRemoteWrite(e516) - } - 15 => { - let e516 = { - let l301 = *base.add(8).cast::(); - let l302 = *base.add(16).cast::(); - let l303 = *base.add(24).cast::<*mut u8>(); - let l304 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len305 = l304; - let bytes305 = _rt::Vec::from_raw_parts( - l303.cast(), - len305, - len305, - ); - let l306 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::oplog::OplogPayload as V315; - let v315 = match l306 { - 0 => { - let e315 = { - let l307 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l308 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len309 = l308; - _rt::Vec::from_raw_parts(l307.cast(), len309, len309) - }; - V315::Inline(e315) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e315 = { - let l310 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l311 = *base - .add(40 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l312 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l313 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len314 = l313; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l310 as u64, - low_bits: l311 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l312.cast(), - len314, - len314, - ), - } - }; - V315::External(e315) - } - }; - let l316 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l317 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len318 = l317; - let bytes318 = _rt::Vec::from_raw_parts( - l316.cast(), - len318, - len318, - ); - let l319 = *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l320 = *base - .add(48 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base324 = l319; - let len324 = l320; - let mut result324 = _rt::Vec::with_capacity(len324); - for i in 0..len324 { - let base = base324 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e324 = { - let l321 = *base.add(0).cast::<*mut u8>(); - let l322 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len323 = l322; - let bytes323 = _rt::Vec::from_raw_parts( - l321.cast(), - len323, - len323, - ); - _rt::string_lift(bytes323) - }; - result324.push(e324); - } - _rt::cabi_dealloc( - base324, - len324 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l325 = *base - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l326 = *base - .add(48 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base355 = l325; - let len355 = l326; - let mut result355 = _rt::Vec::with_capacity(len355); - for i in 0..len355 { - let base = base355 - .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e355 = { - let l327 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::oplog::SpanData as V354; - let v354 = match l327 { - 0 => { - let e354 = { - let l328 = *base.add(8).cast::<*mut u8>(); - let l329 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len330 = l329; - let bytes330 = _rt::Vec::from_raw_parts( - l328.cast(), - len330, - len330, - ); - let l331 = *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l332 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let l333 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l337 = i32::from( - *base - .add(32 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l339 = *base - .add(48 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l340 = *base - .add(48 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base349 = l339; - let len349 = l340; - let mut result349 = _rt::Vec::with_capacity(len349); - for i in 0..len349 { - let base = base349 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e349 = { - let l341 = *base.add(0).cast::<*mut u8>(); - let l342 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len343 = l342; - let bytes343 = _rt::Vec::from_raw_parts( - l341.cast(), - len343, - len343, - ); - let l344 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::context::AttributeValue as V348; - let v348 = match l344 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e348 = { - let l345 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l346 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len347 = l346; - let bytes347 = _rt::Vec::from_raw_parts( - l345.cast(), - len347, - len347, - ); - _rt::string_lift(bytes347) - }; - V348::String(e348) - } - }; - super::super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes343), - value: v348, - } - }; - result349.push(e349); - } - _rt::cabi_dealloc( - base349, - len349 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let l350 = i32::from( - *base - .add(48 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::super::golem::api::oplog::LocalSpanData { - span_id: _rt::string_lift(bytes330), - start: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l331 as u64, - nanoseconds: l332 as u32, - }, - parent: match l333 { - 0 => None, - 1 => { - let e = { - let l334 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l335 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len336 = l335; - let bytes336 = _rt::Vec::from_raw_parts( - l334.cast(), - len336, - len336, - ); - _rt::string_lift(bytes336) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context: match l337 { - 0 => None, - 1 => { - let e = { - let l338 = *base - .add(40 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l338 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result349, - inherited: _rt::bool_lift(l350 as u8), - } - }; - V354::LocalSpan(e354) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e354 = { - let l351 = *base.add(8).cast::<*mut u8>(); - let l352 = *base - .add(8 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len353 = l352; - let bytes353 = _rt::Vec::from_raw_parts( - l351.cast(), - len353, - len353, - ); - super::super::super::super::golem::api::oplog::ExternalSpanData { - span_id: _rt::string_lift(bytes353), - } - }; - V354::ExternalSpan(e354) - } - }; - v354 - }; - result355.push(e355); - } - _rt::cabi_dealloc( - base355, - len355 * (56 + 6 * ::core::mem::size_of::<*const u8>()), - 8, - ); - super::super::super::super::golem::api::oplog::RawPendingAgentInvocationParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l301 as u64, - nanoseconds: l302 as u32, - }, - idempotency_key: _rt::string_lift(bytes305), - payload: v315, - trace_id: _rt::string_lift(bytes318), - trace_states: result324, - invocation_context: result355, - } - }; - V516::PendingAgentInvocation(e516) - } - 16 => { - let e516 = { - let l356 = *base.add(8).cast::(); - let l357 = *base.add(16).cast::(); - let l358 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::oplog::RawUpdateDescription as V374; - let v374 = match l358 { - 0 => { - let e374 = { - let l359 = *base.add(32).cast::(); - l359 as u64 - }; - V374::Automatic(e374) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e374 = { - let l360 = *base.add(32).cast::(); - let l361 = i32::from(*base.add(40).cast::()); - use super::super::super::super::golem::api::oplog::OplogPayload as V370; - let v370 = match l361 { - 0 => { - let e370 = { - let l362 = *base.add(48).cast::<*mut u8>(); - let l363 = *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len364 = l363; - _rt::Vec::from_raw_parts(l362.cast(), len364, len364) - }; - V370::Inline(e370) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e370 = { - let l365 = *base.add(48).cast::(); - let l366 = *base.add(56).cast::(); - let l367 = *base.add(64).cast::<*mut u8>(); - let l368 = *base - .add(64 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len369 = l368; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l365 as u64, - low_bits: l366 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l367.cast(), - len369, - len369, - ), - } - }; - V370::External(e370) - } - }; - let l371 = *base - .add(64 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l372 = *base - .add(64 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len373 = l372; - let bytes373 = _rt::Vec::from_raw_parts( - l371.cast(), - len373, - len373, - ); - super::super::super::super::golem::api::oplog::RawSnapshotBasedUpdate { - target_revision: l360 as u64, - payload: v370, - mime_type: _rt::string_lift(bytes373), - } - }; - V374::SnapshotBased(e374) - } - }; - super::super::super::super::golem::api::oplog::RawPendingUpdateParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l356 as u64, - nanoseconds: l357 as u32, - }, - description: v374, - } - }; - V516::PendingUpdate(e516) - } - 17 => { - let e516 = { - let l375 = *base.add(8).cast::(); - let l376 = *base.add(16).cast::(); - let l377 = *base.add(24).cast::(); - let l378 = *base.add(32).cast::(); - let l379 = *base.add(40).cast::<*mut u8>(); - let l380 = *base - .add(40 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len381 = l380; - super::super::super::super::golem::api::oplog::RawSuccessfulUpdateParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l375 as u64, - nanoseconds: l376 as u32, - }, - target_revision: l377 as u64, - new_component_size: l378 as u64, - new_active_plugins: _rt::Vec::from_raw_parts( - l379.cast(), - len381, - len381, - ), - } - }; - V516::SuccessfulUpdate(e516) - } - 18 => { - let e516 = { - let l382 = *base.add(8).cast::(); - let l383 = *base.add(16).cast::(); - let l384 = *base.add(24).cast::(); - let l385 = i32::from(*base.add(32).cast::()); - super::super::super::super::golem::api::oplog::FailedUpdateParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l382 as u64, - nanoseconds: l383 as u32, - }, - target_revision: l384 as u64, - details: match l385 { - 0 => None, - 1 => { - let e = { - let l386 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l387 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len388 = l387; - let bytes388 = _rt::Vec::from_raw_parts( - l386.cast(), - len388, - len388, - ); - _rt::string_lift(bytes388) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V516::FailedUpdate(e516) - } - 19 => { - let e516 = { - let l389 = *base.add(8).cast::(); - let l390 = *base.add(16).cast::(); - let l391 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::GrowMemoryParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l389 as u64, - nanoseconds: l390 as u32, - }, - delta: l391 as u64, - } - }; - V516::GrowMemory(e516) - } - 20 => { - let e516 = { - let l392 = *base.add(8).cast::(); - let l393 = *base.add(16).cast::(); - let l394 = *base.add(24).cast::(); - let l395 = *base.add(32).cast::<*mut u8>(); - let l396 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len397 = l396; - let bytes397 = _rt::Vec::from_raw_parts( - l395.cast(), - len397, - len397, - ); - let l398 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l399 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len400 = l399; - let bytes400 = _rt::Vec::from_raw_parts( - l398.cast(), - len400, - len400, - ); - super::super::super::super::golem::api::oplog::RawCreateResourceParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l392 as u64, - nanoseconds: l393 as u32, - }, - id: l394 as u64, - resource_type_id: super::super::super::super::golem::api::oplog::ResourceTypeId { - name: _rt::string_lift(bytes397), - owner: _rt::string_lift(bytes400), - }, - } - }; - V516::CreateResource(e516) - } - 21 => { - let e516 = { - let l401 = *base.add(8).cast::(); - let l402 = *base.add(16).cast::(); - let l403 = *base.add(24).cast::(); - let l404 = *base.add(32).cast::<*mut u8>(); - let l405 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len406 = l405; - let bytes406 = _rt::Vec::from_raw_parts( - l404.cast(), - len406, - len406, - ); - let l407 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l408 = *base - .add(32 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len409 = l408; - let bytes409 = _rt::Vec::from_raw_parts( - l407.cast(), - len409, - len409, - ); - super::super::super::super::golem::api::oplog::RawDropResourceParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l401 as u64, - nanoseconds: l402 as u32, - }, - id: l403 as u64, - resource_type_id: super::super::super::super::golem::api::oplog::ResourceTypeId { - name: _rt::string_lift(bytes406), - owner: _rt::string_lift(bytes409), - }, - } - }; - V516::DropResource(e516) - } - 22 => { - let e516 = { - let l410 = *base.add(8).cast::(); - let l411 = *base.add(16).cast::(); - let l412 = i32::from(*base.add(24).cast::()); - let l413 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l414 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len415 = l414; - let bytes415 = _rt::Vec::from_raw_parts( - l413.cast(), - len415, - len415, - ); - let l416 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l417 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len418 = l417; - let bytes418 = _rt::Vec::from_raw_parts( - l416.cast(), - len418, - len418, - ); - super::super::super::super::golem::api::oplog::LogParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l410 as u64, - nanoseconds: l411 as u32, - }, - level: super::super::super::super::golem::api::oplog::LogLevel::_lift( - l412 as u8, - ), - context: _rt::string_lift(bytes415), - message: _rt::string_lift(bytes418), - } - }; - V516::Log(e516) - } - 23 => { - let e516 = { - let l419 = *base.add(8).cast::(); - let l420 = *base.add(16).cast::(); - super::super::super::super::golem::api::oplog::Timestamp { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l419 as u64, - nanoseconds: l420 as u32, - }, - } - }; - V516::Restart(e516) - } - 24 => { - let e516 = { - let l421 = *base.add(8).cast::(); - let l422 = *base.add(16).cast::(); - let l423 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RawActivatePluginParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l421 as u64, - nanoseconds: l422 as u32, - }, - plugin_priority: l423, - } - }; - V516::ActivatePlugin(e516) - } - 25 => { - let e516 = { - let l424 = *base.add(8).cast::(); - let l425 = *base.add(16).cast::(); - let l426 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RawDeactivatePluginParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l424 as u64, - nanoseconds: l425 as u32, - }, - plugin_priority: l426, - } - }; - V516::DeactivatePlugin(e516) - } - 26 => { - let e516 = { - let l427 = *base.add(8).cast::(); - let l428 = *base.add(16).cast::(); - let l429 = *base.add(24).cast::(); - let l430 = *base.add(32).cast::(); - super::super::super::super::golem::api::oplog::RevertParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l427 as u64, - nanoseconds: l428 as u32, - }, - dropped_region: super::super::super::super::golem::api::oplog::OplogRegion { - start: l429 as u64, - end: l430 as u64, - }, - } - }; - V516::Revert(e516) - } - 27 => { - let e516 = { - let l431 = *base.add(8).cast::(); - let l432 = *base.add(16).cast::(); - let l433 = *base.add(24).cast::<*mut u8>(); - let l434 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len435 = l434; - let bytes435 = _rt::Vec::from_raw_parts( - l433.cast(), - len435, - len435, - ); - super::super::super::super::golem::api::oplog::CancelPendingInvocationParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l431 as u64, - nanoseconds: l432 as u32, - }, - idempotency_key: _rt::string_lift(bytes435), - } - }; - V516::CancelPendingInvocation(e516) - } - 28 => { - let e516 = { - let l436 = *base.add(8).cast::(); - let l437 = *base.add(16).cast::(); - let l438 = *base.add(24).cast::<*mut u8>(); - let l439 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len440 = l439; - let bytes440 = _rt::Vec::from_raw_parts( - l438.cast(), - len440, - len440, - ); - let l441 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l445 = i32::from( - *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - let l449 = *base - .add(24 + 8 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l450 = *base - .add(24 + 9 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let base459 = l449; - let len459 = l450; - let mut result459 = _rt::Vec::with_capacity(len459); - for i in 0..len459 { - let base = base459 - .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e459 = { - let l451 = *base.add(0).cast::<*mut u8>(); - let l452 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let len453 = l452; - let bytes453 = _rt::Vec::from_raw_parts( - l451.cast(), - len453, - len453, - ); - let l454 = i32::from( - *base - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::context::AttributeValue as V458; - let v458 = match l454 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e458 = { - let l455 = *base - .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l456 = *base - .add(4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len457 = l456; - let bytes457 = _rt::Vec::from_raw_parts( - l455.cast(), - len457, - len457, - ); - _rt::string_lift(bytes457) - }; - V458::String(e458) - } - }; - super::super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes453), - value: v458, - } - }; - result459.push(e459); - } - _rt::cabi_dealloc( - base459, - len459 * (5 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - super::super::super::super::golem::api::oplog::StartSpanParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l436 as u64, - nanoseconds: l437 as u32, - }, - span_id: _rt::string_lift(bytes440), - parent: match l441 { - 0 => None, - 1 => { - let e = { - let l442 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l443 = *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len444 = l443; - let bytes444 = _rt::Vec::from_raw_parts( - l442.cast(), - len444, - len444, - ); - _rt::string_lift(bytes444) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - linked_context_id: match l445 { - 0 => None, - 1 => { - let e = { - let l446 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l447 = *base - .add(24 + 7 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len448 = l447; - let bytes448 = _rt::Vec::from_raw_parts( - l446.cast(), - len448, - len448, - ); - _rt::string_lift(bytes448) - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - attributes: result459, - } - }; - V516::StartSpan(e516) - } - 29 => { - let e516 = { - let l460 = *base.add(8).cast::(); - let l461 = *base.add(16).cast::(); - let l462 = *base.add(24).cast::<*mut u8>(); - let l463 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len464 = l463; - let bytes464 = _rt::Vec::from_raw_parts( - l462.cast(), - len464, - len464, - ); - super::super::super::super::golem::api::oplog::FinishSpanParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l460 as u64, - nanoseconds: l461 as u32, - }, - span_id: _rt::string_lift(bytes464), - } - }; - V516::FinishSpan(e516) - } - 30 => { - let e516 = { - let l465 = *base.add(8).cast::(); - let l466 = *base.add(16).cast::(); - let l467 = *base.add(24).cast::<*mut u8>(); - let l468 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len469 = l468; - let bytes469 = _rt::Vec::from_raw_parts( - l467.cast(), - len469, - len469, - ); - let l470 = *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l471 = *base - .add(24 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len472 = l471; - let bytes472 = _rt::Vec::from_raw_parts( - l470.cast(), - len472, - len472, - ); - let l473 = i32::from( - *base - .add(24 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - use super::super::super::super::golem::api::context::AttributeValue as V477; - let v477 = match l473 { - n => { - debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e477 = { - let l474 = *base - .add(24 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l475 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len476 = l475; - let bytes476 = _rt::Vec::from_raw_parts( - l474.cast(), - len476, - len476, - ); - _rt::string_lift(bytes476) - }; - V477::String(e477) - } - }; - super::super::super::super::golem::api::oplog::SetSpanAttributeParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l465 as u64, - nanoseconds: l466 as u32, - }, - span_id: _rt::string_lift(bytes469), - key: _rt::string_lift(bytes472), - value: v477, - } - }; - V516::SetSpanAttribute(e516) - } - 31 => { - let e516 = { - let l478 = *base.add(8).cast::(); - let l479 = *base.add(16).cast::(); - let l480 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::host::PersistenceLevel as V481; - let v481 = match l480 { - 0 => V481::PersistNothing, - 1 => V481::PersistRemoteSideEffects, - n => { - debug_assert_eq!(n, 2, "invalid enum discriminant"); - V481::Smart - } - }; - super::super::super::super::golem::api::oplog::ChangePersistenceLevelParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l478 as u64, - nanoseconds: l479 as u32, - }, - persistence_level: v481, - } - }; - V516::ChangePersistenceLevel(e516) - } - 32 => { - let e516 = { - let l482 = *base.add(8).cast::(); - let l483 = *base.add(16).cast::(); - let l484 = *base.add(24).cast::<*mut u8>(); - let l485 = *base - .add(24 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len486 = l485; - let bytes486 = _rt::Vec::from_raw_parts( - l484.cast(), - len486, - len486, - ); - let l487 = i32::from( - *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(), - ); - super::super::super::super::golem::api::oplog::RawBeginRemoteTransactionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l482 as u64, - nanoseconds: l483 as u32, - }, - transaction_id: _rt::string_lift(bytes486), - original_begin_index: match l487 { - 0 => None, - 1 => { - let e = { - let l488 = *base - .add(32 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - l488 as u64 - }; - Some(e) - } - _ => _rt::invalid_enum_discriminant(), - }, - } - }; - V516::BeginRemoteTransaction(e516) - } - 33 => { - let e516 = { - let l489 = *base.add(8).cast::(); - let l490 = *base.add(16).cast::(); - let l491 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RemoteTransactionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l489 as u64, - nanoseconds: l490 as u32, - }, - begin_index: l491 as u64, - } - }; - V516::PreCommitRemoteTransaction(e516) - } - 34 => { - let e516 = { - let l492 = *base.add(8).cast::(); - let l493 = *base.add(16).cast::(); - let l494 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RemoteTransactionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l492 as u64, - nanoseconds: l493 as u32, - }, - begin_index: l494 as u64, - } - }; - V516::PreRollbackRemoteTransaction(e516) - } - 35 => { - let e516 = { - let l495 = *base.add(8).cast::(); - let l496 = *base.add(16).cast::(); - let l497 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RemoteTransactionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l495 as u64, - nanoseconds: l496 as u32, - }, - begin_index: l497 as u64, - } - }; - V516::CommittedRemoteTransaction(e516) - } - 36 => { - let e516 = { - let l498 = *base.add(8).cast::(); - let l499 = *base.add(16).cast::(); - let l500 = *base.add(24).cast::(); - super::super::super::super::golem::api::oplog::RemoteTransactionParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l498 as u64, - nanoseconds: l499 as u32, - }, - begin_index: l500 as u64, - } - }; - V516::RolledBackRemoteTransaction(e516) - } - n => { - debug_assert_eq!(n, 37, "invalid enum discriminant"); - let e516 = { - let l501 = *base.add(8).cast::(); - let l502 = *base.add(16).cast::(); - let l503 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::oplog::OplogPayload as V512; - let v512 = match l503 { - 0 => { - let e512 = { - let l504 = *base.add(32).cast::<*mut u8>(); - let l505 = *base - .add(32 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len506 = l505; - _rt::Vec::from_raw_parts(l504.cast(), len506, len506) - }; - V512::Inline(e512) - } - n => { - debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e512 = { - let l507 = *base.add(32).cast::(); - let l508 = *base.add(40).cast::(); - let l509 = *base.add(48).cast::<*mut u8>(); - let l510 = *base - .add(48 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len511 = l510; - super::super::super::super::golem::api::oplog::OplogExternalPayload { - payload_id: super::super::super::super::golem::core::types::Uuid { - high_bits: l507 as u64, - low_bits: l508 as u64, - }, - md5_hash: _rt::Vec::from_raw_parts( - l509.cast(), - len511, - len511, - ), - } - }; - V512::External(e512) - } - }; - let l513 = *base - .add(48 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l514 = *base - .add(48 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::(); - let len515 = l514; - let bytes515 = _rt::Vec::from_raw_parts( - l513.cast(), - len515, - len515, - ); - super::super::super::super::golem::api::oplog::RawSnapshotParameters { - timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l501 as u64, - nanoseconds: l502 as u32, - }, - data: v512, - mime_type: _rt::string_lift(bytes515), - } - }; - V516::Snapshot(e516) - } - }; - v516 - }; - result517.push(e517); - } - _rt::cabi_dealloc( - base517, - len517 * (144 + 12 * ::core::mem::size_of::<*const u8>()), - 8, - ); - let result518 = T::process( - AccountInfo { - account_id: super::super::super::super::golem::core::types::AccountId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l0 as u64, - low_bits: l1 as u64, - }, - }, - }, - result10, - super::super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l11 as u64, - low_bits: l12 as u64, - }, - }, - super::super::super::super::golem::core::types::AgentId { - component_id: super::super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l13 as u64, - low_bits: l14 as u64, - }, - }, - agent_id: _rt::string_lift(bytes17), - }, - super::super::super::super::golem::api::host::AgentMetadata { - agent_id: super::super::super::super::golem::core::types::AgentId { - component_id: super::super::super::super::golem::core::types::ComponentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l18 as u64, - low_bits: l19 as u64, - }, - }, - agent_id: _rt::string_lift(bytes22), - }, - args: result28, - env: result37, - config_vars: result46, - status: super::super::super::super::golem::api::host::AgentStatus::_lift( - l47 as u8, - ), - component_revision: l48 as u64, - retry_count: l49 as u64, - environment_id: super::super::super::super::golem::api::host::EnvironmentId { - uuid: super::super::super::super::golem::core::types::Uuid { - high_bits: l50 as u64, - low_bits: l51 as u64, - }, - }, - }, - l52 as u64, - result517, - ); - _rt::cabi_dealloc( - arg0, - 112 + 14 * ::core::mem::size_of::<*const u8>(), - 8, - ); - let ptr519 = (&raw mut _RET_AREA.0).cast::(); - match result518 { - Ok(_) => { - *ptr519.add(0).cast::() = (0i32) as u8; - } - Err(e) => { - *ptr519.add(0).cast::() = (1i32) as u8; - let vec520 = (e.into_bytes()).into_boxed_slice(); - let ptr520 = vec520.as_ptr().cast::(); - let len520 = vec520.len(); - ::core::mem::forget(vec520); - *ptr519 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len520; - *ptr519 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr520.cast_mut(); - } - }; - ptr519 - } - #[doc(hidden)] - #[allow(non_snake_case)] - pub unsafe fn __post_return_process(arg0: *mut u8) { - let l0 = i32::from(*arg0.add(0).cast::()); - match l0 { - 0 => {} - _ => { - let l1 = *arg0 - .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>(); - let l2 = *arg0 - .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::(); - _rt::cabi_dealloc(l1, l2, 1); - } - } - } - pub trait Guest { - /// Called when one of the agents the plugin is activated on has written new entries to its oplog. - /// - /// There are no guarantees for the number of processors running at the same time, and different entries from the same agent - /// may be sent to different processor instances. - /// - /// The `account-info` parameters contains details of the account the installation belongs to. - /// The `config` parameter contains the configuration parameters for the plugin, as specified in the plugin installation - /// The `component-id` parameter contains the identifier of the component the plugin was installed to. - /// The `agent-id` parameter identifies the agent. - /// The `metadata` parameter contains the latest metadata of the agent. - /// The `first-entry-index` parameter contains the index of the first entry in the list of `entries`. - /// The `entries` parameter always contains at least one element. - fn process( - account_info: AccountInfo, - config: _rt::Vec<(_rt::String, _rt::String)>, - component_id: ComponentId, - agent_id: AgentId, - metadata: AgentMetadata, - first_entry_index: OplogIndex, - entries: _rt::Vec, - ) -> Result<(), _rt::String>; - } - #[doc(hidden)] - macro_rules! __export_golem_api_oplog_processor_1_5_0_cabi { - ($ty:ident with_types_in $($path_to_types:tt)*) => { - const _ : () = { #[unsafe (export_name = - "golem:api/oplog-processor@1.5.0#process")] unsafe extern "C" fn - export_process(arg0 : * mut u8,) -> * mut u8 { unsafe { - $($path_to_types)*:: _export_process_cabi::<$ty > (arg0) } } - #[unsafe (export_name = - "cabi_post_golem:api/oplog-processor@1.5.0#process")] unsafe - extern "C" fn _post_return_process(arg0 : * mut u8,) { unsafe { - $($path_to_types)*:: __post_return_process::<$ty > (arg0) } } }; - }; - } - #[doc(hidden)] - pub(crate) use __export_golem_api_oplog_processor_1_5_0_cabi; - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct _RetArea( - [::core::mem::MaybeUninit< - u8, - >; 3 * ::core::mem::size_of::<*const u8>()], - ); - static mut _RET_AREA: _RetArea = _RetArea( - [::core::mem::MaybeUninit::uninit(); 3 - * ::core::mem::size_of::<*const u8>()], - ); - } - } - pub mod component { - #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)] - pub mod api { - #[used] - #[doc(hidden)] - static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_custom_section_describing_imports; - use super::super::super::super::_rt; - #[doc(hidden)] - #[allow(non_snake_case)] - pub unsafe fn _export_get_invoked_functions_cabi() -> *mut u8 { - #[cfg(target_arch = "wasm32")] _rt::run_ctors_once(); - let result0 = T::get_invoked_functions(); - let ptr1 = (&raw mut _RET_AREA.0).cast::(); - let vec3 = result0; - let len3 = vec3.len(); - let layout3 = _rt::alloc::Layout::from_size_align_unchecked( - vec3.len() * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - let result3 = if layout3.size() != 0 { - let ptr = _rt::alloc::alloc(layout3).cast::(); - if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout3); - } - ptr - } else { - ::core::ptr::null_mut() - }; - for (i, e) in vec3.into_iter().enumerate() { - let base = result3 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let vec2 = (e.into_bytes()).into_boxed_slice(); - let ptr2 = vec2.as_ptr().cast::(); - let len2 = vec2.len(); - ::core::mem::forget(vec2); - *base - .add(::core::mem::size_of::<*const u8>()) - .cast::() = len2; - *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); - } - } - *ptr1.add(::core::mem::size_of::<*const u8>()).cast::() = len3; - *ptr1.add(0).cast::<*mut u8>() = result3; - ptr1 - } - #[doc(hidden)] - #[allow(non_snake_case)] - pub unsafe fn __post_return_get_invoked_functions( - arg0: *mut u8, - ) { - let l0 = *arg0.add(0).cast::<*mut u8>(); - let l1 = *arg0 - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - let base4 = l0; - let len4 = l1; - for i in 0..len4 { - let base = base4 - .add(i * (2 * ::core::mem::size_of::<*const u8>())); - { - let l2 = *base.add(0).cast::<*mut u8>(); - let l3 = *base - .add(::core::mem::size_of::<*const u8>()) - .cast::(); - _rt::cabi_dealloc(l2, l3, 1); - } - } - _rt::cabi_dealloc( - base4, - len4 * (2 * ::core::mem::size_of::<*const u8>()), - ::core::mem::size_of::<*const u8>(), - ); - } - pub trait Guest { - fn get_invoked_functions() -> _rt::Vec<_rt::String>; - } - #[doc(hidden)] - macro_rules! __export_golem_component_api_cabi { - ($ty:ident with_types_in $($path_to_types:tt)*) => { - const _ : () = { #[unsafe (export_name = - "golem:component/api#get-invoked-functions")] unsafe extern "C" - fn export_get_invoked_functions() -> * mut u8 { unsafe { - $($path_to_types)*:: _export_get_invoked_functions_cabi::<$ty > - () } } #[unsafe (export_name = - "cabi_post_golem:component/api#get-invoked-functions")] unsafe - extern "C" fn _post_return_get_invoked_functions(arg0 : * mut - u8,) { unsafe { $($path_to_types)*:: - __post_return_get_invoked_functions::<$ty > (arg0) } } }; - }; - } - #[doc(hidden)] - pub(crate) use __export_golem_component_api_cabi; - #[cfg_attr(target_pointer_width = "64", repr(align(8)))] - #[cfg_attr(target_pointer_width = "32", repr(align(4)))] - struct _RetArea( - [::core::mem::MaybeUninit< - u8, - >; 2 * ::core::mem::size_of::<*const u8>()], - ); - static mut _RET_AREA: _RetArea = _RetArea( - [::core::mem::MaybeUninit::uninit(); 2 - * ::core::mem::size_of::<*const u8>()], - ); - } - } - } -} -#[rustfmt::skip] -mod _rt { - #![allow(dead_code, clippy::all)] - pub use alloc_crate::string::String; - pub use alloc_crate::vec::Vec; - pub unsafe fn string_lift(bytes: Vec) -> String { - if cfg!(debug_assertions) { - String::from_utf8(bytes).unwrap() - } else { - String::from_utf8_unchecked(bytes) - } - } - pub unsafe fn invalid_enum_discriminant() -> T { - if cfg!(debug_assertions) { - panic!("invalid enum discriminant") - } else { - unsafe { core::hint::unreachable_unchecked() } - } - } - pub fn as_i64(t: T) -> i64 { - t.as_i64() - } - pub trait AsI64 { - fn as_i64(self) -> i64; - } - impl<'a, T: Copy + AsI64> AsI64 for &'a T { - fn as_i64(self) -> i64 { - (*self).as_i64() - } - } - impl AsI64 for i64 { - #[inline] - fn as_i64(self) -> i64 { - self as i64 - } - } - impl AsI64 for u64 { - #[inline] - fn as_i64(self) -> i64 { - self as i64 - } - } - use core::fmt; - use core::marker; - use core::sync::atomic::{AtomicU32, Ordering::Relaxed}; - /// A type which represents a component model resource, either imported or - /// exported into this component. - /// - /// This is a low-level wrapper which handles the lifetime of the resource - /// (namely this has a destructor). The `T` provided defines the component model - /// intrinsics that this wrapper uses. - /// - /// One of the chief purposes of this type is to provide `Deref` implementations - /// to access the underlying data when it is owned. - /// - /// This type is primarily used in generated code for exported and imported - /// resources. - #[repr(transparent)] - pub struct Resource { - handle: AtomicU32, - _marker: marker::PhantomData, - } - /// A trait which all wasm resources implement, namely providing the ability to - /// drop a resource. - /// - /// This generally is implemented by generated code, not user-facing code. - #[allow(clippy::missing_safety_doc)] - pub unsafe trait WasmResource { - /// Invokes the `[resource-drop]...` intrinsic. - unsafe fn drop(handle: u32); - } - impl Resource { - #[doc(hidden)] - pub unsafe fn from_handle(handle: u32) -> Self { - debug_assert!(handle != u32::MAX); - Self { - handle: AtomicU32::new(handle), - _marker: marker::PhantomData, - } - } - /// Takes ownership of the handle owned by `resource`. - /// - /// Note that this ideally would be `into_handle` taking `Resource` by - /// ownership. The code generator does not enable that in all situations, - /// unfortunately, so this is provided instead. - /// - /// Also note that `take_handle` is in theory only ever called on values - /// owned by a generated function. For example a generated function might - /// take `Resource` as an argument but then call `take_handle` on a - /// reference to that argument. In that sense the dynamic nature of - /// `take_handle` should only be exposed internally to generated code, not - /// to user code. - #[doc(hidden)] - pub fn take_handle(resource: &Resource) -> u32 { - resource.handle.swap(u32::MAX, Relaxed) - } - #[doc(hidden)] - pub fn handle(resource: &Resource) -> u32 { - resource.handle.load(Relaxed) - } - } - impl fmt::Debug for Resource { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("Resource").field("handle", &self.handle).finish() - } - } - impl Drop for Resource { - fn drop(&mut self) { - unsafe { - match self.handle.load(Relaxed) { - u32::MAX => {} - other => T::drop(other), - } - } - } - } - pub unsafe fn bool_lift(val: u8) -> bool { - if cfg!(debug_assertions) { - match val { - 0 => false, - 1 => true, - _ => panic!("invalid bool discriminant"), - } - } else { - val != 0 - } - } - pub use alloc_crate::alloc; - pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { - if size == 0 { - return; - } - let layout = alloc::Layout::from_size_align_unchecked(size, align); - alloc::dealloc(ptr, layout); - } - pub fn as_i32(t: T) -> i32 { - t.as_i32() - } - pub trait AsI32 { - fn as_i32(self) -> i32; - } - impl<'a, T: Copy + AsI32> AsI32 for &'a T { - fn as_i32(self) -> i32 { - (*self).as_i32() - } - } - impl AsI32 for i32 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for u32 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for i16 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for u16 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for i8 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for u8 { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for char { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - impl AsI32 for usize { - #[inline] - fn as_i32(self) -> i32 { - self as i32 - } - } - pub fn as_f64(t: T) -> f64 { - t.as_f64() - } - pub trait AsF64 { - fn as_f64(self) -> f64; - } - impl<'a, T: Copy + AsF64> AsF64 for &'a T { - fn as_f64(self) -> f64 { - (*self).as_f64() - } - } - impl AsF64 for f64 { - #[inline] - fn as_f64(self) -> f64 { - self as f64 - } - } - pub fn as_f32(t: T) -> f32 { - t.as_f32() - } - pub trait AsF32 { - fn as_f32(self) -> f32; - } - impl<'a, T: Copy + AsF32> AsF32 for &'a T { - fn as_f32(self) -> f32 { - (*self).as_f32() - } - } - impl AsF32 for f32 { - #[inline] - fn as_f32(self) -> f32 { - self as f32 - } - } - pub unsafe fn char_lift(val: u32) -> char { - if cfg!(debug_assertions) { - core::char::from_u32(val).unwrap() - } else { - core::char::from_u32_unchecked(val) - } - } - #[cfg(target_arch = "wasm32")] - pub fn run_ctors_once() { - wit_bindgen_rt::run_ctors_once(); - } - extern crate alloc as alloc_crate; -} -/// Generates `#[unsafe(no_mangle)]` functions to export the specified type as -/// the root implementation of all generated traits. -/// -/// For more information see the documentation of `wit_bindgen::generate!`. -/// -/// ```rust -/// # macro_rules! export{ ($($t:tt)*) => (); } -/// # trait Guest {} -/// struct MyType; -/// -/// impl Guest for MyType { -/// // ... -/// } -/// -/// export!(MyType); -/// ``` -#[allow(unused_macros)] -#[doc(hidden)] -macro_rules! __export_oplog_processor_impl { - ($ty:ident) => { - self::export!($ty with_types_in self); - }; - ($ty:ident with_types_in $($path_to_types_root:tt)*) => { - $($path_to_types_root)*:: - exports::golem::component::api::__export_golem_component_api_cabi!($ty - with_types_in $($path_to_types_root)*:: exports::golem::component::api); - $($path_to_types_root)*:: - exports::golem::api::oplog_processor::__export_golem_api_oplog_processor_1_5_0_cabi!($ty - with_types_in $($path_to_types_root)*:: exports::golem::api::oplog_processor); - }; -} -#[doc(inline)] -pub(crate) use __export_oplog_processor_impl as export; -#[cfg(target_arch = "wasm32")] -#[unsafe(link_section = "component-type:wit-bindgen:0.41.0:golem:component:oplog-processor:encoded world")] -#[doc(hidden)] -#[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 14967] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xf1s\x01A\x02\x01A-\x01\ -B\x05\x01r\x02\x07secondsw\x0bnanosecondsy\x04\0\x08datetime\x03\0\0\x01@\0\0\x01\ -\x04\0\x03now\x01\x02\x04\0\x0aresolution\x01\x02\x03\0\x1cwasi:clocks/wall-cloc\ -k@0.2.3\x05\0\x01BZ\x01r\x02\x09high-bitsw\x08low-bitsw\x04\0\x04uuid\x03\0\0\x01\ -r\x01\x04uuid\x01\x04\0\x0ccomponent-id\x03\0\x02\x01r\x02\x0ccomponent-id\x03\x08\ -agent-ids\x04\0\x08agent-id\x03\0\x04\x01r\x01\x04uuid\x01\x04\0\x0aaccount-id\x03\ -\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x08agent-id\x05\x09oplog-idx\ -\x09\x04\0\x0apromise-id\x03\0\x0a\x01z\x04\0\x0anode-index\x03\0\x0c\x01w\x04\0\ -\x0bresource-id\x03\0\x0e\x01m\x02\x05owned\x08borrowed\x04\0\x0dresource-mode\x03\ -\0\x10\x01o\x02s\x0d\x01p\x12\x01k\x0d\x01o\x02s\x14\x01p\x15\x01ps\x01p\x0d\x01\ -o\x02\x14\x14\x01o\x02\x0f\x11\x01q\x16\x0brecord-type\x01\x13\0\x0cvariant-type\ -\x01\x16\0\x09enum-type\x01\x17\0\x0aflags-type\x01\x17\0\x0atuple-type\x01\x18\0\ -\x09list-type\x01\x0d\0\x0boption-type\x01\x0d\0\x0bresult-type\x01\x19\0\x0cpri\ -m-u8-type\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0c\ -prim-s8-type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0d\ -prim-f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\ -\0\x10prim-string-type\0\0\x0bhandle-type\x01\x1a\0\x04\0\x0dwit-type-node\x03\0\ -\x1b\x01ks\x01r\x03\x04name\x1d\x05owner\x1d\x04type\x1c\x04\0\x13named-wit-type\ --node\x03\0\x1e\x01p\x1f\x01r\x01\x05nodes\x20\x04\0\x08wit-type\x03\0!\x01r\x01\ -\x05values\x04\0\x03uri\x03\0#\x01o\x02y\x14\x01p\x7f\x01j\x01\x14\x01\x14\x01o\x02\ -$w\x01q\x16\x0crecord-value\x01\x18\0\x0dvariant-value\x01%\0\x0aenum-value\x01y\ -\0\x0bflags-value\x01&\0\x0btuple-value\x01\x18\0\x0alist-value\x01\x18\0\x0copt\ -ion-value\x01\x14\0\x0cresult-value\x01'\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ -prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ -s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ -rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01(\0\x04\ -\0\x08wit-node\x03\0)\x01p*\x01r\x01\x05nodes+\x04\0\x09wit-value\x03\0,\x01r\x02\ -\x05value-\x03typ\"\x04\0\x0evalue-and-type\x03\0.\x01s\x04\0\x03url\x03\00\x01r\ -\x01\x0dlanguage-codes\x04\0\x09text-type\x03\02\x01k3\x01r\x02\x04datas\x09text\ --type4\x04\0\x0btext-source\x03\05\x01q\x02\x03url\x01s\0\x06inline\x016\0\x04\0\ -\x0etext-reference\x03\07\x01r\x01\x09mime-types\x04\0\x0bbinary-type\x03\09\x01\ -p}\x01r\x02\x04data;\x0bbinary-type:\x04\0\x0dbinary-source\x03\0<\x01q\x02\x03u\ -rl\x011\0\x06inline\x01=\0\x04\0\x10binary-reference\x03\0>\x01p3\x01k\xc0\0\x01\ -r\x01\x0crestrictions\xc1\0\x04\0\x0ftext-descriptor\x03\0B\x01p:\x01k\xc4\0\x01\ -r\x01\x0crestrictions\xc5\0\x04\0\x11binary-descriptor\x03\0F\x01q\x03\x0fcompon\ -ent-model\x01\"\0\x11unstructured-text\x01\xc3\0\0\x13unstructured-binary\x01\xc7\ -\0\0\x04\0\x0eelement-schema\x03\0H\x01q\x03\x0fcomponent-model\x01-\0\x11unstru\ -ctured-text\x018\0\x13unstructured-binary\x01?\0\x04\0\x0delement-value\x03\0J\x01\ -o\x02s\xc9\0\x01p\xcc\0\x01q\x02\x05tuple\x01\xcd\0\0\x0amultimodal\x01\xcd\0\0\x04\ -\0\x0bdata-schema\x03\0N\x01p\xcb\0\x01o\x02s\xcb\0\x01p\xd1\0\x01q\x02\x05tuple\ -\x01\xd0\0\0\x0amultimodal\x01\xd2\0\0\x04\0\x0adata-value\x03\0S\x01j\x01\x01\x01\ -s\x01@\x01\x04uuids\0\xd5\0\x04\0\x0aparse-uuid\x01V\x01@\x01\x04uuid\x01\0s\x04\ -\0\x0euuid-to-string\x01W\x03\0\x16golem:core/types@1.5.0\x05\x01\x01B\x0a\x04\0\ -\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[method]pollable\ -.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollable.block\x01\x03\ -\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\0\x12wasi:io/\ -poll@0.2.3\x05\x02\x02\x03\0\x02\x08pollable\x01B\x0f\x02\x03\x02\x01\x03\x04\0\x08\ -pollable\x03\0\0\x01w\x04\0\x07instant\x03\0\x02\x01w\x04\0\x08duration\x03\0\x04\ -\x01@\0\0\x03\x04\0\x03now\x01\x06\x01@\0\0\x05\x04\0\x0aresolution\x01\x07\x01i\ -\x01\x01@\x01\x04when\x03\0\x08\x04\0\x11subscribe-instant\x01\x09\x01@\x01\x04w\ -hen\x05\0\x08\x04\0\x12subscribe-duration\x01\x0a\x03\0!wasi:clocks/monotonic-cl\ -ock@0.2.3\x05\x04\x02\x03\0\x03\x08duration\x02\x03\0\x01\x0ccomponent-id\x02\x03\ -\0\x01\x04uuid\x02\x03\0\x01\x0evalue-and-type\x02\x03\0\x01\x08agent-id\x02\x03\ -\0\x01\x0apromise-id\x02\x03\0\x01\x0boplog-index\x01B\x87\x01\x02\x03\x02\x01\x05\ -\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x06\x04\0\x0ccomponent-id\x03\0\x02\x02\ -\x03\x02\x01\x07\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x08\x04\0\x0evalue-and-\ -type\x03\0\x06\x02\x03\x02\x01\x09\x04\0\x08agent-id\x03\0\x08\x02\x03\x02\x01\x0a\ -\x04\0\x0apromise-id\x03\0\x0a\x02\x03\x02\x01\x0b\x04\0\x0boplog-index\x03\0\x0c\ -\x02\x03\x02\x01\x03\x04\0\x08pollable\x03\0\x0e\x01w\x04\0\x12component-revisio\ -n\x03\0\x10\x01r\x01\x04uuid\x05\x04\0\x0eenvironment-id\x03\0\x12\x01ku\x01r\x05\ -\x0cmax-attemptsy\x09min-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter\ --factor\x14\x04\0\x0cretry-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bp\ -ersist-remote-side-effects\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\ -\x01m\x02\x09automatic\x0esnapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\ -\x05equal\x09not-equal\x0dgreater-equal\x07greater\x0aless-equal\x04less\x04\0\x11\ -filter-comparator\x03\0\x1b\x01m\x05\x05equal\x09not-equal\x04like\x08not-like\x0b\ -starts-with\x04\0\x18string-filter-comparator\x03\0\x1d\x01m\x07\x07running\x04i\ -dle\x09suspended\x0binterrupted\x08retrying\x06failed\x06exited\x04\0\x0cagent-s\ -tatus\x03\0\x1f\x01r\x02\x0acomparator\x1e\x05values\x04\0\x11agent-name-filter\x03\ -\0!\x01r\x02\x0acomparator\x1c\x05value\x20\x04\0\x13agent-status-filter\x03\0#\x01\ -r\x02\x0acomparator\x1c\x05valuew\x04\0\x14agent-version-filter\x03\0%\x01r\x02\x0a\ -comparator\x1c\x05valuew\x04\0\x17agent-created-at-filter\x03\0'\x01r\x03\x04nam\ -es\x0acomparator\x1e\x05values\x04\0\x10agent-env-filter\x03\0)\x01r\x03\x04name\ -s\x0acomparator\x1e\x05values\x04\0\x18agent-config-vars-filter\x03\0+\x01q\x06\x04\ -name\x01\"\0\x06status\x01$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\ -\0\x10wasi-config-vars\x01,\0\x04\0\x15agent-property-filter\x03\0-\x01p.\x01r\x01\ -\x07filters/\x04\0\x10agent-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x10\ -agent-any-filter\x03\03\x01ps\x01o\x02ss\x01p6\x01r\x08\x08agent-id\x09\x04args5\ -\x03env7\x0bconfig-vars7\x06status\x20\x12component-revisionw\x0bretry-countw\x0e\ -environment-id\x13\x04\0\x0eagent-metadata\x03\08\x04\0\x0aget-agents\x03\x01\x01\ -q\x02\x15revert-to-oplog-index\x01\x0d\0\x17revert-last-invocations\x01w\0\x04\0\ -\x13revert-agent-target\x03\0;\x01r\x01\x11forked-phantom-id\x05\x04\0\x0cfork-d\ -etails\x03\0=\x01q\x02\x08original\x01>\0\x06forked\x01>\0\x04\0\x0bfork-result\x03\ -\0?\x04\0\x12get-promise-result\x03\x01\x01p}\x01r\x02\x04data\xc2\0\x09mime-typ\ -es\x04\0\x08snapshot\x03\0C\x01k4\x01i:\x01@\x03\x0ccomponent-id\x03\x06filter\xc5\ -\0\x07precise\x7f\0\xc6\0\x04\0\x17[constructor]get-agents\x01G\x01h:\x01p9\x01k\ -\xc9\0\x01@\x01\x04self\xc8\0\0\xca\0\x04\0\x1b[method]get-agents.get-next\x01K\x01\ -hA\x01i\x0f\x01@\x01\x04self\xcc\0\0\xcd\0\x04\0$[method]get-promise-result.subs\ -cribe\x01N\x01k\xc2\0\x01@\x01\x04self\xcc\0\0\xcf\0\x04\0\x1e[method]get-promis\ -e-result.get\x01P\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01Q\x01iA\x01@\x01\x0apr\ -omise-id\x0b\0\xd2\0\x04\0\x0bget-promise\x01S\x01@\x02\x0apromise-id\x0b\x04dat\ -a\xc2\0\0\x7f\x04\0\x10complete-promise\x01T\x01@\0\0\x0d\x04\0\x0fget-oplog-ind\ -ex\x01U\x01@\x01\x09oplog-idx\x0d\x01\0\x04\0\x0fset-oplog-index\x01V\x01@\x01\x08\ -replicas}\x01\0\x04\0\x0coplog-commit\x01W\x04\0\x14mark-begin-operation\x01U\x01\ -@\x01\x05begin\x0d\x01\0\x04\0\x12mark-end-operation\x01X\x01@\0\0\x16\x04\0\x10\ -get-retry-policy\x01Y\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-\ -policy\x01Z\x01@\0\0\x18\x04\0\x1bget-oplog-persistence-level\x01[\x01@\x01\x15n\ -ew-persistence-level\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01\\\x01@\0\ -\0\x7f\x04\0\x14get-idempotence-mode\x01]\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\ -\x14set-idempotence-mode\x01^\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01\ -_\x01@\x03\x08agent-id\x09\x0ftarget-revision\x11\x04mode\x1a\x01\0\x04\0\x0cupd\ -ate-agent\x01`\x01@\0\09\x04\0\x11get-self-metadata\x01a\x01k9\x01@\x01\x08agent\ --id\x09\0\xe2\0\x04\0\x12get-agent-metadata\x01c\x01@\x03\x0fsource-agent-id\x09\ -\x0ftarget-agent-id\x09\x11oplog-idx-cut-off\x0d\x01\0\x04\0\x0afork-agent\x01d\x01\ -@\x02\x08agent-id\x09\x0drevert-target<\x01\0\x04\0\x0crevert-agent\x01e\x01k\x03\ -\x01@\x01\x13component-references\0\xe6\0\x04\0\x14resolve-component-id\x01g\x01\ -k\x09\x01@\x02\x13component-references\x0aagent-names\0\xe8\0\x04\0\x10resolve-a\ -gent-id\x01i\x04\0\x17resolve-agent-id-strict\x01i\x01@\0\0\xc0\0\x04\0\x04fork\x01\ -j\x03\0\x14golem:api/host@1.5.0\x05\x0c\x02\x03\0\0\x08datetime\x01B7\x02\x03\x02\ -\x01\x0d\x04\0\x08datetime\x03\0\0\x04\0\x04span\x03\x01\x04\0\x12invocation-con\ -text\x03\x01\x01q\x01\x06string\x01s\0\x04\0\x0fattribute-value\x03\0\x04\x01r\x02\ -\x03keys\x05value\x05\x04\0\x09attribute\x03\0\x06\x01p\x05\x01r\x02\x03keys\x06\ -values\x08\x04\0\x0fattribute-chain\x03\0\x09\x01s\x04\0\x08trace-id\x03\0\x0b\x01\ -s\x04\0\x07span-id\x03\0\x0d\x01h\x02\x01@\x01\x04self\x0f\0\x01\x04\0\x17[metho\ -d]span.started-at\x01\x10\x01@\x03\x04self\x0f\x04names\x05value\x05\x01\0\x04\0\ -\x1a[method]span.set-attribute\x01\x11\x01p\x07\x01@\x02\x04self\x0f\x0aattribut\ -es\x12\x01\0\x04\0\x1b[method]span.set-attributes\x01\x13\x01@\x01\x04self\x0f\x01\ -\0\x04\0\x13[method]span.finish\x01\x14\x01h\x03\x01@\x01\x04self\x15\0\x0c\x04\0\ -#[method]invocation-context.trace-id\x01\x16\x01@\x01\x04self\x15\0\x0e\x04\0\"[\ -method]invocation-context.span-id\x01\x17\x01i\x03\x01k\x18\x01@\x01\x04self\x15\ -\0\x19\x04\0![method]invocation-context.parent\x01\x1a\x01k\x05\x01@\x03\x04self\ -\x15\x03keys\x09inherited\x7f\0\x1b\x04\0([method]invocation-context.get-attribu\ -te\x01\x1c\x01@\x02\x04self\x15\x09inherited\x7f\0\x12\x04\0)[method]invocation-\ -context.get-attributes\x01\x1d\x01@\x02\x04self\x15\x03keys\0\x08\x04\0.[method]\ -invocation-context.get-attribute-chain\x01\x1e\x01p\x0a\x01@\x01\x04self\x15\0\x1f\ -\x04\0/[method]invocation-context.get-attribute-chains\x01\x20\x01o\x02ss\x01p!\x01\ -@\x01\x04self\x15\0\"\x04\00[method]invocation-context.trace-context-headers\x01\ -#\x01i\x02\x01@\x01\x04names\0$\x04\0\x0astart-span\x01%\x01@\0\0\x18\x04\0\x0fc\ -urrent-context\x01&\x01@\x01\x05allow\x7f\0\x7f\x04\0&allow-forwarding-trace-con\ -text-headers\x01'\x03\0\x17golem:api/context@1.5.0\x05\x0e\x02\x03\0\x01\x0aacco\ -unt-id\x02\x03\0\x01\x0adata-value\x02\x03\0\x01\x0bdata-schema\x02\x03\0\x01\x09\ -wit-value\x02\x03\0\x04\x12component-revision\x02\x03\0\x04\x0boplog-index\x02\x03\ -\0\x04\x11persistence-level\x02\x03\0\x04\x0eenvironment-id\x02\x03\0\x04\x0cret\ -ry-policy\x02\x03\0\x04\x04uuid\x02\x03\0\x04\x08agent-id\x02\x03\0\x04\x08snaps\ -hot\x02\x03\0\x05\x09attribute\x02\x03\0\x05\x0fattribute-value\x02\x03\0\x05\x07\ -span-id\x02\x03\0\x05\x08trace-id\x01B\xdf\x01\x02\x03\x02\x01\x0d\x04\0\x08date\ -time\x03\0\0\x02\x03\x02\x01\x08\x04\0\x0evalue-and-type\x03\0\x02\x02\x03\x02\x01\ -\x0f\x04\0\x0aaccount-id\x03\0\x04\x02\x03\x02\x01\x10\x04\0\x0adata-value\x03\0\ -\x06\x02\x03\x02\x01\x11\x04\0\x0bdata-schema\x03\0\x08\x02\x03\x02\x01\x12\x04\0\ -\x09wit-value\x03\0\x0a\x02\x03\x02\x01\x13\x04\0\x12component-revision\x03\0\x0c\ -\x02\x03\x02\x01\x14\x04\0\x0boplog-index\x03\0\x0e\x02\x03\x02\x01\x15\x04\0\x11\ -persistence-level\x03\0\x10\x02\x03\x02\x01\x16\x04\0\x0eenvironment-id\x03\0\x12\ -\x02\x03\x02\x01\x17\x04\0\x0cretry-policy\x03\0\x14\x02\x03\x02\x01\x18\x04\0\x04\ -uuid\x03\0\x16\x02\x03\x02\x01\x19\x04\0\x08agent-id\x03\0\x18\x02\x03\x02\x01\x1a\ -\x04\0\x08snapshot\x03\0\x1a\x02\x03\x02\x01\x1b\x04\0\x09attribute\x03\0\x1c\x02\ -\x03\x02\x01\x1c\x04\0\x0fattribute-value\x03\0\x1e\x02\x03\x02\x01\x1d\x04\0\x07\ -span-id\x03\0\x20\x02\x03\x02\x01\x1e\x04\0\x08trace-id\x03\0\"\x01k\x0f\x01q\x06\ -\x0aread-local\0\0\x0bwrite-local\0\0\x0bread-remote\0\0\x0cwrite-remote\0\0\x14\ -write-remote-batched\x01$\0\x18write-remote-transaction\x01$\0\x04\0\x15wrapped-\ -function-type\x03\0%\x01o\x02ss\x01p'\x01r\x03\x04names\x07versions\x0aparameter\ -s(\x04\0\x1fplugin-installation-description\x03\0)\x01ps\x01r\x02\x04path+\x05va\ -lue\x0b\x04\0\x1craw-local-agent-config-entry\x03\0,\x01r\x02\x04path+\x05value\x03\ -\x04\0\x18local-agent-config-entry\x03\0.\x01k\x19\x01p*\x01p/\x01r\x0d\x09times\ -tamp\x01\x08agent-id\x19\x12component-revision\x0d\x04args+\x03env(\x0acreated-b\ -y\x05\x0eenvironment-id\x13\x06parent0\x0ecomponent-sizew\x20initial-total-linea\ -r-memory-sizew\x16initial-active-plugins1\x0bconfig-vars(\x12local-agent-config2\ -\x04\0\x11create-parameters\x03\03\x01r\x05\x09timestamp\x01\x0dfunction-names\x07\ -request\x03\x08response\x03\x15wrapped-function-type&\x04\0\x14host-call-paramet\ -ers\x03\05\x01k!\x01kw\x01p\x1d\x01r\x06\x07span-id!\x05start\x01\x06parent7\x0e\ -linked-context8\x0aattributes9\x09inherited\x7f\x04\0\x0flocal-span-data\x03\0:\x01\ -r\x01\x07span-id!\x04\0\x12external-span-data\x03\0<\x01q\x02\x0alocal-span\x01;\ -\0\x0dexternal-span\x01=\0\x04\0\x09span-data\x03\0>\x01r\x03\x09timestamp\x01\x05\ -errors\x0aretry-from\x0f\x04\0\x10error-parameters\x03\0@\x01r\x02\x05start\x0f\x03\ -end\x0f\x04\0\x0coplog-region\x03\0B\x01r\x02\x09timestamp\x01\x04jump\xc3\0\x04\ -\0\x0fjump-parameters\x03\0D\x01r\x02\x09timestamp\x01\x0anew-policy\x15\x04\0\x1e\ -change-retry-policy-parameters\x03\0F\x01r\x02\x09timestamp\x01\x0bbegin-index\x0f\ -\x04\0\x1cend-atomic-region-parameters\x03\0H\x01r\x02\x09timestamp\x01\x0bbegin\ --index\x0f\x04\0\x1bend-remote-write-parameters\x03\0J\x01r\x02\x05value\x07\x06\ -schema\x09\x04\0\x10typed-data-value\x03\0L\x01p?\x01p\xce\0\x01r\x05\x0fidempot\ -ency-keys\x16constructor-parameters\xcd\0\x08trace-ids\x0ctrace-states+\x12invoc\ -ation-context\xcf\0\x04\0\x1fagent-initialization-parameters\x03\0P\x01r\x06\x0f\ -idempotency-keys\x0bmethod-names\x0efunction-input\xcd\0\x08trace-ids\x0ctrace-s\ -tates+\x12invocation-context\xcf\0\x04\0\"agent-method-invocation-parameters\x03\ -\0R\x01r\x01\x08snapshot\x1b\x04\0\x18load-snapshot-parameters\x03\0T\x01r\x01\x0f\ -idempotency-keys\x04\0\x20process-oplog-entries-parameters\x03\0V\x01r\x01\x0fta\ -rget-revision\x0d\x04\0\x18manual-update-parameters\x03\0X\x01q\x06\x14agent-ini\ -tialization\x01\xd1\0\0\x17agent-method-invocation\x01\xd3\0\0\x0dsave-snapshot\0\ -\0\x0dload-snapshot\x01\xd5\0\0\x15process-oplog-entries\x01\xd7\0\0\x0dmanual-u\ -pdate\x01\xd9\0\0\x04\0\x10agent-invocation\x03\0Z\x01r\x02\x09timestamp\x01\x0a\ -invocation\xdb\0\x04\0#agent-invocation-started-parameters\x03\0\\\x01r\x01\x06o\ -utput\xcd\0\x04\0\"agent-invocation-output-parameters\x03\0^\x01ks\x01r\x01\x05e\ -rror\xe0\0\x04\0\x1afallible-result-parameters\x03\0a\x01r\x01\x08snapshot\x1b\x04\ -\0\x1fsave-snapshot-result-parameters\x03\0c\x01q\x06\x14agent-initialization\x01\ -\xdf\0\0\x0cagent-method\x01\xdf\0\0\x0dmanual-update\0\0\x0dload-snapshot\x01\xe2\ -\0\0\x0dsave-snapshot\x01\xe4\0\0\x15process-oplog-entries\x01\xe2\0\0\x04\0\x17\ -agent-invocation-result\x03\0e\x01r\x04\x09timestamp\x01\x11invocation-result\xe6\ -\0\x0dconsumed-fuelx\x12component-revisionw\x04\0$agent-invocation-finished-para\ -meters\x03\0g\x01r\x02\x09timestamp\x01\x0ainvocation\xdb\0\x04\0#pending-agent-\ -invocation-parameters\x03\0i\x01q\x02\x0bauto-update\0\0\x0esnapshot-based\x01\x1b\ -\0\x04\0\x12update-description\x03\0k\x01r\x03\x09timestamp\x01\x0ftarget-revisi\ -on\x0d\x12update-description\xec\0\x04\0\x19pending-update-parameters\x03\0m\x01\ -r\x04\x09timestamp\x01\x0ftarget-revision\x0d\x12new-component-sizew\x12new-acti\ -ve-plugins1\x04\0\x1csuccessful-update-parameters\x03\0o\x01r\x03\x09timestamp\x01\ -\x0ftarget-revision\x0d\x07details\xe0\0\x04\0\x18failed-update-parameters\x03\0\ -q\x01r\x02\x09timestamp\x01\x05deltaw\x04\0\x16grow-memory-parameters\x03\0s\x01\ -w\x04\0\x11agent-resource-id\x03\0u\x01r\x04\x09timestamp\x01\x0bresource-id\xf6\ -\0\x04names\x05owners\x04\0\x1acreate-resource-parameters\x03\0w\x01r\x04\x09tim\ -estamp\x01\x0bresource-id\xf6\0\x04names\x05owners\x04\0\x18drop-resource-parame\ -ters\x03\0y\x01m\x08\x06stdout\x06stderr\x05trace\x05debug\x04info\x04warn\x05er\ -ror\x08critical\x04\0\x09log-level\x03\0{\x01r\x04\x09timestamp\x01\x05level\xfc\ -\0\x07contexts\x07messages\x04\0\x0elog-parameters\x03\0}\x01r\x02\x09timestamp\x01\ -\x06plugin*\x04\0\x1aactivate-plugin-parameters\x03\0\x7f\x01r\x02\x09timestamp\x01\ -\x06plugin*\x04\0\x1cdeactivate-plugin-parameters\x03\0\x81\x01\x01r\x02\x09time\ -stamp\x01\x0edropped-region\xc3\0\x04\0\x11revert-parameters\x03\0\x83\x01\x01r\x02\ -\x09timestamp\x01\x0fidempotency-keys\x04\0$cancel-pending-invocation-parameters\ -\x03\0\x85\x01\x01r\x05\x09timestamp\x01\x07span-id!\x06parent7\x11linked-contex\ -t-id7\x0aattributes9\x04\0\x15start-span-parameters\x03\0\x87\x01\x01r\x02\x09ti\ -mestamp\x01\x07span-id!\x04\0\x16finish-span-parameters\x03\0\x89\x01\x01r\x04\x09\ -timestamp\x01\x07span-id!\x03keys\x05value\x1f\x04\0\x1dset-span-attribute-param\ -eters\x03\0\x8b\x01\x01r\x02\x09timestamp\x01\x11persistence-level\x11\x04\0#cha\ -nge-persistence-level-parameters\x03\0\x8d\x01\x01r\x02\x09timestamp\x01\x0etran\ -saction-ids\x04\0#begin-remote-transaction-parameters\x03\0\x8f\x01\x01r\x02\x09\ -timestamp\x01\x0bbegin-index\x0f\x04\0\x1dremote-transaction-parameters\x03\0\x91\ -\x01\x01p}\x01r\x03\x09timestamp\x01\x04data\x93\x01\x09mime-types\x04\0\x13snap\ -shot-parameters\x03\0\x94\x01\x01r\x01\x09timestamp\x01\x04\0\x09timestamp\x03\0\ -\x96\x01\x01r\x02\x0apayload-id\x17\x08md5-hash\x93\x01\x04\0\x16oplog-external-\ -payload\x03\0\x98\x01\x01q\x02\x06inline\x01\x93\x01\0\x08external\x01\x99\x01\0\ -\x04\0\x0doplog-payload\x03\0\x9a\x01\x01q\x06\x07unknown\x01s\0\x0finvalid-requ\ -est\x01s\0\x0estack-overflow\0\0\x0dout-of-memory\0\0\x15exceeded-memory-limit\0\ -\0\x0einternal-error\x01s\0\x04\0\x0cworker-error\x03\0\x9c\x01\x01pz\x01p-\x01k\ -\x17\x01r\x0d\x09timestamp\x01\x08agent-id\x19\x12component-revision\x0d\x03env(\ -\x0eenvironment-id\x13\x0acreated-by\x05\x06parent0\x0ecomponent-sizew\x20initia\ -l-total-linear-memory-sizew\x16initial-active-plugins\x9e\x01\x0bconfig-vars(\x12\ -local-agent-config\x9f\x01\x13original-phantom-id\xa0\x01\x04\0\x15raw-create-pa\ -rameters\x03\0\xa1\x01\x01r\x05\x09timestamp\x01\x0dfunction-names\x07request\x9b\ -\x01\x08response\x9b\x01\x15durable-function-type&\x04\0\x18raw-host-call-parame\ -ters\x03\0\xa3\x01\x01r\x06\x09timestamp\x01\x0fidempotency-keys\x07payload\x9b\x01\ -\x08trace-ids\x0ctrace-states+\x12invocation-context\xce\0\x04\0'raw-agent-invoc\ -ation-started-parameters\x03\0\xa5\x01\x01r\x04\x09timestamp\x01\x06result\x9b\x01\ -\x0dconsumed-fuelx\x12component-revisionw\x04\0(raw-agent-invocation-finished-pa\ -rameters\x03\0\xa7\x01\x01r\x03\x09timestamp\x01\x05error\x9d\x01\x0aretry-from\x0f\ -\x04\0\x14raw-error-parameters\x03\0\xa9\x01\x01r\x06\x09timestamp\x01\x0fidempo\ -tency-keys\x07payload\x9b\x01\x08trace-ids\x0ctrace-states+\x12invocation-contex\ -t\xce\0\x04\0'raw-pending-agent-invocation-parameters\x03\0\xab\x01\x01r\x03\x0f\ -target-revision\x0d\x07payload\x9b\x01\x09mime-types\x04\0\x19raw-snapshot-based\ --update\x03\0\xad\x01\x01q\x02\x09automatic\x01\x0d\0\x0esnapshot-based\x01\xae\x01\ -\0\x04\0\x16raw-update-description\x03\0\xaf\x01\x01r\x02\x09timestamp\x01\x0bde\ -scription\xb0\x01\x04\0\x1draw-pending-update-parameters\x03\0\xb1\x01\x01r\x04\x09\ -timestamp\x01\x0ftarget-revision\x0d\x12new-component-sizew\x12new-active-plugin\ -s\x9e\x01\x04\0\x20raw-successful-update-parameters\x03\0\xb3\x01\x01r\x02\x04na\ -mes\x05owners\x04\0\x10resource-type-id\x03\0\xb5\x01\x01r\x03\x09timestamp\x01\x02\ -id\xf6\0\x10resource-type-id\xb6\x01\x04\0\x1eraw-create-resource-parameters\x03\ -\0\xb7\x01\x01r\x03\x09timestamp\x01\x02id\xf6\0\x10resource-type-id\xb6\x01\x04\ -\0\x1craw-drop-resource-parameters\x03\0\xb9\x01\x01r\x02\x09timestamp\x01\x0fpl\ -ugin-priorityz\x04\0\x1eraw-activate-plugin-parameters\x03\0\xbb\x01\x01r\x02\x09\ -timestamp\x01\x0fplugin-priorityz\x04\0\x20raw-deactivate-plugin-parameters\x03\0\ -\xbd\x01\x01r\x03\x09timestamp\x01\x0etransaction-ids\x14original-begin-index$\x04\ -\0'raw-begin-remote-transaction-parameters\x03\0\xbf\x01\x01r\x03\x09timestamp\x01\ -\x04data\x9b\x01\x09mime-types\x04\0\x17raw-snapshot-parameters\x03\0\xc1\x01\x01\ -q&\x06create\x01\xa2\x01\0\x09host-call\x01\xa4\x01\0\x18agent-invocation-starte\ -d\x01\xa6\x01\0\x19agent-invocation-finished\x01\xa8\x01\0\x07suspend\x01\x97\x01\ -\0\x05error\x01\xaa\x01\0\x05no-op\x01\x97\x01\0\x04jump\x01\xc5\0\0\x0binterrup\ -ted\x01\x97\x01\0\x06exited\x01\x97\x01\0\x13change-retry-policy\x01\xc7\0\0\x13\ -begin-atomic-region\x01\x97\x01\0\x11end-atomic-region\x01\xc9\0\0\x12begin-remo\ -te-write\x01\x97\x01\0\x10end-remote-write\x01\xcb\0\0\x18pending-agent-invocati\ -on\x01\xac\x01\0\x0epending-update\x01\xb2\x01\0\x11successful-update\x01\xb4\x01\ -\0\x0dfailed-update\x01\xf2\0\0\x0bgrow-memory\x01\xf4\0\0\x0fcreate-resource\x01\ -\xb8\x01\0\x0ddrop-resource\x01\xba\x01\0\x03log\x01\xfe\0\0\x07restart\x01\x97\x01\ -\0\x0factivate-plugin\x01\xbc\x01\0\x11deactivate-plugin\x01\xbe\x01\0\x06revert\ -\x01\x84\x01\0\x19cancel-pending-invocation\x01\x86\x01\0\x0astart-span\x01\x88\x01\ -\0\x0bfinish-span\x01\x8a\x01\0\x12set-span-attribute\x01\x8c\x01\0\x18change-pe\ -rsistence-level\x01\x8e\x01\0\x18begin-remote-transaction\x01\xc0\x01\0\x1dpre-c\ -ommit-remote-transaction\x01\x92\x01\0\x1fpre-rollback-remote-transaction\x01\x92\ -\x01\0\x1ccommitted-remote-transaction\x01\x92\x01\0\x1erolled-back-remote-trans\ -action\x01\x92\x01\0\x08snapshot\x01\xc2\x01\0\x04\0\x0boplog-entry\x03\0\xc3\x01\ -\x01q&\x06create\x014\0\x09host-call\x016\0\x18agent-invocation-started\x01\xdd\0\ -\0\x19agent-invocation-finished\x01\xe8\0\0\x07suspend\x01\x97\x01\0\x05error\x01\ -\xc1\0\0\x05no-op\x01\x97\x01\0\x04jump\x01\xc5\0\0\x0binterrupted\x01\x97\x01\0\ -\x06exited\x01\x97\x01\0\x13change-retry-policy\x01\xc7\0\0\x13begin-atomic-regi\ -on\x01\x97\x01\0\x11end-atomic-region\x01\xc9\0\0\x12begin-remote-write\x01\x97\x01\ -\0\x10end-remote-write\x01\xcb\0\0\x18pending-agent-invocation\x01\xea\0\0\x0epe\ -nding-update\x01\xee\0\0\x11successful-update\x01\xf0\0\0\x0dfailed-update\x01\xf2\ -\0\0\x0bgrow-memory\x01\xf4\0\0\x0fcreate-resource\x01\xf8\0\0\x0ddrop-resource\x01\ -\xfa\0\0\x03log\x01\xfe\0\0\x07restart\x01\x97\x01\0\x0factivate-plugin\x01\x80\x01\ -\0\x11deactivate-plugin\x01\x82\x01\0\x06revert\x01\x84\x01\0\x19cancel-pending-\ -invocation\x01\x86\x01\0\x0astart-span\x01\x88\x01\0\x0bfinish-span\x01\x8a\x01\0\ -\x12set-span-attribute\x01\x8c\x01\0\x18change-persistence-level\x01\x8e\x01\0\x18\ -begin-remote-transaction\x01\x90\x01\0\x1dpre-commit-remote-transaction\x01\x92\x01\ -\0\x1fpre-rollback-remote-transaction\x01\x92\x01\0\x1ccommitted-remote-transact\ -ion\x01\x92\x01\0\x1erolled-back-remote-transaction\x01\x92\x01\0\x08snapshot\x01\ -\x95\x01\0\x04\0\x12public-oplog-entry\x03\0\xc5\x01\x04\0\x09get-oplog\x03\x01\x04\ -\0\x0csearch-oplog\x03\x01\x01i\xc7\x01\x01@\x02\x08agent-id\x19\x05start\x0f\0\xc9\ -\x01\x04\0\x16[constructor]get-oplog\x01\xca\x01\x01h\xc7\x01\x01p\xc6\x01\x01k\xcc\ -\x01\x01@\x01\x04self\xcb\x01\0\xcd\x01\x04\0\x1a[method]get-oplog.get-next\x01\xce\ -\x01\x01i\xc8\x01\x01@\x02\x08agent-id\x19\x04texts\0\xcf\x01\x04\0\x19[construc\ -tor]search-oplog\x01\xd0\x01\x01h\xc8\x01\x01o\x02\x0f\xc6\x01\x01p\xd2\x01\x01k\ -\xd3\x01\x01@\x01\x04self\xd1\x01\0\xd4\x01\x04\0\x1d[method]search-oplog.get-ne\ -xt\x01\xd5\x01\x01o\x02\x0f\xc4\x01\x01p\xd6\x01\x01j\x01\xcc\x01\x01s\x01@\x04\x0e\ -environment-id\x13\x08agent-id\x19\x07entries\xd7\x01\x12component-revision\x0d\0\ -\xd8\x01\x04\0\x14enrich-oplog-entries\x01\xd9\x01\x03\0\x15golem:api/oplog@1.5.\ -0\x05\x1f\x01B\x03\x01ps\x01@\0\0\0\x04\0\x15get-invoked-functions\x01\x01\x04\0\ -\x13golem:component/api\x05\x20\x02\x03\0\x04\x0eagent-metadata\x02\x03\0\x06\x0b\ -oplog-entry\x01B\x18\x02\x03\x02\x01\x0d\x04\0\x08datetime\x03\0\0\x02\x03\x02\x01\ -\x12\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\x01\x0f\x04\0\x0aaccount-id\x03\0\x04\ -\x02\x03\x02\x01\x06\x04\0\x0ccomponent-id\x03\0\x06\x02\x03\x02\x01\x09\x04\0\x08\ -agent-id\x03\0\x08\x02\x03\x02\x01\x14\x04\0\x0boplog-index\x03\0\x0a\x02\x03\x02\ -\x01!\x04\0\x0eagent-metadata\x03\0\x0c\x02\x03\x02\x01\"\x04\0\x0boplog-entry\x03\ -\0\x0e\x01r\x01\x0aaccount-id\x05\x04\0\x0caccount-info\x03\0\x10\x01o\x02ss\x01\ -p\x12\x01p\x0f\x01j\0\x01s\x01@\x07\x0caccount-info\x11\x06config\x13\x0ccompone\ -nt-id\x07\x08agent-id\x09\x08metadata\x0d\x11first-entry-index\x0b\x07entries\x14\ -\0\x15\x04\0\x07process\x01\x16\x04\0\x1fgolem:api/oplog-processor@1.5.0\x05#\x04\ -\0\x1fgolem:component/oplog-processor\x04\0\x0b\x15\x01\0\x0foplog-processor\x03\ -\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-\ -bindgen-rust\x060.41.0"; -#[inline(never)] -#[doc(hidden)] -pub fn __link_custom_section_describing_imports() { - wit_bindgen_rt::maybe_link_cabi_realloc(); -} diff --git a/test-components/oplog_processor_release.wasm b/test-components/oplog_processor_release.wasm index bb4f776846..c12e69e7fd 100644 Binary files a/test-components/oplog_processor_release.wasm and b/test-components/oplog_processor_release.wasm differ diff --git a/test-components/scalability_large_dynamic_memory_release.wasm b/test-components/scalability_large_dynamic_memory_release.wasm index b1a42438d6..6769cf7616 100644 Binary files a/test-components/scalability_large_dynamic_memory_release.wasm and b/test-components/scalability_large_dynamic_memory_release.wasm differ diff --git a/test-components/scalability_large_initial_memory_release.wasm b/test-components/scalability_large_initial_memory_release.wasm index 6c9699b40e..00681dccba 100644 Binary files a/test-components/scalability_large_initial_memory_release.wasm and b/test-components/scalability_large_initial_memory_release.wasm differ