Error: import `wasi-stderr` has the wrong type

Caused by:
    0: instance export `print` has the wrong type
    1: expected func found nothing

interface imports {
  thunk: func()
}

default world smoke {
  import imports: self.imports

  export thunk: func()
}

[package]
name = "guest"
version = "0.1.0"
edition = "2021"

[dependencies]
wit-bindgen = { git = "https://github.com/bytecodealliance/wit-bindgen" }

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

wit_bindgen::generate!("smoke");

struct Exports;

export_smoke!(Exports);

impl Smoke for Exports {
    fn thunk() {
        imports::thunk();
    }
}

cargo build --target wasm-wasi32

wasm-tools component new <...>/guest.wasm -o <...>/guest.wasm" --adapt <...>/wasi_snapshot_preview1.wasm"

[package]
name = "host"
version = "0.1.0"
edition = "2021"

[dependencies]
wasmtime = { git = 'https://github.com/bytecodealliance/wasmtime', features = ['component-model'] }
wit-bindgen = { git = "https://github.com/bytecodealliance/wit-bindgen" }
anyhow = "1.0.69"

use anyhow::Result;
use std::error::Error;
use wasmtime::component::{Component, Instance, Linker};
use wasmtime::{Config, Engine, Store};

wasmtime::component::bindgen!("smoke");

#[derive(Default)]
struct Wasi<T>(T);

#[derive(Default)]
pub struct MyImports {
    hit: bool,
}

impl imports::Imports for MyImports {
    fn thunk(&mut self) -> Result<()> {
        self.hit = true;
        println!("in the host");
        Ok(())
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let wasm = "<...>/guest.wasm";

    run(
        wasm,
        |linker| Smoke::add_to_linker(linker, |x| &mut x.0),
        |store, component, linker| Smoke::instantiate(store, component, linker),
        run_test,
    )?;

    Ok(())
}

fn run<T, U>(
    wasm: &str,
    add_to_linker: fn(&mut Linker<Wasi<T>>) -> Result<()>,
    instantiate: fn(&mut Store<Wasi<T>>, &Component, &Linker<Wasi<T>>) -> Result<(U, Instance)>,
    test: fn(U, &mut Store<Wasi<T>>) -> Result<()>,
) -> Result<()>
where
    T: Default,
{
    let mut config = Config::new();
    config.cache_config_load_default()?;
    config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
    config.wasm_component_model(true);
    let engine = Engine::new(&config)?;

    let component = Component::from_file(&engine, &wasm)?;
    let mut linker = Linker::new(&engine);

    add_to_linker(&mut linker)?;
    let mut store = Store::new(&engine, Wasi::default());
    let (exports, _) = instantiate(&mut store, &component, &linker)?;

    println!("testing {wasm:?}");
    test(exports, &mut store)?;

    Ok(())
}

fn run_test(exports: Smoke, store: &mut Store<crate::Wasi<MyImports>>) -> Result<()> {
    exports.call_thunk(&mut *store)?;

    assert!(store.data().0.hit);

    Ok(())
}

interface wasi-stderr {
  print: func(message: string)
}