Unify wasmtime configuration to fix precompilation (#3730)

Author: vigoo

AGENTS.md

@@ -45,6 +45,24 @@ exec --fail-on-error ${golem} build -P release --yes
 '''
 ```
 
+### Wasmtime configuration compatibility
+
+All production engines that compile, load, or inspect components must use the shared constructors
+in `golem_common::wasmtime_config`. This includes the component compilation service, worker
+executor, component metadata extraction, and any future component tools. Do not set Wasmtime
+features or tunables independently at those call sites; change the shared constructor instead and
+verify every consumer still uses it.
+
+The component compilation service serializes precompiled `.cwasm` artifacts that the worker
+executor deserializes. Wasmtime validates artifact-affecting feature and tunable settings during
+deserialization. A mismatch makes the executor reject the cached artifact and compile the original
+component again, causing a severe cold-start regression. When changing the Wasmtime version or
+configuration, run the cross-engine precompiled-component compatibility test in `golem-common`.
+
+Minimal Wasmtime engines in unit tests may use a local configuration only when they exercise an
+isolated host primitive and neither load production components nor produce or consume precompiled
+artifacts. Tests intended to mirror production component behavior must use the shared constructor.
+
 ## Testing
 
 Tests use [test-r](https://test-r.vigoo.dev). **Important:** Each test file must import `test_r::test` or tests will not run.

golem-common/src/lib.rs

@@ -65,6 +65,8 @@ pub mod retries;
 pub mod serialization;
 #[cfg(feature = "full")]
 pub mod tracing;
+#[cfg(feature = "full")]
+pub mod wasmtime_config;
 
 mod macros;
 

golem-common/src/model/agent/extraction.rs

@@ -19,6 +19,7 @@ use crate::schema::agent::wit::{decode_agent_error_rejecting_quota_with, decode_
 use crate::schema::tool::Tool;
 use crate::schema::tool::validation::validate_tool;
 use crate::schema::tool::wit::{decode_tool, wire as tool_wire};
+use crate::wasmtime_config::create_wasmtime_config;
 use anyhow::anyhow;
 use golem_schema::schema::wit::{
     QuotaTokenHandleDropper, QuotaTokenHandleRep, SecretHandleDropper, SecretHandleRep,
@@ -133,24 +134,7 @@ async fn extract_component_metadata_impl(
     enable_fs_cache: bool,
     include_tools: bool,
 ) -> anyhow::Result<ExtractedComponentMetadata> {
-    let mut config = wasmtime::Config::default();
-    config.wasm_multi_value(true);
-    config.wasm_component_model(true);
-    // Required for WASI p3: enables the async ABI (stream<T>, future<T>,
-    // async lift/lower, error-context). Without this, components that use
-    // any p3 async builtins fail to parse via `Component::from_file`.
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_error_context(true);
-    config.epoch_interruption(true);
-    config.consume_fuel(true);
-    config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-
-    if enable_fs_cache {
-        config.cache(Some(
-            wasmtime::Cache::new(wasmtime::CacheConfig::new()).expect("Failed to initialize cache"),
-        ));
-    }
-
+    let config = create_wasmtime_config(enable_fs_cache);
     let engine = Engine::new(&config)?;
     let mut linker: Linker<Host> = Linker::new(&engine);
     linker.allow_shadowing(true);

golem-common/src/wasmtime_config.rs

@@ -0,0 +1,72 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use wasmtime::{Config, WasmBacktraceDetails};
+
+/// Creates the Wasmtime configuration shared by every Golem component engine.
+///
+/// A component compiled by one Golem service can be deserialized by another,
+/// so compilation-affecting settings must not be configured independently at
+/// individual call sites.
+pub fn create_wasmtime_config(enable_fs_cache: bool) -> Config {
+    let mut config = Config::default();
+
+    config.wasm_multi_value(true);
+    config.wasm_component_model(true);
+    config.wasm_component_model_async(true);
+    config.wasm_component_model_error_context(true);
+    config.wasm_threads(false);
+    config.shared_memory(false);
+    config.epoch_interruption(true);
+    config.consume_fuel(true);
+    config.concurrency_support(true);
+    config.wasm_backtrace_details(WasmBacktraceDetails::Enable);
+
+    if enable_fs_cache {
+        config.cache(Some(
+            wasmtime::Cache::new(wasmtime::CacheConfig::new()).expect("Failed to initialize cache"),
+        ));
+    }
+
+    config
+}
+
+pub fn create_wasmtime_config_with_fs_cache() -> Config {
+    create_wasmtime_config(true)
+}
+
+pub fn create_wasmtime_config_without_fs_cache() -> Config {
+    create_wasmtime_config(false)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test_r::test;
+    use wasmtime::Engine;
+    use wasmtime::component::Component;
+
+    #[test]
+    fn precompiled_components_are_compatible_across_engines() -> anyhow::Result<()> {
+        let compilation_engine = Engine::new(&create_wasmtime_config_with_fs_cache())?;
+        let precompiled_component = compilation_engine.precompile_component(b"(component)")?;
+        let executor_engine = Engine::new(&create_wasmtime_config_without_fs_cache())?;
+
+        // SAFETY: these bytes were produced by Wasmtime in this process and are
+        // deserialized without being modified.
+        unsafe { Component::deserialize(&executor_engine, precompiled_component) }?;
+
+        Ok(())
+    }
+}

golem-common/tests/agent_extraction.rs

@@ -14,6 +14,7 @@
 
 use assert2::assert;
 use golem_common::model::agent::extraction::extract_agent_type_schemas;
+use golem_common::wasmtime_config::create_wasmtime_config_without_fs_cache;
 use std::path::PathBuf;
 use std::str::FromStr;
 use test_r::test;
@@ -51,10 +52,7 @@ async fn can_extract_agent_type_schemas_from_component_importing_p3_http() -> an
     // Guard: the fixture must actually import P3 `wasi:http`, otherwise a
     // future rebuild of the component would silently defeat the purpose of
     // this regression test.
-    let mut config = wasmtime::Config::default();
-    config.wasm_component_model(true);
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_error_context(true);
+    let config = create_wasmtime_config_without_fs_cache();
     let engine = wasmtime::Engine::new(&config)?;
     let component = wasmtime::component::Component::from_file(&engine, &wasm_path)?;
     let imports_p3_http = component

golem-component-compilation-service/src/lib.rs

@@ -36,7 +36,6 @@ use tonic::codec::CompressionEncoding;
 use tonic_tracing_opentelemetry::middleware;
 use tonic_tracing_opentelemetry::middleware::filters;
 use tracing::{Instrument, info};
-use wasmtime::WasmBacktraceDetails;
 
 pub mod config;
 mod grpc;
@@ -168,24 +167,5 @@ async fn start_grpc_server(
 }
 
 fn create_wasmtime_config(engine_config: &config::EngineConfig) -> wasmtime::Config {
-    let mut config = wasmtime::Config::default();
-
-    config.wasm_multi_value(true);
-    config.wasm_component_model(true);
-    // Must match the executor's enabled wasm features so that components
-    // pre-compiled here are accepted at runtime. WASI p3 components use the
-    // async ABI (stream<T>, future<T>, async lift/lower, error-context).
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_error_context(true);
-    config.epoch_interruption(true);
-    config.consume_fuel(true);
-    config.wasm_backtrace_details(WasmBacktraceDetails::Enable);
-
-    if engine_config.enable_fs_cache {
-        config.cache(Some(
-            wasmtime::Cache::new(wasmtime::CacheConfig::new()).expect("Failed to initialize cache"),
-        ));
-    }
-
-    config
+    golem_common::wasmtime_config::create_wasmtime_config(engine_config.enable_fs_cache)
 }

golem-worker-executor/src/bootstrap.rs

@@ -57,17 +57,12 @@ pub async fn run(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::services::golem_config::EngineConfig;
     use test_r::test;
     use wasmtime::{Engine, Module};
 
     #[test]
     fn production_engine_rejects_shared_memory_modules() {
-        let config = <ServerBootstrap as Bootstrap<Context>>::create_wasmtime_config(
-            &ServerBootstrap,
-            &EngineConfig::default(),
-        );
+        let config = golem_common::wasmtime_config::create_wasmtime_config_without_fs_cache();
         let engine = Engine::new(&config).unwrap();
 
         assert!(Module::new(&engine, "(module (memory 1 2 shared))").is_err());

golem-worker-executor/src/lib.rs

@@ -55,7 +55,7 @@ use crate::services::card::{CardService, CardServiceDefault};
 use crate::services::component::ComponentService;
 use crate::services::events::Events;
 use crate::services::golem_config::{
-    EngineConfig, GolemConfig, HttpClientConfig, IndexedStorageConfig, KeyValueStorageConfig,
+    GolemConfig, HttpClientConfig, IndexedStorageConfig, KeyValueStorageConfig,
     KeyValueStorageInnerConfig, SchedulerStorageConfig,
 };
 use crate::services::key_value::{DefaultKeyValueService, KeyValueService};
@@ -135,8 +135,8 @@ use tonic::transport::Server;
 use tonic_tracing_opentelemetry::middleware;
 use tonic_tracing_opentelemetry::middleware::filters;
 use tracing::{Instrument, info};
+use wasmtime::Engine;
 use wasmtime::component::{HasSelf, Linker};
-use wasmtime::{Config, Engine, WasmBacktraceDetails};
 
 pub struct RunDetails {
     pub http_port: u16,
@@ -463,34 +463,6 @@ pub trait Bootstrap<Ctx: WorkerCtx> {
         ))
     }
 
-    /// Can be overridden to customize the wasmtime configuration
-    fn create_wasmtime_config(&self, engine_config: &EngineConfig) -> Config {
-        let mut config = Config::default();
-
-        config.wasm_multi_value(true);
-        config.wasm_component_model(true);
-        // Required for WASI p3: enables the async ABI (stream<T>, future<T>,
-        // async lift/lower, error-context). Without this, components that use
-        // any p3 async builtins fail to instantiate.
-        config.wasm_component_model_async(true);
-        config.wasm_component_model_error_context(true);
-        // Golem does not expose wasi-threads or a durable shared-memory runtime.
-        config.wasm_threads(false);
-        config.shared_memory(false);
-        config.epoch_interruption(true);
-        config.consume_fuel(true);
-        config.wasm_backtrace_details(WasmBacktraceDetails::Enable);
-
-        if engine_config.enable_fs_cache {
-            config.cache(Some(
-                wasmtime::Cache::new(wasmtime::CacheConfig::new())
-                    .expect("Failed to initialize cache"),
-            ));
-        }
-
-        config
-    }
-
     /// This method is responsible for linking all the host function implementations the worker
     /// executor supports.
     fn create_wasmtime_linker(&self, engine: &Engine) -> anyhow::Result<Linker<Ctx>> {
@@ -853,7 +825,8 @@ pub async fn create_worker_executor_impl<
         shutdown_token.clone(),
     );
 
-    let config = bootstrap.create_wasmtime_config(&golem_config.engine);
+    let config =
+        golem_common::wasmtime_config::create_wasmtime_config(golem_config.engine.enable_fs_cache);
     let engine = Arc::new(Engine::new(&config)?);
     let linker = bootstrap.create_wasmtime_linker(&engine)?;
 

golem-worker-executor/tests/concurrent_delivery_order.rs

@@ -37,7 +37,7 @@
 
 use test_r::test;
 use wasmtime::component::{Accessor, Component, Linker};
-use wasmtime::{Config, Engine, Store};
+use wasmtime::{Engine, Store};
 
 /// Host-side state driving the completion order of the bespoke `call` host
 /// function.
@@ -49,12 +49,7 @@ struct DeliveryState {
 }
 
 fn engine() -> Engine {
-    let mut config = Config::default();
-    // Mirror the production component-model-async configuration (see
-    // `Golem::create_wasmtime_config`).
-    config.wasm_component_model(true);
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_error_context(true);
+    let config = golem_common::wasmtime_config::create_wasmtime_config_without_fs_cache();
     Engine::new(&config).expect("failed to create engine")
 }
 
@@ -116,6 +111,8 @@ async fn delivery_order_for(schedule: Vec<u32>) -> Vec<u32> {
         .expect("register golem:cmtest/host#call");
 
     let mut store = Store::new(&engine, DeliveryState { schedule, step: 0 });
+    store.set_fuel(u64::MAX).expect("set test fuel");
+    store.set_epoch_deadline(u64::MAX);
     let instance = linker
         .instantiate_async(&mut store, &component)
         .await

golem-worker-executor/tests/concurrent_runtime_events.rs

@@ -44,15 +44,10 @@ use std::sync::{Arc, Mutex};
 
 use test_r::test;
 use wasmtime::component::{Accessor, Component, Linker};
-use wasmtime::{Config, Engine, Store, StoreContextMut};
+use wasmtime::{Engine, Store, StoreContextMut};
 
 fn engine() -> Engine {
-    let mut config = Config::default();
-    // Mirror the production component-model-async configuration (see
-    // `Golem::create_wasmtime_config`).
-    config.wasm_component_model(true);
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_error_context(true);
+    let config = golem_common::wasmtime_config::create_wasmtime_config_without_fs_cache();
     Engine::new(&config).expect("failed to create engine")
 }
 
@@ -168,6 +163,8 @@ async fn run_cancel_one() -> CancelShared {
     .expect("register golem:cmtest/host#observed");
 
     let mut store = Store::new(&engine, ());
+    store.set_fuel(u64::MAX).expect("set test fuel");
+    store.set_epoch_deadline(u64::MAX);
     let instance = linker
         .instantiate_async(&mut store, &component)
         .await
@@ -344,6 +341,8 @@ async fn run_observe_completions(schedule: Vec<u32>) -> (Vec<u32>, ObserveShared
     }
 
     let mut store = Store::new(&engine, ());
+    store.set_fuel(u64::MAX).expect("set test fuel");
+    store.set_epoch_deadline(u64::MAX);
     let instance = linker
         .instantiate_async(&mut store, &component)
         .await