Web Assembly Module

A WebAssembly (Wasm) Module is a self-contained, deployable unit of WebAssembly code. It's the core building block of any Wasm application. Written in a low-level binary format (.wasm files), these modules are designed for efficient loading and execution, making them suitable for performance-critical applications both on and off the web.

Key Characteristics of a Wasm Module:
* Binary Format: Wasm modules are distributed as compact binary files (.wasm), which are fast to parse and execute.
* Language Agnostic: They are compiled targets for various high-level languages like Rust, C/C++, Go, AssemblyScript, and more, allowing developers to choose their preferred language for writing Wasm logic.
* Portability: Wasm modules are designed to run in a sandboxed environment on various platforms, including web browsers, Node.js, and standalone Wasm runtimes (like Wasmtime, Wasmer), ensuring consistent behavior across different environments.
* Performance: Wasm executes at near-native speeds, often significantly faster than JavaScript for computationally intensive tasks, making it ideal for games, video processing, scientific simulations, and CAD applications.
* Security: Wasm operates within a strict sandbox, meaning it cannot directly access the host system's resources (like the file system or network) without explicit permission and APIs provided by the host environment.

Components of a Wasm Module:
Every Wasm module can define and utilize several types of components:
* Functions: The executable code units within the module. Functions can take arguments and return values. Modules can import functions from the host environment or export their own functions to be called by the host.
* Linear Memory: A contiguous, mutable array of bytes that the Wasm module can read from and write to. It's often used for data storage, stack, and heap. A module can import a memory from the host or define its own.
* Tables: Arrays of references, primarily used for indirect function calls. This allows for implementing features like dynamic dispatch or calling functions by index.
* Global Variables: Mutable or immutable values that can be accessed throughout the module. They can also be imported or exported.
* Imports: Resources (functions, memory, tables, globals) that the module expects to be provided by its host environment.
* Exports: Resources (functions, memory, tables, globals) that the module makes available for its host environment to use.

Lifecycle of a Wasm Module:
1. Compilation: Source code (e.g., Rust) is compiled into a Wasm binary (.wasm file) and optionally associated JavaScript glue code (e.g., by `wasm-bindgen`).
2. Loading: The host environment (e.g., web browser) fetches the .wasm file.
3. Instantiation: The Wasm binary is loaded and instantiated, creating a Wasm `Instance`. This involves validating the module, setting up memory, tables, and wiring up imports and exports.
4. Execution: The host environment can then call exported functions on the `Instance`, passing data in and out of the module's memory as needed.

In essence, a WebAssembly Module acts as a highly optimized, secure, and portable computational engine that can be integrated into various applications to enhance performance and leverage multi-language development.

```rust
// src/lib.rs
// This Rust code will be compiled into a WebAssembly module.

// Import the `wasm_bindgen` prelude, which provides macros for 
// interacting with JavaScript and exporting functions.
use wasm_bindgen::prelude::*;

// Mark the `add` function with `#[wasm_bindgen]` to make it accessible from JavaScript.
// This function takes two 32-bit integers and returns their sum.
#[wasm_bindgen]
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Another example: a function that takes a string and returns a new formatted string.
#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Hello, {} from Rust Wasm!", name)
}

// --- Cargo.toml (project configuration) ---
// This section describes the configuration required in your Cargo.toml file
// for a Rust project that compiles to WebAssembly.
/*
[package]
name = "rust-wasm-module-example"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"] # This is crucial for compiling to a dynamic library suitable for Wasm.

[dependencies]
wasm-bindgen = "0.2" # The `wasm-bindgen` crate is essential for JS interop.
*/

// --- How to build and use (Conceptual Steps) ---
// 1. Install `wasm-pack`: `cargo install wasm-pack`
// 2. Build the project: `wasm-pack build --target web` (or `--target nodejs` for Node.js environments)
//    This will create a `pkg` directory containing the `.wasm` module and JS glue code.

// 3. Example JavaScript usage (e.g., in a web page's script):
/*
// Assuming the 'pkg' directory is in the same location as your JS file.
import * as wasm from "./pkg/rust_wasm_module_example.js"; 

console.log("Result of add(5, 3):", wasm.add(5, 3)); // Output: Result of add(5, 3): 8
console.log(wasm.greet("Wasm User"));             // Output: Hello, Wasm User from Rust Wasm!
*/
```