Compilation fails because the generated component adapter becomes internally inconsistent when -W concurrency-support=n is used with a component that still requires shared-memory-aware lowering paths.

If your build breaks while compiling a WebAssembly component from the cm-online-stats input, the problem is not the benchmark itself. The failure comes from a mismatch between the selected concurrency configuration and the generated adapter code. In practice, the compiler emits an adapter that is invalid for the chosen settings, so validation fails during compilation instead of execution.

Reproducing the failure

This issue typically appears with a workflow similar to the following:

cargo run -- compile input.wat -W concurrency-support=n

Using the referenced component input causes the compiler to generate a component adapter that does not match the feature assumptions implied by concurrency-support=n. The result is a compile-time validation error, often reported as an invalid module, malformed adapter, or failure during lowering/lifting generation depending on the exact toolchain revision.

Understanding the Root Cause

The underlying bug is a feature-gating mismatch in the adapter generation pipeline.

When the compiler translates a component, it may synthesize helper modules and adapter functions for canonical ABI operations such as lifting, lowering, memory access, and resource plumbing. Those generated artifacts must be valid for the exact set of enabled WebAssembly and component-model features.

With -W concurrency-support=n, the compiler is explicitly told to disable concurrency-related support. However, the adapter generation path can still emit code patterns that assume concurrency-capable semantics are available, or at least emit code shaped for a configuration other than the one requested. That means the generated adapter may reference instructions, memory behavior, or import/export structure that no longer satisfies validation rules under the disabled-concurrency configuration.

In other words:

• The input component is accepted by the front end.
• The compiler starts generating a component adapter.
• The adapter generator does not fully honor the concurrency-support=n setting.
• The resulting generated WebAssembly is invalid for that feature set.
• Compilation fails during validation of the synthesized artifact.

This is why the error can feel confusing: your source input is not necessarily malformed, but the generated intermediate output is.

Step-by-Step Solution

The correct fix is to ensure the adapter generator fully respects the disabled concurrency setting. Until that lands in your toolchain, use one of the following approaches.

1. Confirm the failure is tied to concurrency flagging

cargo run -- compile input.wat

cargo run -- compile input.wat -W concurrency-support=n

If the first succeeds and the second fails, you have confirmed the issue is specifically triggered by the concurrency configuration.

2. Prefer the default or enabled concurrency mode as a temporary workaround

If your environment allows it, remove the flag or use the compiler default so the generated adapter matches the expected feature set:

cargo run -- compile input.wat

If your toolchain supports explicit enablement, test that path as well:

cargo run -- compile input.wat -W concurrency-support=y

This is the fastest workaround when you need to keep moving.

3. Update to a toolchain version containing the fix

If the issue has already been patched upstream, rebuild with the latest revision:

git pull

cargo clean

cargo build

cargo run -- compile input.wat -W concurrency-support=n

This matters because adapter generation bugs are often fixed in compiler internals without changes required in user components.

4. Patch the adapter generation logic if you are fixing the compiler yourself

If you are working inside the compiler codebase, the durable fix is to gate all concurrency-sensitive adapter generation on the actual value of concurrency-support. The implementation details vary by project, but the audit usually looks like this:

// Pseudocode: ensure generated adapter paths honor the configured feature set.

if !options.concurrency_support_enabled() {
    // Do not emit concurrency-dependent adapter structures.
    // Select the non-concurrent canonical ABI lowering path.
    // Avoid shared-memory-specific assumptions.
    generate_single_threaded_adapter();
} else {
    generate_concurrent_adapter();
}

While applying the fix, audit these areas carefully:

• Canonical lowering/lifting helpers
• Generated memory access shims
• Shared memory assumptions in adapter modules
• Feature propagation from CLI flags into validation and codegen
• Conditional imports/exports added only for concurrent mode

5. Add a regression test

This bug should have a dedicated regression test so invalid generated adapters do not return in future releases.

# Example test workflow
cargo run -- compile tests/fixtures/cm-online-stats.wat -W concurrency-support=n

The test should assert that compilation either:

• succeeds fully with a valid generated adapter, or
• fails earlier with a clear user-facing diagnostic if the configuration is intentionally unsupported.

6. Validate the generated artifact when debugging deeply

If your compiler can emit intermediates, inspect the generated adapter and run it through your validator. This helps distinguish a front-end parse issue from a backend generation bug.

# Pseudocode example only
compiler --emit-adapter input.wat -W concurrency-support=n > adapter.wat
wasm-tools validate adapter.wat

If the adapter alone fails validation, you have direct proof that the generator—not the original input—is at fault.

Common Edge Cases

• Stale build artifacts: Generated adapter code may appear unchanged after a source fix if you do not run cargo clean. Always test from a clean build when validating compiler bugs.
• Mixed feature flags: Other Wasm feature toggles can interact with concurrency behavior. If multiple -W options are set, isolate them one by one.
• Validator version mismatch: A newer generator paired with an older validator can produce misleading errors. Keep your Wasm toolchain components aligned.
• Different failure surfaces: Some revisions fail during code generation, others during validation, and others when instantiating the synthesized adapter. The root issue can still be the same.
• Component-model-only inputs: Plain core Wasm modules may compile fine, while component model inputs fail because only components need these adapters.
• Assuming the source benchmark is broken: The linked benchmark is useful mainly because it exercises the buggy code path. It is a trigger, not necessarily the cause.

FAQ

Why does compilation fail only when I pass -W concurrency-support=n?

Because that flag changes the expected feature environment for generated code. The bug is that the compiler still emits an adapter shaped for a different environment, so validation rejects it.

Is this a problem in my .wat file?

Usually no. The input component is valid enough to reach adapter generation. The failure happens because the compiler synthesizes an invalid intermediate module or adapter after reading your input.

What is the safest workaround before the upstream fix lands?

Use the compiler default configuration or a mode where concurrency support remains enabled, provided that matches your deployment constraints. Then upgrade to a version containing the proper adapter-generation fix.

The key takeaway is simple: this bug is caused by invalid generated adapter code, not by invalid source text. Any permanent fix must make adapter generation and validation obey the same concurrency feature contract.