diff --git a/crates/fuzzing/src/oracles/component_api.rs b/crates/fuzzing/src/oracles/component_api.rs
index 24ab9a1be79f..1eaa41b7ba4d 100644
--- a/crates/fuzzing/src/oracles/component_api.rs
+++ b/crates/fuzzing/src/oracles/component_api.rs
@@ -10,7 +10,6 @@ use crate::block_on;
 use crate::generators::{self, CompilerStrategy, InstanceAllocationStrategy};
 use crate::oracles::log_wasm;
 use arbitrary::{Arbitrary, Unstructured};
-use std::any::Any;
 use std::fmt::Debug;
 use std::ops::ControlFlow;
 use wasmtime::component::{
@@ -264,16 +263,16 @@ where
 {
     crate::init_fuzzing();
 
-    let mut store = store::<Box<dyn Any + Send>>(input, Box::new(()))?;
+    let mut store = store::<Option<(P, R)>>(input, None)?;
     let engine = store.engine();
     let wat = declarations.make_component();
     let wat = wat.as_bytes();
     crate::oracles::log_wasm(wat);
     let component = Component::new(&engine, wat).unwrap();
-    let mut linker = Linker::new(&engine);
+    let mut linker: Linker<Option<(P, R)>> = Linker::new(&engine);
 
     fn host_function<P, R>(
-        cx: StoreContextMut<'_, Box<dyn Any + Send>>,
+        cx: StoreContextMut<'_, Option<(P, R)>>,
         params: P,
     ) -> wasmtime::Result<R>
     where
@@ -281,7 +280,7 @@ where
         R: Debug + Clone + 'static,
     {
         log::trace!("received parameters {params:?}");
-        let data: &(P, R) = cx.data().downcast_ref().unwrap();
+        let data: &(P, R) = cx.data().as_ref().unwrap();
         let (expected_params, result) = data;
         assert_eq!(params, *expected_params);
         log::trace!("returning result {result:?}");
@@ -291,9 +290,10 @@ where
     if declarations.options.host_async {
         linker
             .root()
-            .func_wrap_concurrent(IMPORT_FUNCTION, |a, params| {
+            .func_wrap_concurrent(IMPORT_FUNCTION, |a, params: P| {
                 Box::pin(async move {
-                    a.with(|mut cx| host_function::<P, R>(cx.as_context_mut(), params))
+                    a.with(|mut cx| host_function(cx.as_context_mut(), params))
+                        .await
                 })
             })
             .unwrap();
@@ -319,7 +319,7 @@ where
         while iters.next().is_some() && input.arbitrary()? {
             let params = input.arbitrary::<P>()?;
             let result = input.arbitrary::<R>()?;
-            *store.data_mut() = Box::new((params.clone(), result.clone()));
+            *store.data_mut() = Some((params.clone(), result.clone()));
             log::trace!("passing in parameters {params:?}");
             let actual = if declarations.options.guest_caller_async {
                 store
@@ -381,7 +381,11 @@ pub fn dynamic_component_api_target(input: &mut arbitrary::Unstructured) -> arbi
             .func_new_concurrent(IMPORT_FUNCTION, {
                 move |cx: &Accessor<_, _>, _, params: &[Val], results: &mut [Val]| {
                     Box::pin(async move {
+                        // See the note above: drive the always-ready
+                        // `Accessor::with` future with `now_or_never` rather than
+                        // `.await` to avoid tripping Send inference.
                         cx.with(|mut store| host_function(store.as_context_mut(), params, results))
+                            .await
                     })
                 }
             })
diff --git a/crates/misc/component-async-tests/src/resource_stream.rs b/crates/misc/component-async-tests/src/resource_stream.rs
index c54b025d6ae6..ea2daae0a8b4 100644
--- a/crates/misc/component-async-tests/src/resource_stream.rs
+++ b/crates/misc/component-async-tests/src/resource_stream.rs
@@ -38,14 +38,16 @@ impl<T> bindings::local::local::resource_stream::HostWithStore<T> for Ctx {
         accessor: &Accessor<T, Self>,
         count: u32,
     ) -> wasmtime::Result<StreamReader<Resource<ResourceStreamX>>> {
-        accessor.with(|mut access| {
-            let (mut tx, rx) = mpsc::channel(usize::try_from(count).unwrap());
-            for _ in 0..count {
-                tx.try_send(access.get().table.push(ResourceStreamX)?)
-                    .unwrap()
-            }
-            StreamReader::new(access, PipeProducer::new(rx))
-        })
+        accessor
+            .with(|mut access| {
+                let (mut tx, rx) = mpsc::channel(usize::try_from(count).unwrap());
+                for _ in 0..count {
+                    tx.try_send(access.get().table.push(ResourceStreamX)?)
+                        .unwrap()
+                }
+                StreamReader::new(access, PipeProducer::new(rx))
+            })
+            .await
     }
 }
 
diff --git a/crates/misc/component-async-tests/src/yield_runner.rs b/crates/misc/component-async-tests/src/yield_runner.rs
index bdeb3217d792..bf13feacd439 100644
--- a/crates/misc/component-async-tests/src/yield_runner.rs
+++ b/crates/misc/component-async-tests/src/yield_runner.rs
@@ -63,9 +63,9 @@ impl<T> bindings::local::local::ready::HostThingWithStore<T> for Ctx {
         accessor: &Accessor<T, Self>,
         thing: Resource<Thing>,
     ) -> wasmtime::Result<()> {
-        let wakers = accessor.with(|mut view| {
-            Ok::<_, wasmtime::Error>(view.get().table.get(&thing)?.wakers.clone())
-        })?;
+        let wakers = accessor
+            .with(|mut view| Ok::<_, wasmtime::Error>(view.get().table.get(&thing)?.wakers.clone()))
+            .await?;
 
         future::poll_fn(move |cx| {
             let mut wakers = wakers.lock().unwrap();
diff --git a/crates/misc/component-async-tests/tests/scenario/backpressure.rs b/crates/misc/component-async-tests/tests/scenario/backpressure.rs
index 782706011b31..6912750e201b 100644
--- a/crates/misc/component-async-tests/tests/scenario/backpressure.rs
+++ b/crates/misc/component-async-tests/tests/scenario/backpressure.rs
@@ -1,4 +1,5 @@
 use component_async_tests::Ctx;
+use futures::FutureExt as _;
 use std::{
     env, future,
     pin::Pin,
@@ -75,7 +76,15 @@ pub async fn async_backpressure_callee() -> Result<()> {
 
             let mut backpressure_is_set = true;
             future::poll_fn(move |cx| {
-                let instance_ready = accessor.poll_ready_for_concurrent_call(func, cx).is_ready();
+                // `poll_ready_for_concurrent_call` is `async` but resolves
+                // synchronously (its body just drives `Accessor::with`), so
+                // extract the `Poll` with `now_or_never`; the real `cx` still
+                // registers the waker on `Pending`.
+                let instance_ready = accessor
+                    .poll_ready_for_concurrent_call(func, cx)
+                    .now_or_never()
+                    .expect("`Accessor::with` resolves synchronously")
+                    .is_ready();
                 let a_ready = is_ready(cx, &mut a);
                 let b_ready = is_ready(cx, &mut b);
                 let c_ready = is_ready(cx, &mut c);
diff --git a/crates/misc/component-async-tests/tests/scenario/round_trip.rs b/crates/misc/component-async-tests/tests/scenario/round_trip.rs
index bb2c9fee8c84..9ba684d866d2 100644
--- a/crates/misc/component-async-tests/tests/scenario/round_trip.rs
+++ b/crates/misc/component-async-tests/tests/scenario/round_trip.rs
@@ -271,9 +271,14 @@ async fn test_round_trip_recurse(component: &str, same_instance: bool) -> Result
         for MyCtx
     {
         async fn foo(accessor: &Accessor<T, Self>, s: String) -> wasmtime::Result<String> {
-            if let Some(instance) = accessor.with(|mut access| access.get().instance.take()) {
+            if let Some(instance) = accessor
+                .with(|mut access| access.get().instance.take())
+                .await
+            {
                 run(accessor, &instance).await?;
-                accessor.with(|mut access| access.get().instance = Some(instance));
+                accessor
+                    .with(|mut access| access.get().instance = Some(instance))
+                    .await;
             }
             Ok(format!("{s} - entered host - exited host"))
         }
@@ -282,9 +287,11 @@ async fn test_round_trip_recurse(component: &str, same_instance: bool) -> Result
     impl component_async_tests::round_trip::bindings::local::local::baz::Host for MyCtx {}
 
     async fn run<T: Send>(accessor: &Accessor<T, MyCtx>, instance: &Instance) -> Result<()> {
-        let round_trip = accessor.with(|mut access| {
-            component_async_tests::round_trip::bindings::RoundTrip::new(&mut access, &instance)
-        })?;
+        let round_trip = accessor
+            .with(|mut access| {
+                component_async_tests::round_trip::bindings::RoundTrip::new(&mut access, &instance)
+            })
+            .await?;
 
         let input = "hello, world!";
         let expected = "hello, world! - entered guest - entered host - exited host - exited guest";
@@ -424,12 +431,14 @@ pub async fn test_round_trip(
 
             impl AccessorTask<Ctx, HasSelf<Ctx>> for Task {
                 async fn run(self, accessor: &Accessor<Ctx>) -> Result<()> {
-                    let round_trip = accessor.with(|mut store| {
-                        component_async_tests::round_trip::bindings::RoundTrip::new(
-                            &mut store,
-                            &self.instance,
-                        )
-                    })?;
+                    let round_trip = accessor
+                        .with(|mut store| {
+                            component_async_tests::round_trip::bindings::RoundTrip::new(
+                                &mut store,
+                                &self.instance,
+                            )
+                        })
+                        .await?;
 
                     let mut futures = FuturesUnordered::new();
                     for (input, output) in &self.inputs_and_outputs {
diff --git a/crates/misc/component-async-tests/tests/scenario/streams.rs b/crates/misc/component-async-tests/tests/scenario/streams.rs
index f54c95ea15eb..f29247acabbf 100644
--- a/crates/misc/component-async-tests/tests/scenario/streams.rs
+++ b/crates/misc/component-async-tests/tests/scenario/streams.rs
@@ -295,7 +295,9 @@ pub async fn async_closed_stream() -> Result<()> {
             let stream = guest.local_local_closed_stream().call_get(accessor).await?;
 
             let (tx, mut rx) = mpsc::channel(1);
-            accessor.with(move |store| stream.pipe(store, PipeConsumer::new(tx)))?;
+            accessor
+                .with(move |store| stream.pipe(store, PipeConsumer::new(tx)))
+                .await?;
             assert!(rx.next().await.is_none());
 
             Ok(())
@@ -498,8 +500,9 @@ async fn test_async_short_reads(delay: bool) -> Result<()> {
     store
         .run_concurrent(async |store| {
             let count = things.len();
-            let stream =
-                store.with(|store| StreamReader::new(store, VecProducer::new(things, delay)))?;
+            let stream = store
+                .with(|store| StreamReader::new(store, VecProducer::new(things, delay)))
+                .await?;
 
             let stream = guest
                 .local_local_short_reads()
@@ -509,9 +512,9 @@ async fn test_async_short_reads(delay: bool) -> Result<()> {
             let received_things = Arc::new(Mutex::new(Vec::<Thing>::with_capacity(count)));
             // Read just one item at a time from the guest, forcing it to
             // re-take ownership of any unwritten items.
-            store.with(|store| {
-                stream.pipe(store, OneAtATime::new(received_things.clone(), delay))
-            })?;
+            store
+                .with(|store| stream.pipe(store, OneAtATime::new(received_things.clone(), delay)))
+                .await?;
 
             for i in 0.. {
                 assert!(i < 1000);
diff --git a/crates/misc/component-async-tests/tests/scenario/transmit.rs b/crates/misc/component-async-tests/tests/scenario/transmit.rs
index d48b9d2d668f..ef93db2ef1d6 100644
--- a/crates/misc/component-async-tests/tests/scenario/transmit.rs
+++ b/crates/misc/component-async-tests/tests/scenario/transmit.rs
@@ -370,15 +370,17 @@ pub async fn async_readiness() -> Result<()> {
                 .call_start(accessor, rx, expected)
                 .await?;
 
-            accessor.with(|access| {
-                rx.pipe(
-                    access,
-                    DelayedStreamConsumer {
-                        inner: BufferStreamConsumer { expected },
-                        maybe_yield: yield_times(10).boxed(),
-                    },
-                )
-            })?;
+            accessor
+                .with(|access| {
+                    rx.pipe(
+                        access,
+                        DelayedStreamConsumer {
+                            inner: BufferStreamConsumer { expected },
+                            maybe_yield: yield_times(10).boxed(),
+                        },
+                    )
+                })
+                .await?;
 
             Ok(())
         })
@@ -630,17 +632,19 @@ impl TransmitTest for DynamicTransmitTest {
         instance: &'a Self::Instance,
         params: Self::Params,
     ) -> Result<Self::Result> {
-        let exchange_function = accessor.with(|mut store| {
-            let transmit_instance = instance
-                .get_export_index(store.as_context_mut(), None, "local:local/transmit")
-                .ok_or_else(|| format_err!("can't find `local:local/transmit` in instance"))?;
-            let exchange_function = instance
-                .get_export_index(store.as_context_mut(), Some(&transmit_instance), "exchange")
-                .ok_or_else(|| format_err!("can't find `exchange` in instance"))?;
-            instance
-                .get_func(store.as_context_mut(), exchange_function)
-                .ok_or_else(|| format_err!("can't find `exchange` in instance"))
-        })?;
+        let exchange_function = accessor
+            .with(|mut store| {
+                let transmit_instance = instance
+                    .get_export_index(store.as_context_mut(), None, "local:local/transmit")
+                    .ok_or_else(|| format_err!("can't find `local:local/transmit` in instance"))?;
+                let exchange_function = instance
+                    .get_export_index(store.as_context_mut(), Some(&transmit_instance), "exchange")
+                    .ok_or_else(|| format_err!("can't find `exchange` in instance"))?;
+                instance
+                    .get_func(store.as_context_mut(), exchange_function)
+                    .ok_or_else(|| format_err!("can't find `exchange` in instance"))
+            })
+            .await?;
 
         let mut results = vec![Val::Bool(false)];
         exchange_function
@@ -776,15 +780,17 @@ async fn test_transmit_with<Test: TransmitTest + 'static>(component: &str) -> Re
                 .boxed(),
             );
 
-            let params = accessor.with(|s| {
-                Test::into_params(
-                    s,
-                    control_rx,
-                    caller_stream_rx,
-                    caller_future1_rx,
-                    caller_future2_rx,
-                )
-            });
+            let params = accessor
+                .with(|s| {
+                    Test::into_params(
+                        s,
+                        control_rx,
+                        caller_stream_rx,
+                        caller_future1_rx,
+                        caller_future2_rx,
+                    )
+                })
+                .await;
 
             futures.push(
                 Test::call(accessor, &test, params)
@@ -795,19 +801,21 @@ async fn test_transmit_with<Test: TransmitTest + 'static>(component: &str) -> Re
             while let Some(event) = futures.try_next().await? {
                 match event {
                     Event::Result(result) => {
-                        accessor.with(|mut store| {
-                            let (callee_stream_rx, callee_future1_rx, _) =
-                                Test::from_result(&mut store, result)?;
-                            callee_stream_rx.pipe(
-                                &mut store,
-                                PipeConsumer::new(callee_stream_tx.take().unwrap()),
-                            )?;
-                            callee_future1_rx.pipe(
-                                &mut store,
-                                OneshotConsumer::new(callee_future1_tx.take().unwrap()),
-                            )?;
-                            wasmtime::error::Ok(())
-                        })?;
+                        accessor
+                            .with(|mut store| {
+                                let (callee_stream_rx, callee_future1_rx, _) =
+                                    Test::from_result(&mut store, result)?;
+                                callee_stream_rx.pipe(
+                                    &mut store,
+                                    PipeConsumer::new(callee_stream_tx.take().unwrap()),
+                                )?;
+                                callee_future1_rx.pipe(
+                                    &mut store,
+                                    OneshotConsumer::new(callee_future1_tx.take().unwrap()),
+                                )?;
+                                wasmtime::error::Ok(())
+                            })
+                            .await?;
                     }
                     Event::ControlWriteA(mut control_tx) => {
                         futures.push(
@@ -958,31 +966,33 @@ async fn test_synchronous_transmit(component: &str, procrastinate: bool) -> Resu
                 .call_start(accessor, stream, stream_expected, future, future_expected)
                 .await?;
 
-            accessor.with(|mut access| -> wasmtime::Result<_> {
-                let consumer = DelayedStreamConsumer {
-                    inner: BufferStreamConsumer {
-                        expected: stream_expected,
-                    },
-                    maybe_yield: yield_times(10).boxed(),
-                };
-                if procrastinate {
-                    stream.pipe(&mut access, ProcrastinatingStreamConsumer(consumer))?;
-                } else {
-                    stream.pipe(&mut access, consumer)?;
-                }
-                let consumer = DelayedFutureConsumer {
-                    inner: ValueFutureConsumer {
-                        expected: future_expected,
-                    },
-                    maybe_yield: yield_times(10).boxed(),
-                };
-                if procrastinate {
-                    future.pipe(access, ProcrastinatingFutureConsumer(consumer))?;
-                } else {
-                    future.pipe(access, consumer)?;
-                }
-                Ok(())
-            })?;
+            accessor
+                .with(|mut access| -> wasmtime::Result<_> {
+                    let consumer = DelayedStreamConsumer {
+                        inner: BufferStreamConsumer {
+                            expected: stream_expected,
+                        },
+                        maybe_yield: yield_times(10).boxed(),
+                    };
+                    if procrastinate {
+                        stream.pipe(&mut access, ProcrastinatingStreamConsumer(consumer))?;
+                    } else {
+                        stream.pipe(&mut access, consumer)?;
+                    }
+                    let consumer = DelayedFutureConsumer {
+                        inner: ValueFutureConsumer {
+                            expected: future_expected,
+                        },
+                        maybe_yield: yield_times(10).boxed(),
+                    };
+                    if procrastinate {
+                        future.pipe(access, ProcrastinatingFutureConsumer(consumer))?;
+                    } else {
+                        future.pipe(access, consumer)?;
+                    }
+                    Ok(())
+                })
+                .await?;
 
             Ok(())
         })
diff --git a/crates/wasi-http/src/handler.rs b/crates/wasi-http/src/handler.rs
index 35de271162a0..48d32710d3f2 100644
--- a/crates/wasi-http/src/handler.rs
+++ b/crates/wasi-http/src/handler.rs
@@ -522,7 +522,7 @@ where
                 *status.try_lock().unwrap() = (WorkerStatus::Requests, start_time);
 
                 futures.push(async move {
-                    let (prepared, expiration) = prepared?;
+                    let (prepared, expiration) = prepared.await?;
                     let sent = prepared.run(accessor, expiration).await?;
                     wasmtime::error::Ok((sent, start_time))
                 });
@@ -597,7 +597,16 @@ where
                         Poll::Ready(None) | Poll::Pending => {}
                     }
 
-                    let is_ready = accessor.poll_ready_for_concurrent_call(func, cx).is_ready();
+                    // `poll_ready_for_concurrent_call` is an `async` method, but
+                    // its body just drives `Accessor::with`, whose future is
+                    // always immediately ready, so `now_or_never` extracts the
+                    // `Poll` synchronously. The real `cx` is threaded into the
+                    // closure, so the waker is still registered on `Pending`.
+                    let is_ready = accessor
+                        .poll_ready_for_concurrent_call(func, cx)
+                        .now_or_never()
+                        .expect("`Accessor::with` resolves synchronously")
+                        .is_ready();
 
                     // At this point `futures` is either empty or it's `Pending`
                     // meaning nothing is ready. Note that `Pending` here
@@ -656,7 +665,15 @@ where
                     // then we're done with this iteration of `poll`. We'll get
                     // woken up when anything changes, but otherwise it's time
                     // to let something else happen.
-                    if accessor.poll_no_interesting_tasks(cx).is_pending() {
+                    // As with `poll_ready_for_concurrent_call` above, this
+                    // `async` method resolves synchronously, so drive it with
+                    // `now_or_never`; the real `cx` still registers the waker.
+                    if accessor
+                        .poll_no_interesting_tasks(cx)
+                        .now_or_never()
+                        .expect("`Accessor::with` resolves synchronously")
+                        .is_pending()
+                    {
                         break Poll::Pending;
                     }
 
@@ -1078,10 +1095,12 @@ impl<'a, T: Send> Prepared<'a, T> {
                         .await?
                         .0?;
 
-                    accessor.with(|mut store| {
-                        let response = view(store.get()).table.delete(response)?;
-                        response.into_http_with_getter(&mut store, request_io_result, view)
-                    })
+                    accessor
+                        .with(|mut store| {
+                            let response = view(store.get()).table.delete(response)?;
+                            response.into_http_with_getter(&mut store, request_io_result, view)
+                        })
+                        .await
                 });
 
                 // TODO: We should also use `oneshot::Sender::poll_close` to be
diff --git a/crates/wasi-http/src/p3/host/handler.rs b/crates/wasi-http/src/p3/host/handler.rs
index f8d0ab40a638..9874712112be 100644
--- a/crates/wasi-http/src/p3/host/handler.rs
+++ b/crates/wasi-http/src/p3/host/handler.rs
@@ -52,29 +52,37 @@ impl<T> HostWithStore<T> for WasiHttp {
         let (res_result_tx, res_result_rx) = oneshot::channel();
 
         let getter = store.getter();
-        let fut = store.with(|mut store| {
-            let WasiHttpCtxView { table, .. } = store.get();
-            let req = table
-                .delete(req)
-                .context("failed to delete request from table")
-                .map_err(HttpError::trap)?;
-            let (req, options) =
-                req.into_http_with_getter(&mut store, io_task_result(io_result_rx), getter)?;
-            HttpResult::Ok(store.get().hooks.send_request(
-                req.map(|body| body.with_state(io_task_rx).boxed_unsync()),
-                options.as_deref().copied(),
-                Box::new(async {
-                    // Forward the response processing result to `WasiHttpCtx` implementation
-                    let Ok(fut) = res_result_rx.await else {
-                        return Ok(());
-                    };
-                    Box::into_pin(fut).await
-                }),
-            ))
-        })?;
-        let (res, io) = Box::into_pin(fut)
-            .await
-            .map_err(|e| store.with(|mut store| store.get().error_to_p3(&e)))?;
+        let fut = store
+            .with(|mut store| {
+                let WasiHttpCtxView { table, .. } = store.get();
+                let req = table
+                    .delete(req)
+                    .context("failed to delete request from table")
+                    .map_err(HttpError::trap)?;
+                let (req, options) =
+                    req.into_http_with_getter(&mut store, io_task_result(io_result_rx), getter)?;
+                HttpResult::Ok(store.get().hooks.send_request(
+                    req.map(|body| body.with_state(io_task_rx).boxed_unsync()),
+                    options.as_deref().copied(),
+                    Box::new(async {
+                        // Forward the response processing result to `WasiHttpCtx` implementation
+                        let Ok(fut) = res_result_rx.await else {
+                            return Ok(());
+                        };
+                        Box::into_pin(fut).await
+                    }),
+                ))
+            })
+            .await?;
+        let (res, io) = match Box::into_pin(fut).await {
+            Ok(res) => res,
+            Err(e) => {
+                return Err(store
+                    .with(|mut store| store.get().error_to_p3(&e))
+                    .await
+                    .into());
+            }
+        };
         let (
             http::response::Parts {
                 status, headers, ..
@@ -83,10 +91,14 @@ impl<T> HostWithStore<T> for WasiHttp {
         ) = res.into_parts();
 
         let mut io = Box::into_pin(io);
-        let body = match io.as_mut().poll(&mut Context::from_waker(Waker::noop())) {
+        let io_poll = io.as_mut().poll(&mut Context::from_waker(Waker::noop()));
+        let body = match io_poll {
             Poll::Ready(Ok(())) => body,
             Poll::Ready(Err(e)) => {
-                return Err(store.with(|mut store| store.get().error_to_p3(&e)).into());
+                return Err(store
+                    .with(|mut store| store.get().error_to_p3(&e))
+                    .await
+                    .into());
             }
             Poll::Pending => {
                 // I/O driver still needs to be polled, spawn a task and send handles to it
@@ -102,22 +114,24 @@ impl<T> HostWithStore<T> for WasiHttp {
                 body.with_state(io).boxed_unsync()
             }
         };
-        store.with(|mut store| {
-            let res = Response {
-                status,
-                headers: FieldMap::new_immutable(store.get().hooks, headers),
-                body: Body::Host {
-                    body,
-                    result_tx: res_result_tx,
-                },
-            };
-            store
-                .get()
-                .table
-                .push(res)
-                .context("failed to push response to table")
-                .map_err(HttpError::trap)
-        })
+        store
+            .with(|mut store| {
+                let res = Response {
+                    status,
+                    headers: FieldMap::new_immutable(store.get().hooks, headers),
+                    body: Body::Host {
+                        body,
+                        result_tx: res_result_tx,
+                    },
+                };
+                store
+                    .get()
+                    .table
+                    .push(res)
+                    .context("failed to push response to table")
+                    .map_err(HttpError::trap)
+            })
+            .await
     }
 }
 
diff --git a/crates/wasi-http/src/p3/proxy.rs b/crates/wasi-http/src/p3/proxy.rs
index 58aa09520841..7d296df1f879 100644
--- a/crates/wasi-http/src/p3/proxy.rs
+++ b/crates/wasi-http/src/p3/proxy.rs
@@ -18,7 +18,8 @@ impl Service {
                 .table
                 .push(req.into())
                 .context("failed to push request to table")
-        })?;
+        })
+        .await?;
         match self.wasi_http_handler().call_handle(store, req).await? {
             Ok(res) => {
                 let res = store.with(|mut store| {
@@ -28,7 +29,8 @@ impl Service {
                         .table
                         .delete(res)
                         .context("failed to delete response from table")
-                })?;
+                })
+                .await?;
                 Ok(Ok(res))
             }
             Err(err) => Ok(Err(err)),
diff --git a/crates/wasi-tls/src/p3/host.rs b/crates/wasi-tls/src/p3/host.rs
index 66c084f415e2..73d79c4a3cf0 100644
--- a/crates/wasi-tls/src/p3/host.rs
+++ b/crates/wasi-tls/src/p3/host.rs
@@ -184,31 +184,33 @@ impl<T> bindings::tls::client::HostConnectorWithStore<T> for WasiTls {
         fn connect_err(msg: &'static str) -> BoxFutureTlsStream {
             Box::pin(async move { Err(Error::msg(msg)) })
         }
-        let (fut, connection) = accessor.with(
-            move |mut access| -> wasmtime::Result<(BoxFutureTlsStream, _)> {
-                let WasiTlsCtxView { table, ctx } = access.get();
-                let connector = table.delete(this)?;
-                let connection = connector.connection;
-
-                let Some(ciphertext_writer) = connector.send else {
-                    return Ok((
-                        connect_err("send() must be called before connect()"),
-                        connection,
-                    ));
-                };
-                let Some(ciphertext_reader) = connector.recv else {
-                    return Ok((
-                        connect_err("receive() must be called before connect()"),
-                        connection,
-                    ));
-                };
-
-                let transport = Box::new(tokio::io::join(ciphertext_reader, ciphertext_writer));
-                let fut = ctx.provider.connect(server_name, transport);
-
-                Ok((fut, connection))
-            },
-        )?;
+        let (fut, connection) = accessor
+            .with(
+                move |mut access| -> wasmtime::Result<(BoxFutureTlsStream, _)> {
+                    let WasiTlsCtxView { table, ctx } = access.get();
+                    let connector = table.delete(this)?;
+                    let connection = connector.connection;
+
+                    let Some(ciphertext_writer) = connector.send else {
+                        return Ok((
+                            connect_err("send() must be called before connect()"),
+                            connection,
+                        ));
+                    };
+                    let Some(ciphertext_reader) = connector.recv else {
+                        return Ok((
+                            connect_err("receive() must be called before connect()"),
+                            connection,
+                        ));
+                    };
+
+                    let transport = Box::new(tokio::io::join(ciphertext_reader, ciphertext_writer));
+                    let fut = ctx.provider.connect(server_name, transport);
+
+                    Ok((fut, connection))
+                },
+            )
+            .await?;
 
         match fut.await {
             Ok(tls_stream) => {
@@ -217,7 +219,9 @@ impl<T> bindings::tls::client::HostConnectorWithStore<T> for WasiTls {
             }
             Err(e) => {
                 connection.lock().resolve(Box::new(Closed(e.clone())));
-                let resource = accessor.with(|mut access| access.get().table.push(e))?;
+                let resource = accessor
+                    .with(|mut access| access.get().table.push(e))
+                    .await?;
                 Ok(Err(resource))
             }
         }
diff --git a/crates/wasi/src/p3/clocks/host.rs b/crates/wasi/src/p3/clocks/host.rs
index a93438e5876e..2cae85dd713a 100644
--- a/crates/wasi/src/p3/clocks/host.rs
+++ b/crates/wasi/src/p3/clocks/host.rs
@@ -27,7 +27,9 @@ impl<U> monotonic_clock::HostWithStore<U> for WasiClocks {
         store: &Accessor<U, Self>,
         when: monotonic_clock::Mark,
     ) -> wasmtime::Result<()> {
-        let clock_now = store.with(|mut view| view.get().ctx.monotonic_clock.now());
+        let clock_now = store
+            .with(|mut view| view.get().ctx.monotonic_clock.now())
+            .await;
         if when > clock_now {
             sleep(Duration::from_nanos(when - clock_now)).await;
         };
diff --git a/crates/wasi/src/p3/filesystem/host.rs b/crates/wasi/src/p3/filesystem/host.rs
index d36589f9c3b4..2dc35e420355 100644
--- a/crates/wasi/src/p3/filesystem/host.rs
+++ b/crates/wasi/src/p3/filesystem/host.rs
@@ -51,10 +51,10 @@ fn get_dir<'a>(
 }
 
 trait AccessorExt {
-    fn get_descriptor(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Descriptor>;
-    fn get_file(&self, fd: &Resource<Descriptor>) -> FilesystemResult<File>;
-    fn get_dir(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Dir>;
-    fn get_dir_pair(
+    async fn get_descriptor(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Descriptor>;
+    async fn get_file(&self, fd: &Resource<Descriptor>) -> FilesystemResult<File>;
+    async fn get_dir(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Dir>;
+    async fn get_dir_pair(
         &self,
         a: &Resource<Descriptor>,
         b: &Resource<Descriptor>,
@@ -62,28 +62,31 @@ trait AccessorExt {
 }
 
 impl<T> AccessorExt for Accessor<T, WasiFilesystem> {
-    fn get_descriptor(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Descriptor> {
+    async fn get_descriptor(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Descriptor> {
         self.with(|mut store| {
             let fd = get_descriptor(store.get().table, fd)?;
             Ok(fd.clone())
         })
+        .await
     }
 
-    fn get_file(&self, fd: &Resource<Descriptor>) -> FilesystemResult<File> {
+    async fn get_file(&self, fd: &Resource<Descriptor>) -> FilesystemResult<File> {
         self.with(|mut store| {
             let file = get_file(store.get().table, fd)?;
             Ok(file.clone())
         })
+        .await
     }
 
-    fn get_dir(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Dir> {
+    async fn get_dir(&self, fd: &Resource<Descriptor>) -> FilesystemResult<Dir> {
         self.with(|mut store| {
             let dir = get_dir(store.get().table, fd)?;
             Ok(dir.clone())
         })
+        .await
     }
 
-    fn get_dir_pair(
+    async fn get_dir_pair(
         &self,
         a: &Resource<Descriptor>,
         b: &Resource<Descriptor>,
@@ -94,6 +97,7 @@ impl<T> AccessorExt for Accessor<T, WasiFilesystem> {
             let b = get_dir(table, b)?;
             Ok((a.clone(), b.clone()))
         })
+        .await
     }
 }
 
@@ -607,7 +611,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         length: Filesize,
         advice: Advice,
     ) -> FilesystemResult<()> {
-        let file = store.get_file(&fd)?;
+        let file = store.get_file(&fd).await?;
         file.advise(offset, length, advice.into()).await?;
         Ok(())
     }
@@ -616,7 +620,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         store: &Accessor<U, Self>,
         fd: Resource<Descriptor>,
     ) -> FilesystemResult<()> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         fd.sync_data().await?;
         Ok(())
     }
@@ -625,7 +629,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         store: &Accessor<U, Self>,
         fd: Resource<Descriptor>,
     ) -> FilesystemResult<DescriptorFlags> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         let flags = fd.get_flags().await?;
         Ok(flags.into())
     }
@@ -634,7 +638,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         store: &Accessor<U, Self>,
         fd: Resource<Descriptor>,
     ) -> FilesystemResult<DescriptorType> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         let ty = fd.get_type().await?;
         Ok(ty.into())
     }
@@ -644,7 +648,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         size: Filesize,
     ) -> FilesystemResult<()> {
-        let file = store.get_file(&fd)?;
+        let file = store.get_file(&fd).await?;
         file.set_size(size).await?;
         Ok(())
     }
@@ -655,7 +659,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         data_access_timestamp: NewTimestamp,
         data_modification_timestamp: NewTimestamp,
     ) -> FilesystemResult<()> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         let atim = systemtimespec_from(data_access_timestamp)?;
         let mtim = systemtimespec_from(data_modification_timestamp)?;
         fd.set_times(atim, mtim).await?;
@@ -707,7 +711,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
     }
 
     async fn sync(store: &Accessor<U, Self>, fd: Resource<Descriptor>) -> FilesystemResult<()> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         fd.sync().await?;
         Ok(())
     }
@@ -717,7 +721,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         path: String,
     ) -> FilesystemResult<()> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         dir.create_directory_at(path).await?;
         Ok(())
     }
@@ -726,7 +730,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         store: &Accessor<U, Self>,
         fd: Resource<Descriptor>,
     ) -> FilesystemResult<DescriptorStat> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         let stat = fd.stat().await?;
         Ok(stat.into())
     }
@@ -737,7 +741,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         path_flags: PathFlags,
         path: String,
     ) -> FilesystemResult<DescriptorStat> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         let stat = dir.stat_at(path_flags.into(), path).await?;
         Ok(stat.into())
     }
@@ -750,7 +754,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         data_access_timestamp: NewTimestamp,
         data_modification_timestamp: NewTimestamp,
     ) -> FilesystemResult<()> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         let atim = systemtimespec_from(data_access_timestamp)?;
         let mtim = systemtimespec_from(data_modification_timestamp)?;
         dir.set_times_at(path_flags.into(), path, atim, mtim)
@@ -766,7 +770,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         new_fd: Resource<Descriptor>,
         new_path: String,
     ) -> FilesystemResult<()> {
-        let (old_dir, new_dir) = store.get_dir_pair(&fd, &new_fd)?;
+        let (old_dir, new_dir) = store.get_dir_pair(&fd, &new_fd).await?;
         old_dir
             .link_at(old_path_flags.into(), old_path, &new_dir, new_path)
             .await?;
@@ -781,11 +785,13 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         open_flags: OpenFlags,
         flags: DescriptorFlags,
     ) -> FilesystemResult<Resource<Descriptor>> {
-        let (allow_blocking_current_thread, dir) = store.with(|mut store| {
-            let store = store.get();
-            let dir = get_dir(&store.table, &fd)?;
-            FilesystemResult::Ok((store.ctx.allow_blocking_current_thread, dir.clone()))
-        })?;
+        let (allow_blocking_current_thread, dir) = store
+            .with(|mut store| {
+                let store = store.get();
+                let dir = get_dir(&store.table, &fd)?;
+                FilesystemResult::Ok((store.ctx.allow_blocking_current_thread, dir.clone()))
+            })
+            .await?;
         let fd = dir
             .open_at(
                 path_flags.into(),
@@ -795,7 +801,9 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
                 allow_blocking_current_thread,
             )
             .await?;
-        let fd = store.with(|mut store| store.get().table.push(fd))?;
+        let fd = store
+            .with(|mut store| store.get().table.push(fd))
+            .await?;
         Ok(fd)
     }
 
@@ -804,7 +812,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         path: String,
     ) -> FilesystemResult<String> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         let path = dir.readlink_at(path).await?;
         Ok(path)
     }
@@ -814,7 +822,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         path: String,
     ) -> FilesystemResult<()> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         dir.remove_directory_at(path).await?;
         Ok(())
     }
@@ -826,7 +834,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         new_fd: Resource<Descriptor>,
         new_path: String,
     ) -> FilesystemResult<()> {
-        let (old_dir, new_dir) = store.get_dir_pair(&fd, &new_fd)?;
+        let (old_dir, new_dir) = store.get_dir_pair(&fd, &new_fd).await?;
         old_dir.rename_at(old_path, &new_dir, new_path).await?;
         Ok(())
     }
@@ -837,7 +845,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         old_path: String,
         new_path: String,
     ) -> FilesystemResult<()> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         dir.symlink_at(old_path, new_path).await?;
         Ok(())
     }
@@ -847,7 +855,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         path: String,
     ) -> FilesystemResult<()> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         dir.unlink_file_at(path).await?;
         Ok(())
     }
@@ -857,12 +865,14 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         fd: Resource<Descriptor>,
         other: Resource<Descriptor>,
     ) -> wasmtime::Result<bool> {
-        let (fd, other) = store.with(|mut store| {
-            let table = store.get().table;
-            let fd = get_descriptor(table, &fd)?.clone();
-            let other = get_descriptor(table, &other)?.clone();
-            wasmtime::error::Ok((fd, other))
-        })?;
+        let (fd, other) = store
+            .with(|mut store| {
+                let table = store.get().table;
+                let fd = get_descriptor(table, &fd)?.clone();
+                let other = get_descriptor(table, &other)?.clone();
+                wasmtime::error::Ok((fd, other))
+            })
+            .await?;
         fd.is_same_object(&other).await
     }
 
@@ -870,7 +880,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         store: &Accessor<U, Self>,
         fd: Resource<Descriptor>,
     ) -> FilesystemResult<MetadataHashValue> {
-        let fd = store.get_descriptor(&fd)?;
+        let fd = store.get_descriptor(&fd).await?;
         let meta = fd.metadata_hash().await?;
         Ok(meta.into())
     }
@@ -881,7 +891,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {
         path_flags: PathFlags,
         path: String,
     ) -> FilesystemResult<MetadataHashValue> {
-        let dir = store.get_dir(&fd)?;
+        let dir = store.get_dir(&fd).await?;
         let meta = dir.metadata_hash_at(path_flags.into(), path).await?;
         Ok(meta.into())
     }
diff --git a/crates/wasi/src/p3/sockets/host/ip_name_lookup.rs b/crates/wasi/src/p3/sockets/host/ip_name_lookup.rs
index 084e9af317be..634f8b3b4938 100644
--- a/crates/wasi/src/p3/sockets/host/ip_name_lookup.rs
+++ b/crates/wasi/src/p3/sockets/host/ip_name_lookup.rs
@@ -10,7 +10,9 @@ impl<U> HostWithStore<U> for WasiSockets {
         store: &Accessor<U, Self>,
         name: String,
     ) -> wasmtime::Result<Result<Vec<types::IpAddress>, ErrorCode>> {
-        let fut = store.with(|mut view| resolve_addresses(&view.get().ctx, name));
+        let fut = store
+            .with(|mut view| resolve_addresses(&view.get().ctx, name))
+            .await;
         Ok(match fut.await {
             Ok(addrs) => Ok(addrs.into_iter().map(|addr| addr.into()).collect()),
             Err(err) => Err(err.into()),
diff --git a/crates/wasi/src/p3/sockets/host/types/tcp.rs b/crates/wasi/src/p3/sockets/host/types/tcp.rs
index 02e3051173eb..9b87929ca195 100644
--- a/crates/wasi/src/p3/sockets/host/types/tcp.rs
+++ b/crates/wasi/src/p3/sockets/host/types/tcp.rs
@@ -9,6 +9,7 @@ use bytes::BytesMut;
 use core::iter;
 use core::pin::Pin;
 use core::task::{Context, Poll};
+use futures::FutureExt as _;
 use std::net::SocketAddr;
 use tokio::sync::oneshot;
 use wasmtime::component::{
@@ -207,17 +208,29 @@ impl<T: Send> HostTcpSocketWithStore<T> for WasiSockets {
     ) -> SocketResult<()> {
         let remote_address = SocketAddr::from(remote_address);
 
-        store.with(|mut store| {
-            let socket = get_socket_mut(store.get().table, &socket)?;
-            let socket = socket.start_connect(remote_address)?;
-            SocketResult::Ok(socket)
-        })?;
-
-        std::future::poll_fn(|cx| {
-            store.with(|mut store| -> Poll<SocketResult<()>> {
+        store
+            .with(|mut store| {
                 let socket = get_socket_mut(store.get().table, &socket)?;
-                socket.poll_finish_connect(cx).map_err(SocketError::from)
+                let socket = socket.start_connect(remote_address)?;
+                SocketResult::Ok(socket)
             })
+            .await?;
+
+        std::future::poll_fn(|cx| {
+            // `Accessor::with` is an `async` method, but its body is fully
+            // synchronous, so the future it returns is always immediately
+            // ready. Drive it to completion with `now_or_never` to obtain
+            // synchronous access to the store from within this poll context.
+            // The real `cx` is threaded through to `poll_finish_connect`, so
+            // when the connection is still pending the real waker is registered
+            // and `Poll::Pending` propagates out of this `poll_fn` as usual.
+            store
+                .with(|mut store| -> Poll<SocketResult<()>> {
+                    let socket = get_socket_mut(store.get().table, &socket)?;
+                    socket.poll_finish_connect(cx).map_err(SocketError::from)
+                })
+                .now_or_never()
+                .expect("`Accessor::with` resolves synchronously")
         })
         .await
     }
diff --git a/crates/wasi/src/p3/sockets/host/types/udp.rs b/crates/wasi/src/p3/sockets/host/types/udp.rs
index 2a6981785574..9fbfdcc45f57 100644
--- a/crates/wasi/src/p3/sockets/host/types/udp.rs
+++ b/crates/wasi/src/p3/sockets/host/types/udp.rs
@@ -39,7 +39,8 @@ impl<T> HostUdpSocketWithStore<T> for WasiSockets {
             .with(|mut view| -> SocketResult<_> {
                 let socket = get_socket_mut(view.get().table, &socket)?;
                 Ok(socket.send(data, remote_address.map(SocketAddr::from)))
-            })?
+            })
+            .await?
             .await?;
         Ok(())
     }
@@ -52,7 +53,8 @@ impl<T> HostUdpSocketWithStore<T> for WasiSockets {
             .with(|mut view| -> SocketResult<_> {
                 let socket = get_socket_mut(view.get().table, &socket)?;
                 Ok(socket.recv())
-            })?
+            })
+            .await?
             .await?;
         Ok((data, addr.into()))
     }
diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rs
index 079ce49e6e20..1102917f3be5 100644
--- a/crates/wasmtime/src/runtime/component/concurrent.rs
+++ b/crates/wasmtime/src/runtime/component/concurrent.rs
@@ -461,7 +461,7 @@ where
     /// accessor already in scope. For example if `with` is called within `fun`,
     /// then this function will panic. It is up to the embedder to ensure that
     /// this does not happen.
-    pub fn with<R>(&self, fun: impl FnOnce(Access<'_, T, D>) -> R) -> R {
+    pub async fn with<R>(&self, fun: impl FnOnce(Access<'_, T, D>) -> R) -> R {
         tls::get(|vmstore| {
             fun(Access {
                 store: self.token.as_context_mut(vmstore),
@@ -517,12 +517,13 @@ where
     /// Panics if called within a closure provided to the [`Accessor::with`]
     /// function. This can only be called outside an active invocation of
     /// [`Accessor::with`].
-    pub fn spawn(&self, task: impl AccessorTask<T, D>) -> Result<JoinHandle>
+    pub async fn spawn(&self, task: impl AccessorTask<T, D>) -> Result<JoinHandle>
     where
         T: 'static,
     {
         let accessor = self.clone_for_spawn();
         self.with(|mut access| access.as_context_mut().spawn_with_accessor(accessor, task))
+            .await
     }
 
     fn clone_for_spawn(&self) -> Self {
@@ -567,7 +568,7 @@ where
     /// Note that at this time spawned threads within a task are always
     /// considered uninteresting. If this function returns ready, then spawned
     /// threads may still be in the store.
-    pub fn poll_no_interesting_tasks(&self, cx: &mut Context<'_>) -> Poll<()> {
+    pub async fn poll_no_interesting_tasks(&self, cx: &mut Context<'_>) -> Poll<()> {
         self.with(|mut access| {
             let store = access.as_context_mut().0;
             let state = store.concurrent_state_mut_without_forcing_current_thread();
@@ -578,6 +579,7 @@ where
                 Poll::Pending
             }
         })
+        .await
     }
 
     /// Poll to see if the component instance corresponding to the specified
@@ -596,7 +598,11 @@ where
     /// may be notified when _any_ instance becomes callable (i.e. not
     /// necessarily the last one polled), so this function must be called again
     /// to determine if the instance of interest is ready.
-    pub fn poll_ready_for_concurrent_call(&self, func: Func, cx: &mut Context<'_>) -> Poll<()> {
+    pub async fn poll_ready_for_concurrent_call(
+        &self,
+        func: Func,
+        cx: &mut Context<'_>,
+    ) -> Poll<()> {
         self.with(|mut access| {
             let store = access.as_context_mut().0;
             let (_, _, _, raw_options) = func.abi_info(store);
@@ -611,6 +617,7 @@ where
                 Poll::Pending
             }
         })
+        .await
     }
 }
 
diff --git a/crates/wasmtime/src/runtime/component/concurrent/func.rs b/crates/wasmtime/src/runtime/component/concurrent/func.rs
index 371bb8e621e9..e468df35d8f5 100644
--- a/crates/wasmtime/src/runtime/component/concurrent/func.rs
+++ b/crates/wasmtime/src/runtime/component/concurrent/func.rs
@@ -118,7 +118,9 @@ impl Func {
         results: &mut [Val],
     ) -> Result<()> {
         let accessor = accessor.as_accessor();
-        let call = accessor.with(|store| self.start_call_concurrent(store, params, results))?;
+        let call = accessor
+            .with(|store| self.start_call_concurrent(store, params, results))
+            .await?;
         self.finish_call_concurrent(accessor, call).await
     }
 
@@ -348,7 +350,8 @@ where
     {
         let call = accessor
             .as_accessor()
-            .with(|store| self.start_call_concurrent(store, params))?;
+            .with(|store| self.start_call_concurrent(store, params))
+            .await?;
         self.finish_call_concurrent(accessor, call).await
     }
 
diff --git a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
index ff313978bfc3..1b92f2c4f355 100644
--- a/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
+++ b/crates/wasmtime/src/runtime/component/concurrent/futures_and_streams.rs
@@ -1425,8 +1425,11 @@ impl<T> FutureReader<T> {
     }
 
     /// Convenience method around [`Self::close`].
-    pub fn close_with(&mut self, accessor: impl AsAccessor) -> Result<()> {
-        accessor.as_accessor().with(|access| self.close(access))
+    pub async fn close_with(&mut self, accessor: impl AsAccessor) -> Result<()> {
+        accessor
+            .as_accessor()
+            .with(|access| self.close(access))
+            .await
     }
 
     /// Returns a [`GuardedFutureReader`] which will auto-close this future on
@@ -1434,11 +1437,11 @@ impl<T> FutureReader<T> {
     ///
     /// Note that the `accessor` provided must own this future and is
     /// additionally transferred to the `GuardedFutureReader` return value.
-    pub fn guard<A>(self, accessor: A) -> GuardedFutureReader<T, A>
+    pub async fn guard<A>(self, accessor: A) -> GuardedFutureReader<T, A>
     where
         A: AsAccessor,
     {
-        GuardedFutureReader::new(accessor, self)
+        GuardedFutureReader::new(accessor, self).await
     }
 
     /// Attempts to convert this [`FutureReader<T>`] to a [`FutureAny`].
@@ -1607,11 +1610,12 @@ where
     /// Panics if [`Config::concurrency_support`] is not enabled.
     ///
     /// [`Config::concurrency_support`]: crate::Config::concurrency_support
-    pub fn new(accessor: A, reader: FutureReader<T>) -> Self {
+    pub async fn new(accessor: A, reader: FutureReader<T>) -> Self {
         assert!(
             accessor
                 .as_accessor()
                 .with(|a| a.as_context().0.concurrency_support())
+                .await
         );
         Self {
             reader: Some(reader),
@@ -1643,8 +1647,9 @@ where
         if let Some(reader) = &mut self.reader {
             // Currently this can only fail if the future is closed twice, which
             // this guard prevents, so this error shouldn't happen.
-            let result = reader.close_with(&self.accessor);
-            debug_assert!(result.is_ok());
+            todo!()
+            // let result = reader.close_with(&self.accessor);
+            // debug_assert!(result.is_ok());
         }
     }
 }
@@ -1784,8 +1789,11 @@ impl<T> StreamReader<T> {
     }
 
     /// Convenience method around [`Self::close`].
-    pub fn close_with(&mut self, accessor: impl AsAccessor) -> Result<()> {
-        accessor.as_accessor().with(|access| self.close(access))
+    pub async fn close_with(&mut self, accessor: impl AsAccessor) -> Result<()> {
+        accessor
+            .as_accessor()
+            .with(|access| self.close(access))
+            .await
     }
 
     /// Returns a [`GuardedStreamReader`] which will auto-close this stream on
@@ -1793,11 +1801,11 @@ impl<T> StreamReader<T> {
     ///
     /// Note that the `accessor` provided must own this future and is
     /// additionally transferred to the `GuardedStreamReader` return value.
-    pub fn guard<A>(self, accessor: A) -> GuardedStreamReader<T, A>
+    pub async fn guard<A>(self, accessor: A) -> GuardedStreamReader<T, A>
     where
         A: AsAccessor,
     {
-        GuardedStreamReader::new(accessor, self)
+        GuardedStreamReader::new(accessor, self).await
     }
 
     /// Attempts to convert this [`StreamReader<T>`] to a [`StreamAny`].
@@ -1967,11 +1975,12 @@ where
     /// Panics if [`Config::concurrency_support`] is not enabled.
     ///
     /// [`Config::concurrency_support`]: crate::Config::concurrency_support
-    pub fn new(accessor: A, reader: StreamReader<T>) -> Self {
+    pub async fn new(accessor: A, reader: StreamReader<T>) -> Self {
         assert!(
             accessor
                 .as_accessor()
                 .with(|a| a.as_context().0.concurrency_support())
+                .await
         );
         Self {
             reader: Some(reader),
@@ -2003,8 +2012,9 @@ where
         if let Some(reader) = &mut self.reader {
             // Currently this can only fail if the future is closed twice, which
             // this guard prevents, so this error shouldn't happen.
-            let result = reader.close_with(&self.accessor);
-            debug_assert!(result.is_ok());
+            todo!();
+            // let result = reader.close_with(&self.accessor);
+            // debug_assert!(result.is_ok());
         }
     }
 }
diff --git a/crates/wit-bindgen/src/lib.rs b/crates/wit-bindgen/src/lib.rs
index 5154f4491c5f..818efb8a4dad 100644
--- a/crates/wit-bindgen/src/lib.rs
+++ b/crates/wit-bindgen/src/lib.rs
@@ -2939,7 +2939,7 @@ pub fn add_to_linker<T, D>(
             };
             let convert = format!("{}::convert_{}", convert_trait, err_name.to_snake_case());
             let convert = if func.kind.is_async() {
-                format!("caller.with(|mut host| {convert}(&mut host_getter(host.get()), e))")
+                format!("caller.with(|mut host| {convert}(&mut host_getter(host.get()), e)).await")
             } else if flags.contains(FunctionFlags::STORE) {
                 format!("{convert}(&mut host_getter(caller.data_mut()), e)")
             } else {
diff --git a/tests/all/component_model/async.rs b/tests/all/component_model/async.rs
index d7c712e85b2c..55666089c6b4 100644
--- a/tests/all/component_model/async.rs
+++ b/tests/all/component_model/async.rs
@@ -455,12 +455,14 @@ async fn run_wasm_in_call_async() -> Result<()> {
         .root()
         .func_wrap_concurrent("a", |accessor: &Accessor<State>, (): ()| {
             Box::pin(async move {
-                let func = accessor.with(|mut access| {
-                    access
-                        .get()
-                        .unwrap()
-                        .get_typed_func::<(), ()>(&mut access, "run")
-                })?;
+                let func = accessor
+                    .with(|mut access| {
+                        access
+                            .get()
+                            .unwrap()
+                            .get_typed_func::<(), ()>(&mut access, "run")
+                    })
+                    .await?;
                 func.call_concurrent(accessor, ()).await?;
                 Ok(())
             })
@@ -658,11 +660,13 @@ async fn sync_lower_async_host_does_not_leak() -> Result<()> {
 
                 // Keep track of the maximum size of the table in
                 // concurrent_state.
-                accessor.with(|mut s| {
-                    let cur = s.as_context_mut().concurrent_state_table_size();
-                    let max = s.data_mut();
-                    *max = (*max).max(cur);
-                });
+                accessor
+                    .with(|mut s| {
+                        let cur = s.as_context_mut().concurrent_state_table_size();
+                        let max = s.data_mut();
+                        *max = (*max).max(cur);
+                    })
+                    .await;
                 Ok(())
             })
         })?;
@@ -896,10 +900,12 @@ async fn concurrent_sync_calls_to_async_host() -> Result<()> {
         .root()
         .func_wrap_concurrent("await-three-calls", |accessor, (): ()| {
             Box::pin(async move {
-                accessor.with(|mut s| {
-                    *s.data_mut() += 1;
-                });
-                while accessor.with(|mut s| *s.data_mut()) < 3 {
+                accessor
+                    .with(|mut s| {
+                        *s.data_mut() += 1;
+                    })
+                    .await;
+                while accessor.with(|mut s| *s.data_mut()).await < 3 {
                     tokio::task::yield_now().await;
                 }
                 Ok(())
diff --git a/tests/all/component_model/async_dynamic.rs b/tests/all/component_model/async_dynamic.rs
index 3b0b67435720..0297ae52026e 100644
--- a/tests/all/component_model/async_dynamic.rs
+++ b/tests/all/component_model/async_dynamic.rs
@@ -271,7 +271,7 @@ async fn stream_any_smoke() -> Result<()> {
                     wasmtime::error::Ok(())
                 },
                 async {
-                    store.with(|store| stream.close(store))?;
+                    store.with(|store| stream.close(store)).await?;
                     wasmtime::error::Ok(())
                 }
             }?;
diff --git a/tests/all/component_model/bindgen.rs b/tests/all/component_model/bindgen.rs
index 95bf96dcecc0..e13eec347ea3 100644
--- a/tests/all/component_model/bindgen.rs
+++ b/tests/all/component_model/bindgen.rs
@@ -274,7 +274,7 @@ mod one_import_concurrent {
 
         impl<T> foo::HostWithStore<T> for MyImports {
             async fn foo(accessor: &Accessor<T, Self>) {
-                accessor.with(|mut view| view.get().hit = true);
+                accessor.with(|mut view| view.get().hit = true).await;
             }
         }
 
diff --git a/tests/all/component_model/import.rs b/tests/all/component_model/import.rs
index f89f10837f0b..df438c1a0ec5 100644
--- a/tests/all/component_model/import.rs
+++ b/tests/all/component_model/import.rs
@@ -757,8 +757,12 @@ async fn test_stack_and_heap_args_and_rets(concurrent: bool) -> Result<()> {
                 WasmStr,
                 WasmStr,
             ),)| {
-                accessor.with(|v| assert_eq!(arg.0.to_str(&v).unwrap(), "abc"));
-                Box::pin(async { Ok((3u32,)) })
+                Box::pin(async move {
+                    accessor
+                        .with(|v| assert_eq!(arg.0.to_str(&v).unwrap(), "abc"))
+                        .await;
+                    Ok((3u32,))
+                })
             },
         )?;
         linker
@@ -781,8 +785,12 @@ async fn test_stack_and_heap_args_and_rets(concurrent: bool) -> Result<()> {
                 WasmStr,
                 WasmStr,
             ),)| {
-                accessor.with(|v| assert_eq!(arg.0.to_str(&v).unwrap(), "abc"));
-                Box::pin(async { Ok(("xyz".to_string(),)) })
+                Box::pin(async move {
+                    accessor
+                        .with(|v| assert_eq!(arg.0.to_str(&v).unwrap(), "abc"))
+                        .await;
+                    Ok(("xyz".to_string(),))
+                })
             },
         )?;
     } else {