2026年のWebAssembly: ブラウザを超えて — WASI、エッジ、プラグインシステム

# Install the WASI target
rustup target add wasm32-wasip2

# Create a simple HTTP handler
cargo new wasm-handler
cd wasm-handler

# Cargo.toml
[dependencies]
wasi = "0.13"
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// src/main.rs
use std::io::{self, Read, Write};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Request {
    name: String,
    multiplier: u32,
}

#[derive(Serialize)]
struct Response {
    message: String,
    result: u64,
}

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();

    let req: Request = serde_json::from_str(&input).unwrap_or(Request {
        name: "world".to_string(),
        multiplier: 1,
    });

    let response = Response {
        message: format!("Hello, {}!", req.name),
        result: fibonacci(req.multiplier as u64),
    };

    io::stdout()
        .write_all(serde_json::to_string(&response).unwrap().as_bytes())
        .unwrap();
}

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a = 0u64;
            let mut b = 1u64;
            for _ in 2..=n {
                let c = a + b;
                a = b;
                b = c;
            }
            b
        }
    }
}

cargo build --target wasm32-wasip2 --release
# Output: target/wasm32-wasip2/release/wasm-handler.wasm (< 500 KB)

# Run with wasmtime
echo '{"name":"developer","multiplier":30}' | wasmtime target/wasm32-wasip2/release/wasm-handler.wasm
# Output: {"message":"Hello, developer!","result":832040}

pip install wasmtime

# host.py
from wasmtime import Store, Module, Instance, Linker, WasiConfig
import json

def run_wasm_handler(wasm_path: str, input_data: dict) -> dict:
    store = Store()

    # Configure WASI capabilities — deny-by-default
    wasi_config = WasiConfig()
    # We do NOT grant filesystem or network access — pure computation only
    store.set_wasi(wasi_config)

    linker = Linker(store.engine)
    linker.define_wasi()

    module = Module.from_file(store.engine, wasm_path)
    instance = linker.instantiate(store, module)

    # The WASM module reads from stdin and writes to stdout
    # For real production use, consider wasmtime's memory API for direct buffer passing
    import subprocess
    result = subprocess.run(
        ["wasmtime", wasm_path],
        input=json.dumps(input_data).encode(),
        capture_output=True,
        timeout=5,  # hard timeout — Wasm can't escape it
    )

    return json.loads(result.stdout)

result = run_wasm_handler(
    "target/wasm32-wasip2/release/wasm-handler.wasm",
    {"name": "Python host", "multiplier": 40}
)
print(result)  # {"message": "Hello, Python host!", "result": 102334155}

cargo install extism-pdk
cargo new --lib my-plugin
cd my-plugin

# Cargo.toml
[lib]
crate-type = ["cdylib"]

[dependencies]
extism-pdk = "1"
serde = { version = "1", features = ["derive"] }

// src/lib.rs
use extism_pdk::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Input {
    text: String,
    max_words: usize,
}

#[derive(Serialize)]
struct Output {
    summary: String,
    word_count: usize,
}

#[plugin_fn]
pub fn summarize(input: Json<Input>) -> FnResult<Json<Output>> {
    let words: Vec<&str> = input.text.split_whitespace().collect();
    let truncated = words[..words.len().min(input.max_words)].join(" ");

    Ok(Json(Output {
        summary: if words.len() > input.max_words {
            format!("{}...", truncated)
        } else {
            truncated
        },
        word_count: words.len(),
    }))
}

cargo build --target wasm32-unknown-unknown --release

# host.py
import extism
import json

manifest = {"wasm": [{"path": "target/wasm32-unknown-unknown/release/my_plugin.wasm"}]}

with extism.Plugin(manifest) as plugin:
    result = plugin.call(
        "summarize",
        json.dumps({"text": "WebAssembly is a portable compilation target...", "max_words": 5})
    )
    print(json.loads(result))
    # {"summary": "WebAssembly is a portable compilation...", "word_count": 8}

# Deploy a Rust Axum app to Fermyon Spin
spin new -t http-rust my-app
cd my-app
spin build
spin deploy

# Run inference at the edge
wasm-pack build --target web
# Deploy to Cloudflare Workers — inference runs in each PoP

// my-interface.wit
package my:plugin;

interface transform {
    summarize: func(text: string, max-words: u32) -> string;
}