Add WASI P3 tabs to creating-runnable-components/rust.md (#350)

* docs(creating-runnable-components/rust): add WASI P3 tabs

WASI 0.3.0 made `wasi:cli/run` an `async func`, so this page now teaches
the P3 pattern alongside the existing P2 one. Tab the build and run
invocations to cover the `wasm32-wasip3` nightly target and the
`-Sp3 -W component-model-async=y` flags, tab the WIT to pin
`wasi:cli/run@0.3.0`, and tab the Rust code to show the `async fn run()`
signature that `wit-bindgen` with the `async` feature now generates.

Signed-off-by: Eric Gregory <eric@cosmonic.com>

* docs(creating-runnable-components/rust): revise P3 tabs against verified path

Walked the page end-to-end against the current toolchain and reworked the
P3 content to match what actually works on 2026-06-12:

- Drop the P3 tab from "Creating a command component". `rustup target add
  wasm32-wasip3` fails (Tier 3, no prebuilt artifacts), and Rust's std
  has not yet migrated to use P3 imports, so the `fn main()` pattern has
  no honest P3 story today. Replace with a pointer to the library/reactor
  pattern below.
- Library/reactor P3 tabs now build against `wasm32-wasip2` with a
  nightly toolchain (stable's bundled `wasm-component-ld` cannot decode
  the component-type custom section `wit-bindgen` 0.58 emits for P3
  worlds).
- Pin the P3 WIT example to `wasi:cli/run@0.3.0-rc-2026-03-15`. The
  published `0.3.0` tag fails at run time against current Wasmtime and
  `wit-bindgen` (the version-pinning trap we documented as a footnote is
  load-bearing today).
- Note that `wkg` 0.15 or later is needed for `wkg wit fetch` on the P3
  package.
- Fix a long-standing path bug: cargo converts hyphens to underscores in
  library crate names, so the artifact is `runnable_example.wasm`, not
  `runnable-example.wasm`, and lives under `target/.../debug/`.
- Update the top-of-page notice and the bottom version-pinning blockquote
  to capture the transitional state.

Signed-off-by: Eric Gregory <eric@cosmonic.com>

* docs: rename WASI P2/P3 to WASI 0.2/0.3 in rust runnable-components page

Per WASI maintainer guidance, refer to the WASI specifications as
"WASI 0.2" and "WASI 0.3" in prose. Technical identifiers like
`wasm32-wasip3`, `-Sp3`, and `wasi:cli/run@0.3.0-rc-...` are
unaffected.

Signed-off-by: Eric Gregory <eric@cosmonic.com>

---------

Signed-off-by: Eric Gregory <eric@cosmonic.com>

Author: ericgregory

component-model/src/language-support/creating-runnable-components/rust.md

@@ -1,5 +1,13 @@
 # Creating Runnable Components (Rust)
 
+<div class="version-notice">
+
+This page has content for both **WASI 0.2** and **WASI 0.3**. Use the tabs below to switch between versions where they differ.
+
+> **WASI 0.3 toolchain note.** Rust's [`wasm32-wasip3` target](https://doc.rust-lang.org/nightly/rustc/platform-support/wasm32-wasip3.html) is currently Tier 3 with no prebuilt artifacts; building for it requires constructing the standard library from source. The 0.3 example on this page therefore uses the library/reactor pattern targeting `wasm32-wasip2`, where [`wit-bindgen`](https://crates.io/crates/wit-bindgen)'s `async` feature handles the 0.3 binding generation. There is no Rust-idiomatic 0.3 path for the `fn main()` command-component pattern yet.
+
+</div>
+
 ## Creating a command component
 
 A _command_ is a component with a specific export that allows it to be executed directly by `wasmtime`
@@ -45,7 +53,7 @@ cargo build --target=wasm32-wasip2
 
 The component can also be built in release mode:
 
-```console
+```sh
 cargo build --target=wasm32-wasip2 --release
 ```
 
@@ -57,6 +65,8 @@ To run your command component:
 wasmtime run ./target/wasm32-wasip2/debug/runnable-example.wasm
 ```
 
+> For a runnable component that exports the 0.3 `wasi:cli/run` interface, see the library/reactor pattern below.
+
 ## Enabling a library component to be run via the `wasi:cli/run` interface
 
 Sometimes, it is useful to create a component that can *both* be used as a library (via
@@ -91,15 +101,28 @@ crate-type = ['cdylib']
 
 We'll also be generating Rust bindings from WIT interfaces, so add `wit-bindgen`:
 
+{{#tabs global="wasi-version" }}
+{{#tab name="WASI 0.2" }}
 ```sh
 cargo add wit-bindgen
 ```
+{{#endtab }}
+{{#tab name="WASI 0.3" }}
+```sh
+cargo add wit-bindgen --features async
+```
+
+The `async` feature enables `wit-bindgen`'s async code generation, which is needed for the 0.3 `async func run()` signature.
+{{#endtab }}
+{{#endtabs }}
 
 ### 2. Add the appropriate WIT interfaces
 
 Then, add the appropriate WIT interfaces. For example a simple component that prints "Hello World", add the following
 contents to `runnable-example/wit/component.wit`:
 
+{{#tabs global="wasi-version" }}
+{{#tab name="WASI 0.2" }}
 ```wit
 package example:runnable;
 
@@ -112,6 +135,26 @@ world greeter {
     export wasi:cli/run@0.2.7;
 }
 ```
+{{#endtab }}
+{{#tab name="WASI 0.3" }}
+```wit
+package example:runnable;
+
+interface greet {
+    greet: func(name: string) -> string;
+}
+
+world greeter {
+    export greet;
+    export wasi:cli/run@0.3.0-rc-2026-03-15;
+}
+```
+
+In WASI 0.3, `wasi:cli/run` is declared as `run: async func() -> result`, so the generated `Guest` trait expects an `async fn`.
+
+> The pin here is `0.3.0-rc-2026-03-15` rather than the published `0.3.0` because Wasmtime, `wit-bindgen`, and other toolchain components currently ship this snapshot of the WIT. They are expected to refresh to `0.3.0` in upcoming releases.
+{{#endtab }}
+{{#endtabs }}
 
 Building a library component this way does two things:
 
@@ -126,6 +169,8 @@ using `wkg`:
 wkg wit fetch
 ```
 
+> For WASI 0.3, use `wkg` 0.15 or later. Earlier versions fail to decode the `wasi:cli@0.3.0-rc-2026-03-15` package.
+
 At this point, you should have a `wit` folder with a `deps` subfolder and your original `component.wit`.
 
 The component we will create to satisfy the WIT above can be used as a library, as other components
@@ -137,6 +182,8 @@ with any tooling (ex. `wasmtime run`) that supports/recognizes the `wasi:cli` in
 
 The following code can be inserted into `runnable-example/src/lib.rs`:
 
+{{#tabs global="wasi-version" }}
+{{#tab name="WASI 0.2" }}
 ```rust
 mod bindings {
     use super::Component;
@@ -164,9 +211,43 @@ impl bindings::exports::wasi::cli::run::Guest for Component {
     }
 }
 ```
+{{#endtab }}
+{{#tab name="WASI 0.3" }}
+```rust
+mod bindings {
+    use super::Component;
+
+    wit_bindgen::generate!();
+
+    export!(Component);
+}
+
+/// Component off of which implementation will hang (this can be named anything)
+struct Component;
+
+/// Implementation for the `greet` interface export
+impl bindings::exports::example::runnable::greet::Guest for Component {
+    fn greet(name: String) -> String {
+        format!("Hello {name}!")
+    }
+}
+
+/// Implementation for `wasi:cli/run` interface export.
+/// In WASI 0.3 the `run` function is asynchronous.
+impl bindings::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        eprintln!("Hello World!");
+        Ok(())
+    }
+}
+```
+{{#endtab }}
+{{#endtabs }}
 
 ### 4. Build the component
 
+{{#tabs global="wasi-version" }}
+{{#tab name="WASI 0.2" }}
 To build the component, use `cargo`:
 
 ```sh
@@ -175,16 +256,49 @@ cargo build --target=wasm32-wasip2
 
 The component can also be built in release mode:
 
-```console
+```sh
 cargo build --target=wasm32-wasip2 --release
 ```
+{{#endtab }}
+{{#tab name="WASI 0.3" }}
+Build the component against `wasm32-wasip2` using a nightly Rust toolchain:
+
+```sh
+cargo +nightly build --target=wasm32-wasip2
+```
+
+Release mode:
+
+```sh
+cargo +nightly build --target=wasm32-wasip2 --release
+```
+
+> A nightly toolchain is required because the `wasm-component-ld` bundled with current stable Rust cannot decode the component-type custom section that `wit-bindgen` 0.58 emits for 0.3 worlds. Nightly ships a newer linker that handles it.
+{{#endtab }}
+{{#endtabs }}
 
 ### 5. Run the component with `wasmtime`
 
+{{#tabs global="wasi-version" }}
+{{#tab name="WASI 0.2" }}
 You can run the component with `wasmtime`, and unlike a generic reactor component, you do not need to specify
 the interface and function to run (`wasi:cli/run` is detected and used automatically):
 
 ```console
-$ wasmtime run target/wasm32-wasip2/runnable-example.wasm
+$ wasmtime run target/wasm32-wasip2/debug/runnable_example.wasm
+Hello World!
+```
+
+> Cargo converts hyphens to underscores in library crate names, so the artifact is `runnable_example.wasm` even though the package was created as `runnable-example`.
+{{#endtab }}
+{{#tab name="WASI 0.3" }}
+Enable the WASI 0.3 ABI when running a 0.3 component, with Wasmtime 43 or later:
+
+```console
+$ wasmtime run -Sp3 -W component-model-async=y target/wasm32-wasip2/debug/runnable_example.wasm
 Hello World!
 ```
+{{#endtab }}
+{{#endtabs }}
+
+> **Version pinning.** WASI 0.3 tools (`wit-bindgen`, Wasmtime, jco, and so on) must all target the same WIT version. As of WASI 0.3.0's release on 2026-06-11, `wit-bindgen` 0.58 and Wasmtime 45 still ship the `0.3.0-rc-2026-03-15` snapshot of the WIT; pinning to the published `0.3.0` produces `no exported instance named wasi:cli/run@0.2.6` (or similar) errors at run time until those tools refresh. Use the RC pin until then.