[WASM Component Model in Practice, Part 2: Polyglot Implementation, Composition, and Production Trade-offs]

# Step 1: generate bindings -- inspect the output before writing implementation
wit-bindgen go \
  --world validator-world \
  ../../wit \
  --out-dir gen

# The generated package will contain:
# gen/validator.go     -- the Validator interface you must implement
# gen/types.go         -- generated types (Document, ValidationError, etc.)
# gen/validator_host.go -- SetValidator() registration function
# Exact names vary by wit-bindgen version -- check the generated files
ls gen/

// components/validator/main.go
// Written against generated bindings from wit-bindgen 0.32.0 + TinyGo 0.34.0
// If your generated types differ, adjust the implementation accordingly

package main

// Import the generated package -- path depends on your Go module name
import (
	"my-org/doc-pipeline/components/validator/gen"
)

// Compile-time check: ValidatorImpl must satisfy the generated interface.
// If this line fails, the generated interface name differs from gen.Validator.
var _ gen.Validator = ValidatorImpl{}

type ValidatorImpl struct{}

func (v ValidatorImpl) Validate(doc gen.TypesDocument) gen.TypesValidationResult {
	if len(doc.Content) == 0 {
		return gen.TypesValidationResult{
			IsOk: false,
			Err: &gen.TypesValidationError{
				Tag: gen.TypesValidationErrorTagSchemaViolation,
				Val: "content must not be empty",
			},
		}
	}

	const maxBytes = 10 * 1024 * 1024
	if uint64(len(doc.Content)) > maxBytes {
		return gen.TypesValidationResult{
			IsOk: false,
			Err: &gen.TypesValidationError{
				Tag: gen.TypesValidationErrorTagSizeLimitExceeded,
				Val: uint64(len(doc.Content)),
			},
		}
	}

	return gen.TypesValidationResult{IsOk: true, Ok: &doc}
}

func (v ValidatorImpl) ValidateBatch(docs []gen.TypesDocument) []gen.TypesValidationResult {
	results := make([]gen.TypesValidationResult, len(docs))
	for i, doc := range docs {
		results[i] = v.Validate(doc)
	}
	return results
}

func init() {
	// Register implementation with the generated glue code.
	// The exact function name (SetValidator) is generated by wit-bindgen.
	gen.SetValidator(ValidatorImpl{})
}

func main() {}

# components/validator/Makefile
# TinyGo 0.34+ native Component Model -- no Preview 1 adapter needed

WORLD    = validator-world
WIT_DIR  = ../../wit
GEN_DIR  = gen

.PHONY: bindings build validate

bindings:
	wit-bindgen go \
		--world $(WORLD) \
		$(WIT_DIR) \
		--out-dir $(GEN_DIR)
	@echo "Generated bindings in $(GEN_DIR)/ -- review before implementing"

build: bindings
	tinygo build \
		-target wasip2 \
		-o ../../composed/validator.wasm \
		.
	@echo "Validator component built: ../../composed/validator.wasm"

validate:
	wasm-tools validate ../../composed/validator.wasm --features component-model
	wasm-tools component wit ../../composed/validator.wasm

rustup target add wasm32-wasip2

# components/transformer/Cargo.toml
[package]
name = "transformer"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wit-bindgen = "0.32"

[profile.release]
opt-level = "s"
lto = true
strip = true

// components/transformer/src/lib.rs

wit_bindgen::generate!({
    path: "../../wit",
    world: "transformer-world",
});

use exports::my_org::doc_pipeline::transformer::{Document, Guest};

struct TransformerImpl;

impl Guest for TransformerImpl {
    fn transform(doc: Document, rules: Vec<String>) -> Option<Document> {
        let mut content = doc.content.clone();

        for rule in &rules {
            match rule.as_str() {
                "uppercase" => content = content.to_uppercase(),
                "trim" => content = content.trim().to_string(),
                "strip-html" => content = strip_html_tags(&content),
                unknown => {
                    eprintln!("transformer: unknown rule '{}'", unknown);
                }
            }
        }

        if content.is_empty() {
            None
        } else {
            Some(Document {
                id: doc.id,
                content,
                metadata: doc.metadata,
            })
        }
    }
}

fn strip_html_tags(input: &str) -> String {
    let mut result = String::with_capacity(input.len());
    let mut inside_tag = false;
    for c in input.chars() {
        match c {
            '<' => inside_tag = true,
            '>' => inside_tag = false,
            _ if !inside_tag => result.push(c),
            _ => {}
        }
    }
    result
}

export!(TransformerImpl);

# Build the Rust transformer component
cargo build --target wasm32-wasip2 --release
cp target/wasm32-wasip2/release/transformer.wasm ../../composed/transformer.wasm

# Validate the component's interface matches the WIT
wasm-tools validate ../../composed/transformer.wasm --features component-model
wasm-tools component wit ../../composed/transformer.wasm

# Step 1: generate Python bindings from the WIT
# This creates a Python package you import in your implementation
componentize-py \
  --wit-path ../../wit \
  --world pipeline-world \
  bindings \
  bindings/

# Inspect what was generated -- package and class names come from here
ls bindings/
# Expect something like:
# bindings/my_org/doc_pipeline/
#   types.py        -- Document, ValidationError, etc.
#   validator.py    -- imported validator interface
#   transformer.py  -- imported transformer interface
# components/pipeline/app.py
# IMPORTANT: The imports below are illustrative.
# Use the generated bindings package as the source of truth for actual import paths.
# Generated package structure and class names depend on componentize-py version and WIT layout.
# Run `componentize-py bindings` first and inspect the output before writing this file.

# Generated types from the WIT 'types' interface
from bindings.my_org.doc_pipeline.types import Document

# Generated stubs for imported interfaces (validator and transformer)
# These are satisfied at composition time by the validator and transformer components
from bindings.my_org.doc_pipeline.validator import validate, validate_batch
from bindings.my_org.doc_pipeline.transformer import transform


class Pipeline:
    """
    Implements the 'process' export from pipeline-world.
    The class name must match what componentize-py expects for this world --
    check the generated bindings for the exact convention.
    """

    def process(self, docs: list[Document]) -> list[Document]:
        results = []

        for doc in docs:
            # Call the validator -- imported from the composed validator component
            validation = validate(doc)

            # result<document, validation-error> -- check is_ok before accessing value
            if not validation.is_ok:
                # In production, surface per-document errors rather than silently skipping
                print(f"pipeline: validation failed for {doc.id}")
                continue

            validated_doc = validation.value

            # Call the transformer -- imported from the composed transformer component
            transformed = transform(validated_doc, ["trim", "strip-html"])

            # option<document> -- None means transformation produced no output
            if transformed is not None:
                results.append(transformed)

        return results

# Step 2: compile the Python module into a WASM component
# At this point, validator and transformer imports are unsatisfied --
# the component references them but does not bundle them.
# Composition in the next step satisfies those imports.
componentize-py \
  --wit-path ../../wit \
  --world pipeline-world \
  componentize app \
  --output ../../composed/pipeline-pre-compose.wasm

# Validate the output
wasm-tools validate ../../composed/pipeline-pre-compose.wasm --features component-model
wasm-tools component wit ../../composed/pipeline-pre-compose.wasm
# Output should show: imports validator + transformer, exports process

# Install WAC
cargo install wac-cli

# Compose: plug validator and transformer into the pipeline
# The pipeline component is the "socket" (it imports validator + transformer)
# The validator and transformer components are the "plugs"
wac plug \
  composed/pipeline-pre-compose.wasm \
  --plug composed/validator.wasm \
  --plug composed/transformer.wasm \
  -o composed/pipeline.wasm

# Validate the result
wasm-tools validate composed/pipeline.wasm --features component-model
wasm-tools component wit composed/pipeline.wasm
# Should show: no unsatisfied imports, exports 'process'

# compose.yaml
# The root component is passed as a CLI argument, not in this file.
# search-paths: directories where wasm-tools looks for dependency components
search-paths:
  - composed

# definitions: paths to components that provide implementations
# These are string paths, not name/path objects.
definitions:
  - composed/validator.wasm
  - composed/transformer.wasm

wasm-tools compose \
  composed/pipeline-pre-compose.wasm \
  --config compose.yaml \
  --output composed/pipeline.wasm

error: type mismatch for import `my-org:doc-pipeline/validator`
expected type `(record (field "id" string) ...)`
found type `(record (field "id" string) ...)`

# Is this a valid WASM component?
wasm-tools validate composed/validator.wasm --features component-model

# What does the component actually export?
# Use this to verify -- do not expect byte-for-byte equality with your source WIT.
# The extracted WIT is normalized and may have a different structure.
# What you are checking: the world name, the exported interfaces, and the type shapes.
wasm-tools component wit composed/validator.wasm

# Run the same check on the composed pipeline
wasm-tools validate composed/pipeline.wasm --features component-model
wasm-tools component wit composed/pipeline.wasm
# Should show: imports (validator, transformer) satisfied, exports process

// test-host/src/main.rs
// Pin wasmtime and wasmtime-wasi to the same version as your tested environment.
// The WasiView trait and linker API change between major versions.
//
// Cargo.toml:
// [dependencies]
// wasmtime = "25.0.0"
// wasmtime-wasi = "25.0.0"
// anyhow = "1"

use wasmtime::component::{Component, Linker, bindgen};
use wasmtime::{Config, Engine, Store};
use wasmtime_wasi::{WasiCtxBuilder, WasiView, ResourceTable};

// bindgen! generates Rust types matching the WIT world at compile time.
// path must point to your WIT directory.
bindgen!({
    path: "../wit",
    world: "pipeline-world",
});

struct HostState {
    table: ResourceTable,
    wasi: wasmtime_wasi::WasiCtx,
}

impl WasiView for HostState {
    fn table(&mut self) -> &mut ResourceTable { &mut self.table }
    fn ctx(&mut self) -> &mut wasmtime_wasi::WasiCtx { &mut self.wasi }
}

fn main() -> anyhow::Result<()> {
    let mut config = Config::new();
    config.wasm_component_model(true);
    config.async_support(false);

    let engine = Engine::new(&config)?;
    let component = Component::from_file(&engine, "../composed/pipeline.wasm")?;

    let mut linker: Linker<HostState> = Linker::new(&engine);

    let wasi = WasiCtxBuilder::new().inherit_stdio().build();
    let mut store = Store::new(&engine, HostState {
        table: ResourceTable::new(),
        wasi,
    });

    let (pipeline, _) = PipelineWorld::instantiate(&mut store, &component, &linker)?;

    let docs = vec![
        Document { id: "doc1".into(), content: "hello world".into(), metadata: vec![] },
    ];

    let results = pipeline.my_org_doc_pipeline_pipeline().call_process(&mut store, &docs)?;

    for result in &results {
        println!("Result: id={}, content={}", result.id, result.content);
    }

    Ok(())
}

┌──────────────────────────────────────────────────────────┐
│  Platform host (Rust + Wasmtime)                         │
│                                                          │
│  ┌─────────────────────┐   ┌─────────────────────────┐   │
│  │  Plugin registry    │   │  Host API (WIT-defined) │   │
│  │  - load(path)       │   │  - key-value store      │   │
│  │  - unload(id)       │   │  - logging              │   │
│  │  - call(id, input)  │   │  - http-client          │   │
│  └──────────┬──────────┘   └────────────┬────────────┘   │
│             │                           │                │
│  ┌──────────▼───────────────────────────▼────────────┐   │
│  │              Wasmtime component runtime           │   │
│  └──────────┬────────────────────────────────────────┘   │
│             │  isolated instances                        │
│    ┌────────┴──────────┬──────────────────┐              │
│    │                   │                  │              │
│  ┌─▼──────────┐  ┌─────▼──────┐  ┌───────▼───────┐       │
│  │ plugin-A   │  │  plugin-B  │  │   plugin-C    │       │
│  │ (Go/TinyGo)│  │  (Rust)    │  │   (Python)    │       │
│  └────────────┘  └────────────┘  └───────────────┘       │
└──────────────────────────────────────────────────────────┘

// wit/plugin-interface.wit
package my-platform:[email protected];

interface plugin {
  // Every plugin must export these
  record plugin-metadata {
    name: string,
    version: string,
    capabilities: list<string>,
  }

  record plugin-input {
    event-type: string,
    payload: list<u8>,  // opaque bytes -- the platform does not interpret
  }

  variant plugin-result {
    success(list<u8>),
    failure(string),
    not-applicable,  // plugin signals it does not handle this event type
  }

  metadata: func() -> plugin-metadata;
  handle: func(input: plugin-input) -> plugin-result;
}

world plugin-world {
  // What the platform provides to plugins
  import my-platform:platform/[email protected];
  import wasi:logging/[email protected];

  // What every plugin must provide
  export plugin;
}

use wasmtime::component::{Component, Linker};
use wasmtime::{Engine, Store};
use std::collections::HashMap;

pub struct PluginRegistry {
    engine: Engine,
    linker: Linker<HostState>,
    plugins: HashMap<String, Component>,
}

impl PluginRegistry {
    pub fn load(&mut self, id: &str, wasm_path: &str) -> anyhow::Result<()> {
        let bytes = std::fs::read(wasm_path)?;
        wasmtime::component::Component::validate(&self.engine, &bytes)?;

        let component = Component::from_binary(&self.engine, &bytes)?;

        self.plugins.insert(id.to_string(), component);
        Ok(())
    }

    pub fn call(
        &self,
        id: &str,
        input: PluginInput,
        store: &mut Store<HostState>,
    ) -> anyhow::Result<PluginResult> {
        let component = self.plugins.get(id)
            .ok_or_else(|| anyhow::anyhow!("plugin '{}' not found", id))?;

        let instance = MyPlatformPlugin::instantiate(store, component, &self.linker)?;
        let result = instance.my_platform_plugin_plugin()
            .call_handle(store, &input)?;

        Ok(result)
    }
}