@wasm-oj/server 0.2.2 → 0.2.4

package/crates/runtime-core/src/deterministic.rs

@@ -6,6 +6,7 @@ use crate::{
     },
     types::DeterminismConfig,
 };
+use std::cell::Cell;
 use std::sync::{Arc, Mutex};
 use wasmer::{
     AsStoreMut, Extern, Function, FunctionEnv, FunctionEnvMut, Imports, Memory, Memory32, Memory64,
@@ -239,6 +240,23 @@ struct PollEnv {
     clock: VirtualClock,
 }
 
+thread_local! {
+    static STDIN_READINESS_DEFERRALS: Cell<u64> = const { Cell::new(0) };
+}
+
+/// Whether an empty stdin readiness check may return `Pending` instead of
+/// blocking. A clock probe never blocks. A poll without a clock grants one
+/// deferral per read subscription, so WASIX reports any other ready
+/// subscription first and blocks on stdin only when it would wait anyway.
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn defer_stdin_readiness() -> bool {
+    STDIN_READINESS_DEFERRALS.with(|deferrals| {
+        let remaining = deferrals.get();
+        deferrals.set(remaining.saturating_sub(1));
+        remaining > 0
+    })
+}
+
 #[derive(Clone, Copy)]
 struct ClockSubscription {
     subscription: Subscription,
@@ -251,6 +269,7 @@ fn call_original_poll<M: MemorySize>(
     events: WasmPtr<Event, M>,
     subscription_count: M::Offset,
     event_count: WasmPtr<M::Offset, M>,
+    stdin_deferrals: u64,
 ) -> Result<i32, RuntimeError> {
     let Some(original) = env.data().original.clone() else {
         return Ok(Errno::Notsup as i32);
@@ -262,6 +281,7 @@ fn call_original_poll<M: MemorySize>(
             Value::I32(offset as i32)
         }
     };
+    STDIN_READINESS_DEFERRALS.with(|deferrals| deferrals.set(stdin_deferrals));
     let results = original.call(
         env,
         &[
@@ -270,7 +290,9 @@ fn call_original_poll<M: MemorySize>(
             pointer(subscription_count.into()),
             pointer(event_count.offset().into()),
         ],
-    )?;
+    );
+    STDIN_READINESS_DEFERRALS.with(|deferrals| deferrals.set(0));
+    let results = results?;
     match results.as_ref() {
         [Value::I32(errno)] => Ok(*errno),
         _ => Err(RuntimeError::new(
@@ -302,6 +324,7 @@ fn deterministic_poll_oneoff<M: MemorySize>(
     let mut originals = Vec::with_capacity(input.len() as usize);
     let mut clock_subscriptions = Vec::new();
     let mut has_non_clock = false;
+    let mut read_subscriptions = 0;
     for index in 0..input.len() {
         let subscription = input
             .index(index)
@@ -320,6 +343,7 @@ fn deterministic_poll_oneoff<M: MemorySize>(
             });
         } else {
             has_non_clock = true;
+            read_subscriptions += u64::from(subscription.type_ == Eventtype::FdRead);
         }
     }
 
@@ -330,6 +354,7 @@ fn deterministic_poll_oneoff<M: MemorySize>(
             events,
             subscription_count,
             event_count,
+            read_subscriptions,
         );
     }
 
@@ -355,6 +380,7 @@ fn deterministic_poll_oneoff<M: MemorySize>(
             events,
             subscription_count,
             event_count,
+            u64::MAX,
         );
         let restore_view = memory.view(&env);
         let restore_input = subscriptions

package/crates/runtime-core/src/interactive.rs

@@ -3,10 +3,7 @@ use crate::deterministic::{VirtualClock, attach_interactive_deterministic_import
 use crate::filesystem::{
     RuntimeProjectFilesystem, is_normalized_guest_path, runtime_project_files,
 };
-use crate::meter::{
-    CONTESTANT_METERING_MODULE, HOST_GAS_FUNCTION, INTERACTOR_METERING_MODULE,
-    instrument_wasm_with_host_meter,
-};
+use crate::meter::{CostPoints, MeterState, instrument_wasm, meter_state, remaining_points};
 use crate::module_imports::attach_declared_memory_imports;
 use crate::module_policy::{
     DEFERRED_START_EXPORT, defer_start_section, enforce_memory_limit,
@@ -17,6 +14,7 @@ use crate::{
     ExecutionTermination, InteractiveMetrics, InteractiveProcessResult, InteractiveProgram,
     InteractiveRequest, InteractiveResult, RunError,
 };
+use futures::channel::oneshot;
 use std::collections::{BTreeMap, HashMap};
 use std::io;
 use std::pin::Pin;
@@ -24,75 +22,17 @@ use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
 use virtual_fs::{FsError, Pipe, PipeRx, PipeTx, VirtualFile};
-use wasmer::{
-    AsStoreMut, Engine, Function, FunctionEnv, FunctionEnvMut, Imports, Memory, RuntimeError,
-};
+use wasmer::{AsStoreMut, Engine, Imports, Memory};
 use wasmer_types::StoreId;
-use wasmer_wasix::bin_factory::spawn_exec_wasm;
+use wasmer_wasix::bin_factory::{run_exec, spawn_load_module};
+use wasmer_wasix::os::task::TaskJoinHandle;
 use wasmer_wasix::runtime::module_cache::{self, HashedModuleData, ModuleCache};
+use wasmer_wasix::runtime::task_manager::TaskWasm;
 use wasmer_wasix::{
     PluggableRuntime, Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiVersion,
     generate_import_object_from_env,
 };
 
-#[derive(Debug)]
-struct GasBudget {
-    initial: u64,
-    state: Mutex<GasState>,
-}
-
-#[derive(Debug)]
-struct GasState {
-    remaining: u64,
-    exhausted: bool,
-}
-
-impl GasBudget {
-    fn new(initial: u64) -> Self {
-        Self {
-            initial,
-            state: Mutex::new(GasState {
-                remaining: initial,
-                exhausted: false,
-            }),
-        }
-    }
-
-    fn charge(&self, amount: u64) -> Result<(), RuntimeError> {
-        let mut state = self
-            .state
-            .lock()
-            .map_err(|error| RuntimeError::new(error.to_string()))?;
-        if amount > state.remaining {
-            state.remaining = 0;
-            state.exhausted = true;
-            return Err(RuntimeError::new("WASM-OJ instruction budget exhausted"));
-        }
-        state.remaining -= amount;
-        Ok(())
-    }
-
-    fn metrics(&self) -> Result<(u64, bool), RunError> {
-        let state = self
-            .state
-            .lock()
-            .map_err(|error| RunError::Runtime(error.to_string()))?;
-        Ok((
-            self.initial.saturating_sub(state.remaining),
-            state.exhausted,
-        ))
-    }
-}
-
-#[derive(Clone)]
-struct GasEnv(Arc<GasBudget>);
-
-fn charge_gas(env: FunctionEnvMut<GasEnv>, amount: i64) -> Result<(), RuntimeError> {
-    let amount = u64::try_from(amount)
-        .map_err(|_| RuntimeError::new("WASM-OJ received a negative instruction charge"))?;
-    env.data().0.charge(amount)
-}
-
 #[derive(Debug)]
 struct InteractiveInput {
     pipe: PipeRx,
@@ -263,7 +203,8 @@ impl VirtualFile for InteractiveOutput {
 struct PreparedProgram {
     wasm: Vec<u8>,
     operations: BTreeMap<String, u64>,
-    gas: Arc<GasBudget>,
+    budget: u64,
+    meter: Arc<Mutex<Option<MeterState>>>,
     protocol: OutputCapture,
     stderr: OutputCapture,
     filesystem: RuntimeProjectFilesystem,
@@ -272,16 +213,8 @@ struct PreparedProgram {
 
 pub async fn interact(request: InteractiveRequest) -> Result<InteractiveResult, RunError> {
     validate_request(&request)?;
-    let contestant = prepare_program(
-        &request.contestant,
-        CONTESTANT_METERING_MODULE,
-        &request.determinism,
-    )?;
-    let interactor = prepare_program(
-        &request.interactor,
-        INTERACTOR_METERING_MODULE,
-        &request.determinism,
-    )?;
+    let contestant = prepare_program(&request.contestant, &request.determinism)?;
+    let interactor = prepare_program(&request.interactor, &request.determinism)?;
     let maximum_memory = request
         .contestant
         .resources
@@ -293,7 +226,7 @@ pub async fn interact(request: InteractiveRequest) -> Result<InteractiveResult,
     let contestant_runtime = interactive_runtime(
         engine.clone(),
         &request.determinism,
-        contestant.gas.clone(),
+        contestant.meter.clone(),
         contestant.clock.clone(),
         request.contestant.startup_entropy_bytes,
         module_cache.clone(),
@@ -303,7 +236,7 @@ pub async fn interact(request: InteractiveRequest) -> Result<InteractiveResult,
     let interactor_runtime = interactive_runtime(
         engine,
         &request.determinism,
-        interactor.gas.clone(),
+        interactor.meter.clone(),
         interactor.clock.clone(),
         request.interactor.startup_entropy_bytes,
         module_cache,
@@ -334,36 +267,38 @@ pub async fn interact(request: InteractiveRequest) -> Result<InteractiveResult,
     *interactor_wasi
         .lock()
         .map_err(|error| RunError::Runtime(error.to_string()))? = Some(interactor_env.clone());
-    let mut contestant_handle = spawn_exec_wasm(
-        HashedModuleData::new(contestant.wasm.clone()),
+    let (mut contestant_handle, contestant_points) = spawn_metered(
         "contestant",
+        &contestant,
         contestant_env,
         &contestant_runtime,
     )
-    .await
-    .map_err(|error| RunError::Compile(format!("failed to start contestant: {error}")))?;
-    let mut interactor_handle = spawn_exec_wasm(
-        HashedModuleData::new(interactor.wasm.clone()),
+    .await?;
+    let (mut interactor_handle, interactor_points) = spawn_metered(
         "interactor",
+        &interactor,
         interactor_env,
         &interactor_runtime,
     )
-    .await
-    .map_err(|error| RunError::Compile(format!("failed to start interactor: {error}")))?;
-    let (contestant_status, interactor_status) = futures::join!(
+    .await?;
+    let (contestant_status, interactor_status, contestant_points, interactor_points) = futures::join!(
         contestant_handle.wait_finished(),
         interactor_handle.wait_finished(),
+        contestant_points,
+        interactor_points,
     );
 
     let contestant_to_interactor = contestant.protocol.bytes();
     let interactor_to_contestant = interactor.protocol.bytes();
     let contestant_result = process_result(
         contestant_status,
+        contestant_points,
         contestant,
         contestant_to_interactor.len(),
     )?;
     let interactor_result = process_result(
         interactor_status,
+        interactor_points,
         interactor,
         interactor_to_contestant.len(),
     )?;
@@ -376,15 +311,56 @@ pub async fn interact(request: InteractiveRequest) -> Result<InteractiveResult,
     })
 }
 
+/// `spawn_exec_wasm` without its CLOEXEC sweep, which a fresh environment does not need, plus a
+/// recycle hook that reads the meter from the store after the process exits. WASIX reports the
+/// exit before it recycles the store, so callers await both.
+async fn spawn_metered(
+    name: &str,
+    program: &PreparedProgram,
+    env: WasiEnv,
+    runtime: &Arc<dyn Runtime + Send + Sync>,
+) -> Result<
+    (
+        TaskJoinHandle,
+        oneshot::Receiver<Result<CostPoints, String>>,
+    ),
+    RunError,
+> {
+    let module = spawn_load_module(name, HashedModuleData::new(program.wasm.clone()), runtime)
+        .await
+        .map_err(|error| RunError::Compile(format!("failed to start {name}: {error}")))?;
+    let finished = env.thread.join_handle();
+    let meter = program.meter.clone();
+    let (points, received) = oneshot::channel();
+    let task = TaskWasm::new(Box::new(run_exec), env, module, true, true).with_recycle(Box::new(
+        move |mut exited| {
+            let read = meter
+                .lock()
+                .map_err(|error| error.to_string())
+                .and_then(|meter| {
+                    meter
+                        .clone()
+                        .ok_or_else(|| "meter is unavailable".to_string())
+                })
+                .and_then(|meter| remaining_points(&mut exited.store, &meter));
+            let _ = points.send(read);
+        },
+    ));
+    runtime
+        .task_manager()
+        .task_wasm(task)
+        .map_err(|error| RunError::Compile(format!("failed to start {name}: {error}")))?;
+    Ok((finished, received))
+}
+
 fn prepare_program(
     program: &InteractiveProgram,
-    metering_module: &'static str,
     determinism: &crate::DeterminismConfig,
 ) -> Result<PreparedProgram, RunError> {
     let limited = enforce_memory_limit(&program.wasm, program.resources.memory_limit_bytes)
         .map_err(RunError::Compile)?;
-    let metered =
-        instrument_wasm_with_host_meter(&limited, metering_module).map_err(RunError::Compile)?;
+    let metered = instrument_wasm(&limited, program.resources.instruction_budget)
+        .map_err(RunError::Compile)?;
     let executable = defer_start_section(&metered.wasm).map_err(RunError::Compile)?;
     let wasm =
         rewrite_interactive_deterministic_imports(&executable.wasm).map_err(RunError::Compile)?;
@@ -397,7 +373,8 @@ fn prepare_program(
     Ok(PreparedProgram {
         wasm,
         operations: metered.operations,
-        gas: Arc::new(GasBudget::new(program.resources.instruction_budget)),
+        budget: program.resources.instruction_budget,
+        meter: Arc::new(Mutex::new(None)),
         protocol,
         stderr,
         filesystem,
@@ -443,12 +420,20 @@ fn build_environment(
 
 fn process_result(
     status: Result<wasmer_wasix::wasmer_wasix_types::wasi::ExitCode, Arc<WasiRuntimeError>>,
+    points: Result<Result<CostPoints, String>, oneshot::Canceled>,
     prepared: PreparedProgram,
     protocol_bytes: usize,
 ) -> Result<InteractiveProcessResult, RunError> {
     let stderr = prepared.stderr.bytes();
     let output_exceeded = prepared.protocol.exceeded() || prepared.stderr.exceeded();
-    let (cost, exhausted) = prepared.gas.metrics()?;
+    let points = points
+        .map_err(|_| RunError::Runtime("interactive process exited without its meter".to_string()))?
+        .map_err(RunError::Runtime)?;
+    let exhausted = points == CostPoints::Exhausted;
+    let cost = match points {
+        CostPoints::Remaining(points) => prepared.budget.saturating_sub(points),
+        CostPoints::Exhausted => prepared.budget,
+    };
     let logical_time_exceeded = prepared.clock.limit_exceeded()?;
     let (code, termination) = if prepared.filesystem.quota_exceeded() {
         (137, ExecutionTermination::FilesystemLimit)
@@ -516,7 +501,7 @@ fn validate_request(request: &InteractiveRequest) -> Result<(), RunError> {
 fn interactive_runtime(
     engine: Engine,
     determinism: &crate::DeterminismConfig,
-    gas: Arc<GasBudget>,
+    meter: Arc<Mutex<Option<MeterState>>>,
     clock: VirtualClock,
     startup_entropy_bytes: u64,
     module_cache: Arc<dyn ModuleCache + Send + Sync>,
@@ -578,22 +563,6 @@ fn interactive_runtime(
             clock.clone(),
             startup_entropy_bytes,
         );
-        let metering_module = module
-            .imports()
-            .find_map(|import| match import.module() {
-                CONTESTANT_METERING_MODULE => Some(CONTESTANT_METERING_MODULE),
-                INTERACTOR_METERING_MODULE => Some(INTERACTOR_METERING_MODULE),
-                _ => None,
-            })
-            .ok_or_else(|| {
-                io::Error::other("interactive module has no WASM-OJ metering identity")
-            })?;
-        let gas_env = FunctionEnv::new(&mut *store, GasEnv(gas.clone()));
-        imports.define(
-            metering_module,
-            HOST_GAS_FUNCTION,
-            Function::new_typed_with_env(&mut *store, &gas_env, charge_gas),
-        );
         attach_capability_denials(store, module, &mut imports).map_err(io::Error::other)?;
         attach_declared_memory_imports(store, module, &mut imports).map_err(io::Error::other)?;
         Ok(imports)
@@ -616,6 +585,10 @@ fn interactive_runtime(
             .memory
             .lock()
             .map_err(|error| io::Error::other(error.to_string()))? = Some(memory);
+        *meter
+            .lock()
+            .map_err(|error| io::Error::other(error.to_string()))? =
+            Some(meter_state(instance).map_err(io::Error::other)?);
         pending
             .wasi
             .initialize(&mut *store, instance.clone())
@@ -673,7 +646,7 @@ mod tests {
     use super::interact;
     use crate::{
         DeterminismConfig, ExecutionTermination, InteractiveProgram, InteractiveRequest,
-        ResourcePolicy,
+        ResourcePolicy, RunRequest,
     };
     use std::collections::BTreeMap;
 
@@ -998,6 +971,155 @@ mod tests {
         assert_eq!(result.interactor.metrics.logical_time_ns, 0);
     }
 
+    #[test]
+    fn interactive_empty_stdin_poll_times_out_on_the_process_clock() {
+        let poller = wat::parse_str(
+            r#"(module
+              (import "wasi_snapshot_preview1" "poll_oneoff"
+                (func $poll (param i32 i32 i32 i32) (result i32)))
+              (import "wasi_snapshot_preview1" "fd_write"
+                (func $fd_write (param i32 i32 i32 i32) (result i32)))
+              (memory (export "memory") 1)
+              (func (export "_start")
+                i32.const 0 i64.const 1 i64.store
+                i32.const 8 i32.const 1 i32.store8
+                i32.const 16 i32.const 0 i32.store
+                i32.const 48 i64.const 2 i64.store
+                i32.const 56 i32.const 0 i32.store8
+                i32.const 64 i32.const 1 i32.store
+                i32.const 72 i64.const 5000000000 i64.store
+                i32.const 80 i64.const 1 i64.store
+                i32.const 88 i32.const 0 i32.store16
+                i32.const 0 i32.const 128 i32.const 2 i32.const 240 call $poll drop
+                i32.const 200 i32.const 138 i32.store
+                i32.const 204 i32.const 1 i32.store
+                i32.const 208 i32.const 240 i32.store
+                i32.const 212 i32.const 1 i32.store
+                i32.const 1 i32.const 200 i32.const 2 i32.const 216 call $fd_write drop))"#,
+        )
+        .unwrap();
+        let listener = wat::parse_str(
+            r#"(module
+              (import "wasi_snapshot_preview1" "fd_read"
+                (func $fd_read (param i32 i32 i32 i32) (result i32)))
+              (memory (export "memory") 1)
+              (func (export "_start")
+                (i32.store (i32.const 0) (i32.const 64))
+                (i32.store (i32.const 4) (i32.const 8))
+                (drop (call $fd_read (i32.const 0) (i32.const 0) (i32.const 1) (i32.const 8)))))"#,
+        )
+        .unwrap();
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let result = runtime
+            .block_on(interact(InteractiveRequest {
+                contestant: program(poller),
+                interactor: program(listener),
+                determinism: DeterminismConfig {
+                    random_seed: 7,
+                    realtime_epoch_ms: 946_684_800_000,
+                    clock_step_ns: 1_000_000,
+                },
+            }))
+            .unwrap();
+
+        assert_eq!(result.contestant_to_interactor, [0, 1]);
+        assert_eq!(result.contestant.termination, ExecutionTermination::Exited);
+        assert_eq!(result.contestant.metrics.logical_time_ns, 5_000_000_000);
+        assert_eq!(result.interactor.termination, ExecutionTermination::Exited);
+    }
+
+    #[test]
+    fn interactive_contestant_is_metered_like_a_standalone_run() {
+        let looping = |ending: &str| {
+            wat::parse_str(format!(
+                r#"(module
+                  (import "wasi_snapshot_preview1" "proc_exit" (func $exit (param i32)))
+                  (memory (export "memory") 1)
+                  (func (export "_start")
+                    (local $remaining i32)
+                    i32.const 1000 local.set $remaining
+                    (loop $again
+                      local.get $remaining i32.const 1 i32.sub local.tee $remaining
+                      br_if $again)
+                    {ending}))"#
+            ))
+            .unwrap()
+        };
+        let determinism = DeterminismConfig {
+            random_seed: 7,
+            realtime_epoch_ms: 946_684_800_000,
+            clock_step_ns: 1_000_000,
+        };
+        let execute = |wasm: &[u8], instruction_budget: u64| {
+            let mut contestant = program(wasm.to_vec());
+            contestant.resources.instruction_budget = instruction_budget;
+            let standalone = crate::run(RunRequest {
+                wasm: contestant.wasm.clone(),
+                args: Vec::new(),
+                env: BTreeMap::new(),
+                stdin: Vec::new(),
+                files: BTreeMap::new(),
+                output_paths: Vec::new(),
+                cwd: contestant.cwd.clone(),
+                startup_entropy_bytes: 0,
+                determinism: determinism.clone(),
+                resources: contestant.resources.clone(),
+            })
+            .unwrap();
+            let interactive = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(interact(InteractiveRequest {
+                    interactor: contestant.clone(),
+                    contestant,
+                    determinism: determinism.clone(),
+                }))
+                .unwrap();
+            assert_eq!(interactive.interactor.code, interactive.contestant.code);
+            assert_eq!(
+                interactive.interactor.termination,
+                interactive.contestant.termination
+            );
+            assert_eq!(
+                interactive.interactor.metrics.cost,
+                interactive.contestant.metrics.cost
+            );
+            (standalone, interactive.contestant)
+        };
+
+        for (ending, code) in [("", 0), ("i32.const 3 call $exit", 3)] {
+            let wasm = looping(ending);
+            let (standalone, interactive) = execute(&wasm, 1_000_000);
+            assert_eq!(standalone.termination, ExecutionTermination::Exited);
+            assert_eq!(standalone.code, code);
+            assert_eq!(interactive.termination, ExecutionTermination::Exited);
+            assert_eq!(interactive.code, code);
+            assert_eq!(interactive.metrics.cost, standalone.metrics.cost);
+
+            let budget = standalone.metrics.cost - 1;
+            let (standalone, interactive) = execute(&wasm, budget);
+            assert_eq!(
+                standalone.termination,
+                ExecutionTermination::InstructionLimit
+            );
+            assert_eq!(
+                interactive.termination,
+                ExecutionTermination::InstructionLimit
+            );
+            assert_eq!(interactive.code, 137);
+            assert_eq!(interactive.metrics.cost, budget);
+            assert_eq!(interactive.metrics.cost, standalone.metrics.cost);
+        }
+
+        let (standalone, interactive) = execute(&looping("unreachable"), 1_000_000);
+        assert_eq!(standalone.termination, ExecutionTermination::Trap);
+        assert_eq!(interactive.metrics.cost, standalone.metrics.cost);
+    }
+
     fn program(wasm: Vec<u8>) -> InteractiveProgram {
         InteractiveProgram {
             wasm,

package/crates/runtime-core/src/meter.rs

@@ -7,18 +7,13 @@ use std::borrow::Cow;
 use std::collections::BTreeMap;
 use wasm_encoder::reencode::{Error as ReencodeError, Reencode};
 use wasm_encoder::{Encode, Section};
-#[cfg(not(target_arch = "wasm32"))]
-use wasmer::Global;
 #[cfg(target_arch = "wasm32")]
 use wasmer::js::AsJs;
-use wasmer::{AsStoreMut, Instance};
+use wasmer::{AsStoreMut, Global, Instance};
 
 pub const METER_MODEL: &str = "weighted";
 const METERING_MODULE: &str = "wasm_oj_metering";
 const GAS_COUNTER_NAME: &str = "gas_counter";
-pub(crate) const CONTESTANT_METERING_MODULE: &str = "wasm_oj_contestant_metering";
-pub(crate) const INTERACTOR_METERING_MODULE: &str = "wasm_oj_interactor_metering";
-pub(crate) const HOST_GAS_FUNCTION: &str = "charge";
 
 #[derive(Debug)]
 pub struct InstrumentedModule {
@@ -53,10 +48,7 @@ pub enum CostPoints {
 
 #[derive(Clone, Debug)]
 pub struct MeterState {
-    #[cfg(not(target_arch = "wasm32"))]
     gas_counter: Global,
-    #[cfg(target_arch = "wasm32")]
-    gas_counter: WebAssembly::Global,
 }
 
 pub fn instrument_wasm(wasm: &[u8], budget: u64) -> Result<InstrumentedModule, String> {
@@ -85,32 +77,6 @@ pub fn instrument_wasm(wasm: &[u8], budget: u64) -> Result<InstrumentedModule, S
     })
 }
 
-pub(crate) fn instrument_wasm_with_host_meter(
-    wasm: &[u8],
-    metering_module: &'static str,
-) -> Result<InstrumentedModule, String> {
-    let runtime_sections = runtime_custom_sections(wasm)?;
-    let executable = canonicalize_custom_sections(wasm)?;
-    let operations = inspect_weighted_opcodes(&executable)?;
-    let mut module = ModuleInfo::new(&executable)
-        .map_err(|error| format!("failed to parse module for weighted metering: {error}"))?;
-    let backend = gas_metering::host_function::Injector::new(metering_module, HOST_GAS_FUNCTION);
-    let mut metered = gas_metering::inject(&mut module, backend, &WeightedRules)
-        .map_err(|error| format!("failed to inject weighted host metering: {error}"))?;
-    for (name, data) in runtime_sections {
-        let section = wasm_encoder::CustomSection {
-            name: Cow::Owned(name),
-            data: Cow::Owned(data),
-        };
-        metered.push(section.id());
-        section.encode(&mut metered);
-    }
-    Ok(InstrumentedModule {
-        wasm: metered,
-        operations,
-    })
-}
-
 #[derive(Debug)]
 struct MeterInitializationError(String);
 
@@ -271,26 +237,13 @@ fn inspect_weighted_opcodes(wasm: &[u8]) -> Result<BTreeMap<String, u64>, String
     Ok(operations)
 }
 
-pub fn meter_state(store: &mut impl AsStoreMut, instance: &Instance) -> Result<MeterState, String> {
-    let gas_counter = instance
+pub fn meter_state(instance: &Instance) -> Result<MeterState, String> {
+    instance
         .exports
         .get_global(GAS_COUNTER_NAME)
-        .map_err(|error| format!("instrumented module does not export its meter: {error}"))?
-        .clone();
-
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        let _ = store;
-        Ok(MeterState { gas_counter })
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    {
-        let js_global: WebAssembly::Global = gas_counter.as_jsvalue(store).into();
-        Ok(MeterState {
-            gas_counter: js_global,
-        })
-    }
+        .cloned()
+        .map(|gas_counter| MeterState { gas_counter })
+        .map_err(|error| format!("instrumented module does not export its meter: {error}"))
 }
 
 pub fn remaining_points(
@@ -306,8 +259,8 @@ pub fn remaining_points(
 
     #[cfg(target_arch = "wasm32")]
     let value = {
-        let _ = store;
-        i64::try_from(BigInt::from(meter.gas_counter.value()))
+        let gas_counter: WebAssembly::Global = meter.gas_counter.as_jsvalue(store).into();
+        i64::try_from(BigInt::from(gas_counter.value()))
             .map_err(|_| "metering global is outside the signed 64-bit range".to_string())?
     };
 

package/crates/runtime-core/src/run/mod.rs

@@ -15,6 +15,8 @@ mod native;
 #[cfg(target_arch = "wasm32")]
 mod web;
 #[cfg(target_arch = "wasm32")]
+pub(crate) mod web_interactive;
+#[cfg(target_arch = "wasm32")]
 pub(crate) mod web_runtime;
 
 pub fn run(request: RunRequest) -> Result<RunResult, RunError> {