refactor: running components chapter (#277)

macovedj · vados-cosmonic · web-flow · commit 78075132db2e · 2025-07-13T14:44:20.000+09:00
* remove 6.1 'Authoring Components' section

* running.md moved to wasmtime.md section and updated for custom invocations

* refactor chapter 6 into 1 chapter for running and 1 for composing/distributing

* nits

* refactor: custom export comment

---------

Co-authored-by: Victor Adossi &lt;123968127+vados-cosmonic@users.noreply.github.com&gt;
diff --git a/component-model/book.toml b/component-model/book.toml
@@ -10,6 +10,15 @@ git-repository-url = "https://github.com/bytecodealliance/component-docs/tree/ma
 edit-url-template = "https://github.com/bytecodealliance/component-docs/tree/main/component-model/{path}"
 additional-css = ["theme/head.hbs"]
 
+[output.html.redirect]
+"/creating-and-consuming/composing.html" = "/composing-and-distributing/composing.html"
+"/creating-and-consuming/distributing.html" = "/composing-and-distributing/distributing.html"
+"/creating-and-consuming/running.html" = "/running-components.html"
+"/creating-and-consuming/authoring.html" = "/language-support.html"
+"/creating-and-consuming.html" = "/language-support.html"
+"/runtimes/wasmtime.html" = "/running-components/wasmtime.html"
+"/runtimes/jco.html" = "/running-components/jco.html"
+
 [preprocessor.alerts]
 
 [output.linkcheck]
diff --git a/component-model/src/SUMMARY.md b/component-model/src/SUMMARY.md
@@ -22,18 +22,14 @@
   - [JavaScript](./language-support/javascript.md)
   - [Python](./language-support/python.md)
   - [Rust](./language-support/rust.md)
-- [Creating and Consuming Components](./creating-and-consuming.md)
-  - [Authoring Components](./creating-and-consuming/authoring.md)
-  - [Composing Components](./creating-and-consuming/composing.md)
-  - [Running Components](./creating-and-consuming/running.md)
-  - [Distributing and Fetching Components and WIT](./creating-and-consuming/distributing.md)
+- [Running Components](./running-components.md)
+  - [Wasmtime](./running-components/wasmtime.md)
+  - [jco](./running-components/jco.md)
+- [Consuming and Distributing Components](./composing-and-distributing.md)
+  - [Composing Components](./composing-and-distributing/composing.md)
+  - [Distributing and Fetching Components and WIT](./composing-and-distributing/distributing.md)
 - [Tutorial](./tutorial.md)
 
-# Runtime Support
-
-- [Wasmtime](./runtimes/wasmtime.md)
-- [jco](./runtimes/jco.md)
-
 # Advanced Topics
 
 - [Canonical ABI](./advanced/canonical-abi.md)
diff --git a/component-model/src/composing-and-distributing.md b/component-model/src/composing-and-distributing.md
@@ -1,3 +1,3 @@
-# Creating and Consuming Components
+# Composing and Distributing Components
 
 The component model defines how components interface to each other and to hosts. This section describes how to work with components - from authoring them in custom code or by composing existing components, through to using them in applications and distributing them via registries.
diff --git a/component-model/src/composing-and-distributing/composing.md b/component-model/src/composing-and-distributing/composing.md
diff --git a/component-model/src/composing-and-distributing/distributing.md b/component-model/src/composing-and-distributing/distributing.md
diff --git a/component-model/src/creating-and-consuming/authoring.md b/component-model/src/creating-and-consuming/authoring.md
diff --git a/component-model/src/creating-and-consuming/running.md b/component-model/src/creating-and-consuming/running.md
diff --git a/component-model/src/introduction.md b/component-model/src/introduction.md
@@ -23,9 +23,9 @@ The WebAssembly Component Model is a broad-reaching architecture for building in
 [Python]: ./language-support/python.md
 [Rust]: ./language-support/rust.md
 
-[Composing]: ./creating-and-consuming/composing.md
-[Running]: ./creating-and-consuming/running.md
-[Distributing]: ./creating-and-consuming/distributing.md
+[Composing]: ./composing-and-distributing/composing.md
+[Running]: ./running-components.md
+[Distributing]: ./composing-and-distributing/distributing.md
 
 > [!NOTE]
 >This documentation is aimed at _users_ of the component model: developers of libraries and applications.
diff --git a/component-model/src/language-support.md b/component-model/src/language-support.md
@@ -89,5 +89,4 @@ working with WebAssembly modules and components.
 You can "run" a component by calling one of its exports. Hosts and runtimes often only support
 running components with certain exports. The [`wasmtime`](https://github.com/bytecodealliance/wasmtime) CLI can only run "command" components, so in
 order to run the `add` function above, it first must be composed with a primary "command" component
-that calls it. See [documentation on running components](./creating-and-consuming/running.md) for
-more details.
+that calls it. See [documentation on running components](./running-components/wasmtime.md) for more details.
diff --git a/component-model/src/language-support/javascript.md b/component-model/src/language-support/javascript.md
@@ -54,7 +54,7 @@ download a pre-existing interface that defines what your component should do.
 The [`adder` world][adder-world] contains an interface with a single `add` function that sums two numbers:
 
 ```wit
-{{#include ../../exmaples/tutorial/wit/adder/world.wit}}
+{{#include ../../examples/tutorial/wit/adder/world.wit}}
 ```
 
 > [!NOTE]
diff --git a/component-model/src/language-support/rust.md b/component-model/src/language-support/rust.md
@@ -207,7 +207,7 @@ world root {
 ```
 
 As the import is unfulfilled, the `calculator.wasm` component could not run by itself in its current form. To fulfill the `add` import, so that
-only `calculate` is exported, you would need to [compose the `calculator.wasm` with some `adder.wasm` into a single, self-contained component](../creating-and-consuming/composing.md).
+only `calculate` is exported, you would need to [compose the `calculator.wasm` with some `adder.wasm` into a single, self-contained component](../composing-and-distributing/composing.md).
 
 ## Creating a command component with `cargo component`
 
@@ -284,7 +284,7 @@ As mentioned above, `cargo component build` doesn't generate a WIT file for a co
     }
     ```
 
-5. [Compose the command component with the `.wasm` components that implement the imports.](../creating-and-consuming/composing.md)
+5. [Compose the command component with the `.wasm` components that implement the imports.](../composing-and-distributing/composing.md)
 
 6. Run the composed component:
 
@@ -488,7 +488,7 @@ To use the calculator engine in another component, that component must import th
     }
     ```
 
-You can now build the command component and [compose it with the `.wasm` component that implements the resource.](../creating-and-consuming/composing.md). You can then run the composed command with `wasmtime run`.
+You can now build the command component and [compose it with the `.wasm` component that implements the resource.](../composing-and-distributing/composing.md). You can then run the composed command with `wasmtime run`.
 
 ### Implementing and exporting a resource implementation in a host
 
diff --git a/component-model/src/running-components.md b/component-model/src/running-components.md
@@ -0,0 +1,3 @@
+# Running Components
+
+There are two standard wit worlds that runtimes support. These worlds are the [`wasi:cli/command` world](https://github.com/WebAssembly/wasi-cli/blob/main/wit/command.wit) and the [`wasi:http/proxy` world](https://github.com/WebAssembly/wasi-http/blob/main/wit/proxy.wit). All other wit worlds and interfaces are considered to be custom.  In the following sections, you'll see how to run components that implement either world, as well as how to invoke custom exports.
diff --git a/component-model/src/running-components/jco.md b/component-model/src/running-components/jco.md
diff --git a/component-model/src/running-components/wasmtime.md b/component-model/src/running-components/wasmtime.md
@@ -1,6 +1,6 @@
 # Wasmtime
 
-[Wasmtime](https://github.com/bytecodealliance/wasmtime/) is the reference implementation of the Component Model. It supports running components that implement the [`wasi:cli/command` world](https://github.com/WebAssembly/wasi-cli/blob/main/wit/command.wit) and serving components that implement the [`wasi:http/proxy` world](https://github.com/WebAssembly/wasi-http/blob/main/wit/proxy.wit).
+[Wasmtime](https://github.com/bytecodealliance/wasmtime/) is the reference implementation of the Component Model. It supports running components that implement the [`wasi:cli/command` world](https://github.com/WebAssembly/wasi-cli/blob/main/wit/command.wit) and serving components that implement the [`wasi:http/proxy` world](https://github.com/WebAssembly/wasi-http/blob/main/wit/proxy.wit). Wasmtime can also invoke functions exported from a component.
 
 ## Running command components with Wasmtime
 To run a command component with Wasmtime, execute:
@@ -27,3 +27,14 @@ Try out building and running HTTP components with one of these tutorials
 1. [Hello WASI HTTP tutorial](https://github.com/sunfishcode/hello-wasi-http) - build and serve a simple Rust-based HTTP component
 
 2. [HTTP Auth Middleware tutorial](https://github.com/fermyon/http-auth-middleware#running-with-wasmtime) - compose a HTTP authentication middleware component with a business logic component
+
+## Running components with custom exports
+As of Wasmtime Version 33.0.0, there is [support for invoking components with custom exports](https://bytecodealliance.org/articles/invoking-component-functions-in-wasmtime-cli).
+
+
+As an example, if your component exports a function `add` which takes two numeric arguments, you can make use of this feature with the following command.
+
+```sh
+wasmtime run --invoke 'foo(1, 2)' <path-to-wasm-file>
+```
+Make sure to wrap your invocation in single quotes abd to include parentheses, even if your function doesn't take any arguments. For a full list of ways to represent the various wit types when passing arguments to your exported function, visit the [WAVE repo](https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasm-wave).
diff --git a/component-model/src/tutorial.md b/component-model/src/tutorial.md
@@ -79,17 +79,15 @@ These files define:
 
 ## Create an `add` component
 
-Reference the [language guide](language-support.md) and [authoring components
-documentation](creating-and-consuming/authoring.md) to create a component that implements the
+Reference the [language guide](language-support.md) to create a component that implements the
 `adder` world of `adder/wit/world.wit`.
 
 For reference, see the completed
 [example](https://github.com/bytecodealliance/component-docs/tree/main/component-model/examples/tutorial/adder/).
 
 ## Create a `calculator` component
 
-Reference the [language guide](language-support.md) and [authoring components
-documentation](creating-and-consuming/authoring.md) to create a component that implements the
+Reference the [language guide](language-support.md) to create a component that implements the
 `calculator` world of `wit/calculator/world.wit`.
 
 For reference, see the completed
@@ -160,7 +158,7 @@ wac plug calculator.wasm --plug adder.wasm -o composed.wasm
 wac plug command.wasm --plug composed.wasm -o final.wasm
 ```
 
-> If you'd prefer to take a more visual approach to composing components, see the [documentation on composing components with wasmbuilder.app](creating-and-consuming/composing.md#composing-components-with-a-visual-interface).
+> If you'd prefer to take a more visual approach to composing components, see the [documentation on composing components with wasmbuilder.app](composing-and-distributing/composing.md#composing-components-with-a-visual-interface).
 
 ## Running the calculator
 

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-# Creating and Consuming Components`
	`1`	`+# Composing and Distributing Components`
`2`	`2`
`3`	`3`	`The component model defines how components interface to each other and to hosts. This section describes how to work with components - from authoring them in custom code or by composing existing components, through to using them in applications and distributing them via registries.`