@wasm-oj/server 0.2.0

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

@@ -0,0 +1,229 @@
+use super::web_runtime::runtime_with_engine;
+use crate::capabilities::attach_capability_denials;
+use crate::deterministic::{VirtualClock, attach_deterministic_imports};
+use crate::filesystem::{read_files_bounded, runtime_project_files};
+use crate::meter::{CostPoints, METER_MODEL, instrument_wasm, meter_state, remaining_points};
+use crate::module_imports::attach_imported_memory;
+use crate::module_policy::{DEFERRED_START_EXPORT, defer_start_section, enforce_memory_limit};
+use crate::output::{OutputBudget, OutputCapture};
+use crate::{ExecutionMetrics, ExecutionTermination, RunError, RunRequest, RunResult};
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+use wasmer::{Instance, Memory, Module, Store};
+use wasmer_wasix::{
+    Pipe, WasiEnv, WasiError, WasiModuleInstanceHandles, WasiModuleTreeHandles, wasmer_wasix_types,
+};
+
+pub fn run(request: RunRequest) -> Result<RunResult, RunError> {
+    let limited = enforce_memory_limit(&request.wasm, request.resources.memory_limit_bytes)
+        .map_err(RunError::Compile)?;
+    let metered = instrument_wasm(&limited, request.resources.instruction_budget)
+        .map_err(RunError::Compile)?;
+    let executable = defer_start_section(&metered.wasm).map_err(RunError::Compile)?;
+    let mut store = Store::default();
+    let module = Module::new(&store, &executable.wasm).map_err(|error| {
+        RunError::Compile(format!("failed to compile instrumented module: {error}"))
+    })?;
+    let runtime = runtime_with_engine(store.engine().clone());
+
+    let (mut stdin_writer, stdin_reader) = Pipe::channel();
+    stdin_writer
+        .write_all(&request.stdin)
+        .map_err(|error| RunError::Io(error.to_string()))?;
+    drop(stdin_writer);
+    let output_limit = usize::try_from(request.resources.output_limit_bytes)
+        .map_err(|_| RunError::InvalidRequest("output limit exceeds host range".to_string()))?;
+    let output_budget = OutputBudget::new(output_limit);
+    let (stdout_capture, stdout_file) = OutputCapture::new(output_budget.clone(), 1);
+    let (stderr_capture, stderr_file) = OutputCapture::new(output_budget, 2);
+
+    let project_filesystem = runtime_project_files(
+        &request.files,
+        &request.output_paths,
+        &request.determinism,
+        &request.resources,
+    )?;
+    let filesystem = project_filesystem.filesystem();
+    let mut builder = WasiEnv::builder("app")
+        .runtime(runtime)
+        .args(request.args.clone())
+        .envs(request.env.clone())
+        .stdin(Box::new(stdin_reader))
+        .stdout(Box::new(stdout_file))
+        .stderr(Box::new(stderr_file))
+        .fs(filesystem.clone());
+    builder
+        .add_preopen_build(|directory| directory.directory("/").read(true).write(true).create(true))
+        .map_err(|error| {
+            RunError::InvalidRequest(format!("failed to preopen guest filesystem: {error}"))
+        })?;
+    if let Some(cwd) = &request.cwd {
+        builder.set_current_dir(cwd);
+    }
+    let mut sandbox = builder.finalize(&mut store).map_err(|error| {
+        RunError::Compile(format!("failed to finalize WASI environment: {error}"))
+    })?;
+    let mut imports = sandbox
+        .import_object_for_all_wasi_versions(&mut store, &module)
+        .map_err(|error| RunError::Compile(format!("failed to create WASI imports: {error}")))?;
+    let memory_slot: Arc<Mutex<Option<Memory>>> = Arc::new(Mutex::new(None));
+    let clock = VirtualClock::new(
+        &request.determinism,
+        request.resources.logical_time_limit_ms,
+    );
+    attach_deterministic_imports(
+        &mut store,
+        &mut imports,
+        memory_slot.clone(),
+        &request.determinism,
+        clock.clone(),
+        request.startup_entropy_bytes,
+    );
+    attach_capability_denials(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
+    let imported_memory =
+        attach_imported_memory(&mut store, &module, &mut imports).map_err(RunError::Compile)?;
+    let instance = Instance::new(&mut store, &module, &imports)
+        .map_err(|error| RunError::Compile(format!("failed to instantiate module: {error}")))?;
+    let meter = meter_state(&mut store, &instance).map_err(RunError::Runtime)?;
+    let guest_memory = instance
+        .exports
+        .get_memory("memory")
+        .cloned()
+        .ok()
+        .or(imported_memory)
+        .ok_or_else(|| RunError::Compile("module has no guest linear memory".to_string()))?;
+    *memory_slot
+        .lock()
+        .map_err(|error| RunError::Runtime(error.to_string()))? = Some(guest_memory.clone());
+    let handles = WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new(
+        guest_memory.clone(),
+        &store,
+        instance.clone(),
+        None,
+    ));
+    sandbox
+        .initialize_handles_and_layout(&mut store, instance.clone(), handles, None, true)
+        .map_err(|error| {
+            RunError::Compile(format!("failed to initialize WASI instance: {error}"))
+        })?;
+    let start = instance
+        .exports
+        .get_function("_start")
+        .map_err(|error| RunError::Compile(format!("module has no _start function: {error}")))?;
+    let execution = if executable.has_deferred_start {
+        let initializer = instance
+            .exports
+            .get_function(DEFERRED_START_EXPORT)
+            .map_err(|error| {
+                RunError::Runtime(format!("deferred start function is unavailable: {error}"))
+            })?;
+        match initializer.call(&mut store, &[]) {
+            Ok(_) => start.call(&mut store, &[]),
+            Err(error) => Err(error),
+        }
+    } else {
+        start.call(&mut store, &[])
+    };
+
+    let stdout = stdout_capture.bytes();
+    let stderr = stderr_capture.bytes();
+    let mut output_exceeded = stdout_capture.exceeded() || stderr_capture.exceeded();
+    let remaining = remaining_points(&mut store, &meter).map_err(RunError::Runtime)?;
+    let logical_time_exceeded = clock.limit_exceeded()?;
+
+    let mut code = 0;
+    let mut termination = ExecutionTermination::Exited;
+    let mut trap_message = None;
+    if let Err(error) = execution {
+        if let Some(wasi_error) = crate::wasi_error(&error) {
+            match wasi_error {
+                WasiError::Exit(exit) => {
+                    let errno: wasmer_wasix_types::wasi::Errno = (*exit).into();
+                    if errno != wasmer_wasix_types::wasi::Errno::Success {
+                        code = errno as i32;
+                    }
+                }
+                WasiError::UnknownWasiVersion => {
+                    return Err(RunError::WasiUnsupported(
+                        "unknown WASI version".to_string(),
+                    ));
+                }
+                WasiError::ThreadExit => {
+                    return Err(RunError::WasiUnsupported("thread exit".to_string()));
+                }
+                WasiError::DeepSleep(_) => {
+                    return Err(RunError::WasiUnsupported("deep sleep".to_string()));
+                }
+                WasiError::DlSymbolResolutionFailed(symbol) => {
+                    return Err(RunError::WasiUnsupported(format!(
+                        "unresolved symbol {symbol}"
+                    )));
+                }
+            }
+        } else {
+            trap_message = Some(super::canonical_trap_message(&error.to_string()));
+            termination = ExecutionTermination::Trap;
+            code = 1;
+        }
+    }
+
+    sandbox.on_exit(
+        &mut store,
+        Some(wasmer_wasix_types::wasi::Errno::Success.into()),
+    );
+    let captured_bytes = stdout.len().saturating_add(stderr.len());
+    let remaining_output = output_limit.saturating_sub(captured_bytes);
+    let (files, file_output_exceeded) =
+        read_files_bounded(&filesystem, &request.output_paths, remaining_output)?;
+    output_exceeded |= file_output_exceeded;
+
+    if project_filesystem.quota_exceeded() {
+        code = 137;
+        termination = ExecutionTermination::FilesystemLimit;
+    } else if output_exceeded {
+        code = 137;
+        termination = ExecutionTermination::OutputLimit;
+    } else if logical_time_exceeded {
+        code = 137;
+        termination = ExecutionTermination::LogicalTimeLimit;
+    } else if matches!(remaining, CostPoints::Exhausted) {
+        code = 137;
+        termination = ExecutionTermination::InstructionLimit;
+    }
+    let memory_bytes = u64::from(guest_memory.size(&store).0) * 65_536;
+    if memory_bytes > request.resources.memory_limit_bytes {
+        code = 137;
+        termination = ExecutionTermination::MemoryLimit;
+    }
+    if termination != ExecutionTermination::Trap {
+        trap_message = None;
+    }
+    let cost = match remaining {
+        CostPoints::Remaining(points) => {
+            request.resources.instruction_budget.saturating_sub(points)
+        }
+        CostPoints::Exhausted => request.resources.instruction_budget,
+    };
+    let filesystem_metrics = project_filesystem.metrics();
+    Ok(RunResult {
+        code,
+        metrics: ExecutionMetrics {
+            cost,
+            cost_model: METER_MODEL.to_string(),
+            operations: metered.operations,
+            memory_bytes,
+            logical_time_ns: clock.elapsed_ns()?,
+            filesystem_bytes: filesystem_metrics.bytes,
+            filesystem_entries: filesystem_metrics.entries,
+            stdout_bytes: stdout.len() as u64,
+            stderr_bytes: stderr.len() as u64,
+        },
+        stdout,
+        stderr,
+        files,
+        termination,
+        trap_message,
+        determinism: request.determinism,
+        resources: request.resources,
+    })
+}

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

@@ -0,0 +1,109 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+use wasm_bindgen_futures::spawn_local;
+use wasmer::Engine;
+use wasmer_wasix::runtime::task_manager::{
+    SpawnMemoryTypeOrStore, SpawnType, TaskWasm, TaskWasmRunProperties, VirtualTaskManager,
+};
+use wasmer_wasix::{PluggableRuntime, Runtime, WasiFunctionEnv, WasiThreadError};
+
+#[derive(Debug, Default)]
+pub struct WebTaskManager;
+
+impl VirtualTaskManager for WebTaskManager {
+    fn sleep_now(&self, _duration: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
+        Box::pin(async {})
+    }
+
+    fn task_shared(
+        &self,
+        task: Box<
+            dyn FnOnce() -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> + Send + 'static,
+        >,
+    ) -> Result<(), WasiThreadError> {
+        spawn_local(async move { task().await });
+        Ok(())
+    }
+
+    fn task_wasm(&self, task: TaskWasm) -> Result<(), WasiThreadError> {
+        let TaskWasm {
+            callbacks,
+            env,
+            module,
+            globals,
+            spawn_type,
+            update_layout,
+            call_initialize,
+        } = task;
+        let (memory, instance_group) = match spawn_type {
+            SpawnType::CreateMemory => (SpawnMemoryTypeOrStore::New, None),
+            SpawnType::NewLinkerInstanceGroup(group) => (SpawnMemoryTypeOrStore::New, Some(group)),
+            SpawnType::CreateMemoryOfType(ty) => (SpawnMemoryTypeOrStore::Type(ty), None),
+            SpawnType::AttachMemory(shared) => {
+                let mut store = env.runtime().new_store();
+                let memory = shared.attach(&mut store);
+                (SpawnMemoryTypeOrStore::StoreAndMemory(store, memory), None)
+            }
+        };
+        let (mut ctx, mut store) = WasiFunctionEnv::new_with_store(
+            module,
+            env,
+            globals,
+            memory,
+            update_layout,
+            call_initialize,
+            instance_group,
+        )?;
+        if let Some(trigger) = callbacks.trigger {
+            let run = callbacks.run;
+            let recycle = callbacks.recycle;
+            let pre_run = callbacks.pre_run;
+            spawn_local(async move {
+                let trigger_result = trigger().await;
+                if let Some(pre_run) = pre_run {
+                    pre_run(&mut ctx, &mut store).await;
+                }
+                run(TaskWasmRunProperties {
+                    ctx,
+                    store,
+                    trigger_result: Some(trigger_result),
+                    recycle,
+                });
+            });
+        } else {
+            spawn_local(async move {
+                if let Some(pre_run) = callbacks.pre_run {
+                    pre_run(&mut ctx, &mut store).await;
+                }
+                (callbacks.run)(TaskWasmRunProperties {
+                    ctx,
+                    store,
+                    trigger_result: None,
+                    recycle: callbacks.recycle,
+                });
+            });
+        }
+        Ok(())
+    }
+
+    fn task_dedicated(
+        &self,
+        task: Box<dyn FnOnce() + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        task();
+        Ok(())
+    }
+
+    fn thread_parallelism(&self) -> Result<usize, WasiThreadError> {
+        Ok(1)
+    }
+}
+
+pub fn runtime_with_engine(engine: Engine) -> Arc<dyn Runtime + Send + Sync> {
+    let tasks: Arc<dyn VirtualTaskManager> = Arc::new(WebTaskManager);
+    let mut runtime = PluggableRuntime::new(tasks);
+    runtime.set_engine(engine);
+    Arc::new(runtime)
+}

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

@@ -0,0 +1,268 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+use crate::RunErrorCode;
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct DeterminismConfig {
+    pub random_seed: u64,
+    pub realtime_epoch_ms: u64,
+    pub clock_step_ns: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct ResourcePolicy {
+    pub instruction_budget: u64,
+    pub logical_time_limit_ms: u64,
+    pub memory_limit_bytes: u64,
+    pub output_limit_bytes: u64,
+    pub filesystem_write_limit_bytes: u64,
+    pub filesystem_entry_limit: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct RunRequest {
+    #[serde(with = "serde_bytes")]
+    pub wasm: Vec<u8>,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: BTreeMap<String, String>,
+    #[serde(default, with = "serde_bytes")]
+    pub stdin: Vec<u8>,
+    #[serde(default)]
+    pub files: BTreeMap<String, serde_bytes::ByteBuf>,
+    #[serde(default)]
+    pub output_paths: Vec<String>,
+    pub cwd: Option<String>,
+    /// Fixed host entropy consumed before the caller-seeded stream.
+    pub startup_entropy_bytes: u64,
+    pub determinism: DeterminismConfig,
+    pub resources: ResourcePolicy,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum ExecutionTermination {
+    Exited,
+    InstructionLimit,
+    LogicalTimeLimit,
+    MemoryLimit,
+    OutputLimit,
+    FilesystemLimit,
+    Trap,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionMetrics {
+    pub cost: u64,
+    pub cost_model: String,
+    pub operations: BTreeMap<String, u64>,
+    pub memory_bytes: u64,
+    pub logical_time_ns: u64,
+    pub filesystem_bytes: u64,
+    pub filesystem_entries: u64,
+    pub stdout_bytes: u64,
+    pub stderr_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RunResult {
+    pub code: i32,
+    #[serde(with = "serde_bytes")]
+    pub stdout: Vec<u8>,
+    #[serde(with = "serde_bytes")]
+    pub stderr: Vec<u8>,
+    pub files: BTreeMap<String, serde_bytes::ByteBuf>,
+    pub termination: ExecutionTermination,
+    pub trap_message: Option<String>,
+    pub metrics: ExecutionMetrics,
+    pub determinism: DeterminismConfig,
+    pub resources: ResourcePolicy,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RunFailure {
+    pub code: RunErrorCode,
+    pub message: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RunResponse {
+    pub ok: bool,
+    pub result: Option<RunResult>,
+    pub error: Option<RunFailure>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompilerToolchainConfig {
+    #[serde(with = "serde_bytes")]
+    pub package: Vec<u8>,
+    pub memory_limit_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct CompileRequest {
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: BTreeMap<String, String>,
+    #[serde(default, with = "serde_bytes")]
+    pub stdin: Vec<u8>,
+    #[serde(default)]
+    pub files: BTreeMap<String, serde_bytes::ByteBuf>,
+    pub cwd: Option<String>,
+    #[serde(default)]
+    pub output_paths: Vec<String>,
+    pub output_limit_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CompileResult {
+    pub code: i32,
+    #[serde(with = "serde_bytes")]
+    pub stdout: Vec<u8>,
+    #[serde(with = "serde_bytes")]
+    pub stderr: Vec<u8>,
+    pub output_files: BTreeMap<String, serde_bytes::ByteBuf>,
+    pub termination: ExecutionTermination,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CompileResponse {
+    pub ok: bool,
+    pub result: Option<CompileResult>,
+    pub error: Option<RunFailure>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CompilePipelineResult {
+    pub stages: Vec<CompileResult>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CompilePipelineResponse {
+    pub ok: bool,
+    pub result: Option<CompilePipelineResult>,
+    pub error: Option<RunFailure>,
+}
+
+/// One-time immutable inputs for a browser Go compiler session.
+///
+/// `digest` is the SHA-256 of the already verified Go toolchain manifest. The
+/// manifest binds the WebC package and standard-library archive digests.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct GoCompilerSessionConfig {
+    pub digest: String,
+    pub toolchain: CompilerToolchainConfig,
+    pub standard_library_files: BTreeMap<String, serde_bytes::ByteBuf>,
+}
+
+/// A monotonic update to the mutable `/work` source snapshot.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct GoCompilerSourceDelta {
+    pub generation: u32,
+    #[serde(default)]
+    pub upsert_files: BTreeMap<String, serde_bytes::ByteBuf>,
+    #[serde(default)]
+    pub remove_paths: Vec<String>,
+}
+
+/// A compile request against an existing digest-bound browser Go session.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct GoCompilerSessionRequest {
+    pub digest: String,
+    pub source_delta: GoCompilerSourceDelta,
+    pub stages: Vec<CompileRequest>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct GoCompilerSessionResponse {
+    pub digest: String,
+    pub generation: u32,
+    pub response: CompilePipelineResponse,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct InteractiveProgram {
+    #[serde(with = "serde_bytes")]
+    pub wasm: Vec<u8>,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: BTreeMap<String, String>,
+    #[serde(default)]
+    pub files: BTreeMap<String, serde_bytes::ByteBuf>,
+    pub cwd: Option<String>,
+    pub startup_entropy_bytes: u64,
+    pub resources: ResourcePolicy,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct InteractiveRequest {
+    pub contestant: InteractiveProgram,
+    pub interactor: InteractiveProgram,
+    pub determinism: DeterminismConfig,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct InteractiveMetrics {
+    pub cost: u64,
+    pub operations: BTreeMap<String, u64>,
+    pub logical_time_ns: u64,
+    pub filesystem_bytes: u64,
+    pub filesystem_entries: u64,
+    pub protocol_bytes: u64,
+    pub stderr_bytes: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct InteractiveProcessResult {
+    pub code: i32,
+    #[serde(with = "serde_bytes")]
+    pub stderr: Vec<u8>,
+    pub termination: ExecutionTermination,
+    pub metrics: InteractiveMetrics,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct InteractiveResult {
+    pub contestant: InteractiveProcessResult,
+    pub interactor: InteractiveProcessResult,
+    #[serde(with = "serde_bytes")]
+    pub contestant_to_interactor: Vec<u8>,
+    #[serde(with = "serde_bytes")]
+    pub interactor_to_contestant: Vec<u8>,
+    pub determinism: DeterminismConfig,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct InteractiveResponse {
+    pub ok: bool,
+    pub result: Option<InteractiveResult>,
+    pub error: Option<RunFailure>,
+}

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

@@ -0,0 +1,83 @@
+use crate::{
+    GoCompilerSession as CoreGoCompilerSession, GoCompilerSessionConfig, GoCompilerSessionRequest,
+    InteractiveRequest, RunRequest, interactive_response, run_response,
+};
+use serde::Serialize;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn run_wasm_oj(request: JsValue) -> Result<JsValue, JsValue> {
+    console_error_panic_hook::set_once();
+    let request: RunRequest = serde_wasm_bindgen::from_value(request)
+        .map_err(|error| JsValue::from_str(&format!("invalid run request: {error}")))?;
+    let response = run_response(request);
+    response
+        .serialize(&serde_wasm_bindgen::Serializer::new().serialize_maps_as_objects(true))
+        .map_err(|error| JsValue::from_str(&format!("failed to serialize run response: {error}")))
+}
+
+/// Process-local browser Go compiler session. Construction transfers and
+/// hydrates the immutable package/stdlib exactly once; later calls carry only
+/// monotonic source deltas and pipeline requests.
+#[wasm_bindgen(js_name = GoCompilerSession)]
+pub struct WebGoCompilerSession {
+    inner: CoreGoCompilerSession,
+}
+
+#[wasm_bindgen(js_class = GoCompilerSession)]
+impl WebGoCompilerSession {
+    #[wasm_bindgen(constructor)]
+    pub fn new(config: JsValue) -> Result<WebGoCompilerSession, JsValue> {
+        console_error_panic_hook::set_once();
+        let config: GoCompilerSessionConfig = serde_wasm_bindgen::from_value(config)
+            .map_err(|error| JsValue::from_str(&format!("invalid Go compiler session: {error}")))?;
+        let inner = CoreGoCompilerSession::new(config)
+            .map_err(|error| JsValue::from_str(&error.to_string()))?;
+        Ok(Self { inner })
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn digest(&self) -> String {
+        self.inner.digest().to_string()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn generation(&self) -> Result<u32, JsValue> {
+        self.inner
+            .generation()
+            .map_err(|error| JsValue::from_str(&error.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = compilePipeline)]
+    pub async fn compile_pipeline(&self, request: JsValue) -> Result<JsValue, JsValue> {
+        let request: GoCompilerSessionRequest = serde_wasm_bindgen::from_value(request)
+            .map_err(|error| JsValue::from_str(&format!("invalid Go compiler request: {error}")))?;
+        let response = self
+            .inner
+            .compile_pipeline_response(request)
+            .await
+            .map_err(|error| JsValue::from_str(&error.to_string()))?;
+        response
+            .serialize(&serde_wasm_bindgen::Serializer::new().serialize_maps_as_objects(true))
+            .map_err(|error| {
+                JsValue::from_str(&format!(
+                    "failed to serialize Go compiler response: {error}"
+                ))
+            })
+    }
+}
+
+#[wasm_bindgen]
+pub async fn interact_wasm_oj(request: JsValue) -> Result<JsValue, JsValue> {
+    console_error_panic_hook::set_once();
+    let request: InteractiveRequest = serde_wasm_bindgen::from_value(request)
+        .map_err(|error| JsValue::from_str(&format!("invalid interactive request: {error}")))?;
+    let response = interactive_response(request).await;
+    response
+        .serialize(&serde_wasm_bindgen::Serializer::new().serialize_maps_as_objects(true))
+        .map_err(|error| {
+            JsValue::from_str(&format!(
+                "failed to serialize interactive response: {error}"
+            ))
+        })
+}