fn default_engine() -> Engine {

    build_engine(EngineOpts::baseline()).expect("WASM engine config rejected")

}

    pub fn new() -> Self {

        Self {

            host: WasmHost::new(default_engine(), SymbolTable::new()),

        }

    }

    pub fn with_engine(engine: Engine) -> Self {

        Self {

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

        }

    }

    fn get_or_compile_module(&self, bytecode: &[u8]) -> Result<Module, HookError> {

        self.host

            .module_cache()

            .get_or_compile(self.host.engine(), bytecode)

            .map_err(HookError::from)

    }

    pub fn execute(

        &self,

        bytecode: &[u8],

        input: &[u8],

        output_size: Option<u32>,

    ) -> Result<Vec<ParsedEntity>, HookError> {

        debug!(bytecode_size = bytecode.len(), "script execution start");

        let output_size = output_size.unwrap_or(DEFAULT_OUTPUT_SIZE);

        let module = self.get_or_compile_module(bytecode)?;

        debug!("module compiled");

        let header = GlobalHeader::from_bytes(input)

            .ok_or_else(|| HookError::Parse("Invalid input header".to_string()))?;

        let input_offset = BASE_OFFSET;

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

        let strings_offset = header.strings_pool_offset;

        let exec_state = self

            .host

            .execution_state(input_offset, output_offset, strings_offset);

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

        store.set_epoch_deadline(EPOCH_DEADLINE_TICKS);

        let engine = self.host.engine().clone();

        let ticker = std::thread::spawn(move || {

            for _ in 0..EPOCH_DEADLINE_TICKS {

                std::thread::sleep(EPOCH_TICK_INTERVAL);

                engine.increment_epoch();

            }

        });

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

        define_host_functions(&mut linker)?;

        let instance = linker.instantiate(&mut store, &module)?;

        let memory = instance

            .get_memory(&mut store, "memory")

            .ok_or(HookError::WASMMem)?;

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

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

        let required_pages = (BASE_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 {

        }

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

        let input_start = BASE_OFFSET as usize;

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

        let output_start = output_offset as usize;

        let input_entity_count = header.input_entity_count;

        let output_header = OutputHeader::new(input_entity_count);

        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| HookError::Script(format!("Missing should_apply export: {e}")))?;

        let result = should_apply.call(&mut store, ())?;

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

        if result == 0 {

            drop(ticker);

            return Ok(Vec::new());

        }

        let process = instance

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

            .map_err(|e| HookError::Script(format!("Missing process export: {e}")))?;

        debug!("calling process");

        let call_result = process.call(&mut store, ());

        drop(ticker);

        call_result?;

        let mem_data = memory.data(&store);

        let output_data = &mem_data[output_start..output_start + output_size as usize];

        let output_header = OutputHeader::from_bytes(output_data)

            .ok_or_else(|| HookError::Parse("Invalid output header".to_string()))?;

        let output_strings_offset = { output_header.strings_offset } as usize;

        let parser = OutputParser::new(output_data, output_strings_offset)?;

        let entities: Result<Vec<ParsedEntity>, HookError> = parser.entities().collect();

        debug!(

            entity_count = entities.as_ref().map_or(0, std::vec::Vec::len),

        entities

    }

    fn test_executor_creation() {

        let executor = ScriptExecutor::new();

        assert!(

            executor

                .host

                .module_cache()

                .is_empty()

                .expect("cache lock must not be poisoned in fresh executor")

    }