pub fn new(debug_mode: bool) -> anyhow::Result<Self> {

        let mut config = Config::new();

        config.wasm_gc(true);

        let engine = Engine::new(&config)?;

        let mut symbols = SymbolTable::with_builtins();

        symbols.define(

            Symbol::new("REVISION", SymbolKind::Variable)

                .with_value(Expr::String(GIT_REVISION.to_string())),

        let default_filter = if debug_mode { "debug" } else { "warn" };

        let filter =

            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(default_filter));

        let (filter_layer, reload_handle) = reload::Layer::new(filter);

        tracing_subscriber::registry()

            .with(filter_layer)

            .with(tracing_subscriber::fmt::layer().with_writer(std::io::stderr))

            .try_init()

            .ok();

        let mut interp = Self {

            host: WasmHost::new(engine, symbols),

            compiler: Compiler::new(),

            reload_handle,

        };

        interp.load_stdlib()?;

        Ok(interp)

    }

    fn load_stdlib(&mut self) -> Result<()> {

        let program = Reader::parse(STDLIB)?;

        let mut symbols = self

            .host

            .symbol_table()

            .write()

            .map_err(|e| Error::Runtime(format!("failed to write symbol table: {e}")))?;

        self.compiler.compile(&program, &mut symbols)?;

        Ok(())

    }

    pub fn eval(&mut self, input: &str) -> Result<Vec<Value>> {

        let program = Reader::parse(input)?;

        let debug_mode = program.annotations.iter().any(|a| a.name == "debug");

        if debug_mode {

        }

        let result = self.eval_program(&program);

        if debug_mode {

        }

        result

    }

    fn eval_program(&mut self, program: &Program) -> Result<Vec<Value>> {

        if program.exprs.is_empty() {

            return Ok(vec![]);

        }

        let wasm = {

            let mut symbols = self

                .host

                .symbol_table()

                .write()

                .map_err(|e| Error::Runtime(format!("failed to write symbol table: {e}")))?;

            self.compiler.compile(program, &mut symbols)?

        let value = self.run_wasm(&wasm)?;

        Ok(vec![value])

    }

    pub fn compile_to_wasm(&mut self, input: &str) -> Result<Vec<u8>> {

        let program = Reader::parse(input)?;

        if program.exprs.is_empty() {

        }

        let mut symbols = self

            .host

            .symbol_table()

            .write()

            .map_err(|e| Error::Runtime(format!("failed to write symbol table: {e}")))?;

        Ok(self.compiler.compile(&program, &mut symbols)?)

    }

    pub fn run_wasm(&self, wasm: &[u8]) -> Result<Value> {

        debug!(wasm_size = wasm.len(), "creating WASM module");

        let module =

            Module::new(self.host.engine(), wasm).map_err(|e| Error::Runtime(e.to_string()))?;

        let output_size = DEFAULT_OUTPUT_SIZE;

        let input = build_minimal_input(output_size);

        let input_offset = scripting_format::BASE_OFFSET;

        let output_offset = input_offset + input.len() as u32;

        let strings_offset = {

            let header = GlobalHeader::from_bytes(&input).expect("minimal input must be valid");

            header.strings_pool_offset

        debug!(

        let exec_state = self

            .host

            .execution_state(input_offset, output_offset, strings_offset);

        let mut store = Store::new(self.host.engine(), exec_state);

        let mut linker = Linker::new(self.host.engine());

        define_host_functions(&mut linker).map_err(|e| Error::Runtime(e.to_string()))?;

        let instance = linker

            .instantiate(&mut store, &module)

            .map_err(|e| Error::Runtime(e.to_string()))?;

        let memory = instance

            .get_memory(&mut store, "memory")

            .ok_or_else(|| Error::Runtime("no memory export".to_string()))?;

        store.data_mut().memory = Some(memory);

        let total_size = input.len() + output_size as usize;

        let required_pages = (input_offset as usize + total_size).div_ceil(WASM_PAGE_SIZE as usize);

        let current_pages = memory.size(&store) as usize;

        if required_pages > current_pages {

            debug!(current_pages, required_pages, "growing memory");

            memory

                .grow(&mut store, (required_pages - current_pages) as u64)

                .map_err(|e| Error::Runtime(e.to_string()))?;

        let mem_data = memory.data_mut(&mut store);

        let input_start = input_offset as usize;

        mem_data[input_start..input_start + input.len()].copy_from_slice(&input);

        let output_start = output_offset as usize;

        let output_header = OutputHeader::new(0);

        mem_data[output_start..output_start + OUTPUT_HEADER_SIZE]

            .copy_from_slice(&output_header.to_bytes());

        let should_apply = instance

            .get_typed_func::<(), i32>(&mut store, "should_apply")

            .map_err(|e| Error::Runtime(e.to_string()))?;

        debug!("calling should_apply");

        let apply = should_apply

            .call(&mut store, ())

            .map_err(|e| Error::Runtime(e.to_string()))?;

        debug!(result = apply, "should_apply returned");

        if apply != 1 {

        }

        let process = instance

            .get_typed_func::<(), ()>(&mut store, "process")

            .map_err(|e| Error::Runtime(e.to_string()))?;

        debug!("calling process");

        process

            .call(&mut store, ())

            .map_err(|e| Error::Runtime(e.to_string()))?;

        let mem_data = memory.data(&store);

        let output_data = &mem_data[output_start..];

        let result = decode_result(output_data);

        debug!("result decoded");

        result

    }

fn build_minimal_input(output_size: u32) -> Vec<u8> {

    let mut ser = MemorySerializer::new();

    ser.set_context(ContextType::BatchProcess, EntityType::Transaction);

    ser.finalize(output_size)

}

fn decode_result(data: &[u8]) -> Result<Value> {

    let output_header = OutputHeader::from_bytes(data)

        .ok_or_else(|| Error::Runtime("invalid output header".to_string()))?;

    if output_header.output_entity_count == 0 {

    }

    let entity_header = scripting_format::EntityHeader::from_bytes(&data[OUTPUT_HEADER_SIZE..])

        .ok_or_else(|| Error::Runtime("invalid entity header".to_string()))?;

    let data_offset = entity_header.data_offset as usize;

    let value_data = DebugValueData::from_bytes(&data[data_offset..])

        .ok_or_else(|| Error::Runtime("invalid debug value data".to_string()))?;

    let value_type = ValueType::try_from(value_data.value_type)

        .map_err(|()| Error::Runtime("unknown value type".to_string()))?;

    match value_type {

        ValueType::Nil => Ok(Value::Nil),

        ValueType::Bool => Ok(Value::Bool(value_data.data1 != 0)),

        ValueType::Number => Ok(Value::Number(Fraction::new(

            value_data.data1,

            value_data.data2,

        ))),

            let pool_offset = value_data.data1 as usize;

            let len = value_data.data2 as usize;

            let strings_offset = output_header.strings_offset as usize;

            let start = strings_offset + pool_offset;

            let end = start + len;

            if end > data.len() {

            }

            let s = std::str::from_utf8(&data[start..end])

                .map_err(|_| Error::Runtime("invalid UTF-8 in string".to_string()))?;

            if value_type == ValueType::Symbol {

                Ok(Value::Symbol(s.to_string()))

                Ok(Value::String(s.to_string()))

}