Skip to content

Composed component from wac plug throws NotImplementedError #185

Open

Description

@peter-facko

Hello,

I am experimenting with WASM components. I have two packages, A and B.

package example:a;

interface %type {
    record blob {
        x: f64,
    }
}

interface %interface {
    use %type.{blob};

    f-a: func(x: f64) -> blob;
}

world %world {
    export %type;
    export %interface;
}
from a.interface.wit_world.exports import Interface as Base
from a.interface.wit_world.exports.type import Blob

class Interface(Base):
    def f_a(self, x: float):
        return Blob(x=x * 5)
package example:b;

interface %interface {
    use example:a/%type.{blob};

    f-b: func(x: f64) -> blob;
}

world %world {
    import example:a/%interface;

    export %interface;
}
from b.interface.wit_world.exports import Interface as Base
from b.interface.wit_world.imports.interface import f_a

class Interface(Base):
    def f_b(self, x: float):
        return f_a(f_a(x).x)

If I do componentize-py componentize on A, I can run this on the output successfully

wasmtime run --invoke 'f-a(3)' a.wasm

However, when i do

wac plug --plug a.wasm b.wasm --output composed.wasm
wasmtime run --invoke 'f-b(3)' composed.wasm

gives me

Traceback (most recent call last):
  File "/1/b/implementation/__init__.py", line 11, in f_b1
  File "/1/b/interface/wit_world/imports/interface.py", line 15, in f_a
NotImplementedError

thread '<unnamed>' (1) panicked at runtime/src/lib.rs:1290:25:
Python function threw an unexpected exception
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Error: failed to run main module `composed.wasm`

Caused by:
    0: error while executing at wasm backtrace:
           0: 0x4b05657 - libc.so!abort
           1: 0x2695395 - <unknown>!<wasm function 307>
           2: 0x31fbc00 - libcomponentize_py_runtime_sync.so!std::sys::pal::wasip1::helpers::abort_internal
           3: 0x31fdce0 - libcomponentize_py_runtime_sync.so!std::process::abort
           4: 0x31eeaf7 - libcomponentize_py_runtime_sync.so!__rustc::__rust_abort
           5: 0x318476f - libcomponentize_py_runtime_sync.so!__rustc::__rust_start_panic
           6: 0x31ff807 - libcomponentize_py_runtime_sync.so!__rustc::rust_panic
           7: 0x3200983 - libcomponentize_py_runtime_sync.so!std::panicking::panic_with_hook
           8: 0x32038fc - libcomponentize_py_runtime_sync.so!std::panicking::panic_handler::{closure#0}
           9: 0x320388f - libcomponentize_py_runtime_sync.so!std::sys::backtrace::__rust_end_short_backtrace::<std::panicking::panic_handler::{closure#0}, !>
          10: 0x31ff8de - libcomponentize_py_runtime_sync.so!__rustc::rust_begin_unwind
          11: 0x32453ff - libcomponentize_py_runtime_sync.so!core::panicking::panic_fmt
          12: 0x31748f7 - libcomponentize_py_runtime_sync.so!wit_dylib_export_call
          13: 0x4cd1934 - <unknown>!example:b/%interface#f-b
       note: using the `WASMTIME_BACKTRACE_DETAILS=1` environment variable may show more debugging information
    1: wasm trap: wasm `unreachable` instruction executed

Why doesn't the implementation of f-a end up in the composed component?

Activity

  1. dicej commented on Dec 12, 2025

    @dicej
    Collaborator

    Thanks for reporting this.

    I wasn't sure what specific commands you were using to build the components, so I guessed and made some tweaks to the Python code you provided since it wouldn't run otherwise:

    mkdir foo
    cd foo
    python3 -m venv .venv
    source .venv/bin/activate
    pip install componentize-py==0.19.3
    mkdir -p wit/deps/a
    cat >wit/deps/a/a.wit <<EOF
    package example:a;
    
    interface %type {
        record blob {
            x: f64,
        }
    }
    
    interface %interface {
        use %type.{blob};
    
        f-a: func(x: f64) -> blob;
    }
    
    world %world {
        export %type;
        export %interface;
    }
    EOF
    cat >wit/b.wit <<EOF
    package example:b;
    
    interface %interface {
        use example:a/%type.{blob};
    
        f-b: func(x: f64) -> blob;
    }
    
    world %world {
        import example:a/%interface;
    
        export %interface;
    }
    EOF
    cat >a.py <<EOF
    from wit_world.exports import Interface as Base
    from wit_world.exports.type import Blob
    
    class Interface(Base):
        def f_a(self, x: float):
            return Blob(x=x * 5)
    EOF
    cat >b.py <<EOF
    from wit_world.exports import Interface as Base
    from wit_world.imports.interface import f_a
    
    class Interface(Base):
        def f_b(self, x: float):
            return f_a(f_a(x).x)
    EOF
    componentize-py -d wit -w 'example:a/%world' componentize a -o a.wasm
    componentize-py -d wit -w 'example:b/%world' componentize b -o b.wasm
    wac plug --plug a.wasm b.wasm -o composed.wasm
    wasmtime run --invoke 'f-b(3)' composed.wasm

    When I run that, I get {x: 75}, which appears correct. Can you compare that with the commands you used?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions