pub const fn baseline() -> Self {

        Self {

            fuel: false,

            profiler: ProfilerStrategy::None,

        }

    }

    pub const fn with_fuel(mut self) -> Self {

        self.fuel = true;

        self

    }

    pub const fn with_profiler(mut self, strategy: ProfilerStrategy) -> Self {

        self.profiler = strategy;

        self

    }

pub fn build_engine(opts: EngineOpts) -> Result<Engine, EngineError> {

    let mut config = Config::new();

    config.wasm_gc(true);

    config.wasm_function_references(true);

    config.wasm_exceptions(true);

    config.epoch_interruption(true);

    if opts.fuel {

        config.consume_fuel(true);

    }

    match opts.profiler {

        ProfilerStrategy::None => {}

        ProfilerStrategy::PerfMap => {

            config.profiler(wasmtime::ProfilingStrategy::PerfMap);

        }

    Engine::new(&config).map_err(|e| EngineError::Config(e.to_string()))

}

pub fn compile_module(engine: &Engine, bytes: &[u8]) -> Result<Module, EngineError> {

    Module::new(engine, bytes).map_err(|e| EngineError::Compile(e.to_string()))

}

pub fn compile_wat(engine: &Engine, source: &str) -> Result<Module, EngineError> {

    Module::new(engine, source).map_err(|e| EngineError::Compile(e.to_string()))

}

    pub fn new() -> Self {

        Self::default()

    }

    pub fn get_or_compile(&self, engine: &Engine, bytecode: &[u8]) -> Result<Module, EngineError> {

        if let Some(module) = self.lookup(bytecode)? {

            return Ok(module);

        }

        let module = compile_module(engine, bytecode)?;

        self.store(bytecode, module.clone())?;

        Ok(module)

    }

    fn lookup(&self, bytecode: &[u8]) -> Result<Option<Module>, EngineError> {

        let guard = self.inner.lock().map_err(|_| EngineError::CachePoisoned)?;

        Ok(guard.get(bytecode).cloned())

    }

    fn store(&self, bytecode: &[u8], module: Module) -> Result<(), EngineError> {

        let mut guard = self.inner.lock().map_err(|_| EngineError::CachePoisoned)?;

        guard.insert(bytecode.to_vec(), module);

        Ok(())

    }

    pub fn is_empty(&self) -> Result<bool, EngineError> {

        let guard = self.inner.lock().map_err(|_| EngineError::CachePoisoned)?;

        Ok(guard.is_empty())

    }

    pub fn len(&self) -> Result<usize, EngineError> {

        let guard = self.inner.lock().map_err(|_| EngineError::CachePoisoned)?;

        Ok(guard.len())

    }

pub fn classify_runtime_error(err: &wasmtime::Error) -> EngineError {

    if let Some(trap) = err.downcast_ref::<wasmtime::Trap>() {

        match *trap {

            wasmtime::Trap::OutOfFuel => return EngineError::OutOfFuel,

            wasmtime::Trap::Interrupt => return EngineError::EpochInterrupt,

    }

    let mut combined = err.to_string();

    for cause in err.chain().skip(1) {

        combined.push_str(": ");

        combined.push_str(&cause.to_string());

    }

    if let Some(raised) = parse_nomi_raise_marker(err) {

        return raised;

    }

    if combined.contains("convert-commodity: no Price row")

        || combined.contains("convert-commodity: inverse price has zero numerator")

        return EngineError::NoConversion(combined);

    }

    EngineError::Trap(combined)

}

fn parse_nomi_raise_marker(err: &wasmtime::Error) -> Option<EngineError> {

    err.chain()

        .map(|cause| cause.to_string())

        .find_map(|cause_str| split_marker(&cause_str))

}

fn split_marker(text: &str) -> Option<EngineError> {

    let rest = text.strip_prefix(NOMI_RAISE_MARKER)?;

    let (code, message) = rest.split_once(':')?;

    Some(EngineError::ScriptRaised {

        code: code.to_string(),

        message: message.to_string(),

    })

}

pub fn err_code_and_message(err: &EngineError) -> (String, String) {

    match err {

        EngineError::ScriptRaised { code, message } => (code.clone(), message.clone()),

        EngineError::NoConversion(msg) => ("no-conversion".to_string(), msg.clone()),

        EngineError::Trap(msg) => ("runtime".to_string(), msg.clone()),

        EngineError::Compile(msg) => ("compile".to_string(), msg.clone()),

        EngineError::OutOfFuel => ("runtime".to_string(), "fuel exhausted".to_string()),

}

pub async fn alloc_commodity_ref<T>(

    caller: &mut Caller<'_, T>,

    numer: i64,

    denom: i64,

    commodity_id: Uuid,

) -> wasmtime::Result<Rooted<StructRef>>

where

    T: Send,

{

    let commodity_new = caller

        .get_export("commodity_new")

        .and_then(|e| e.into_func())

        .ok_or_else(|| {

            wasmtime::Error::msg(

        })?;

    let (hi, lo) = commodity_id.as_u64_pair();

    let mut results = [Val::AnyRef(None)];

    commodity_new

        .call_async(

            caller.as_context_mut(),

            &[

                Val::I64(numer),

                Val::I64(denom),

                Val::I64(hi as i64),

                Val::I64(lo as i64),

            ],

            &mut results,

        )

        .await?;

    match &results[0] {

        Val::AnyRef(Some(any)) => any.checked_struct(caller.as_context_mut()),

}

pub fn alloc_string_ref<T>(

    caller: &mut Caller<'_, T>,

    bytes: &[u8],

) -> wasmtime::Result<Rooted<wasmtime::ArrayRef>> {

    let engine = caller.engine().clone();

    let ty = wasmtime::ArrayType::new(&engine, FieldType::new(Mutability::Var, StorageType::I8));

    let pre = wasmtime::ArrayRefPre::new(caller.as_context_mut(), ty);

    let vals: Vec<Val> = bytes.iter().map(|b| Val::I32(i32::from(*b))).collect();

    wasmtime::ArrayRef::new_fixed(caller.as_context_mut(), &pre, &vals)

}

pub fn alloc_ratio_ref<T>(

    caller: &mut Caller<'_, T>,

    numer: i64,

    denom: i64,

) -> wasmtime::Result<Rooted<StructRef>> {

    let engine = caller.engine().clone();

    let ty = StructType::new(

        &engine,

        std::iter::repeat_n(

            FieldType::new(Mutability::Const, StorageType::ValType(ValType::I64)),

    let pre = StructRefPre::new(caller.as_context_mut(), ty);

    StructRef::new(

        caller.as_context_mut(),

        &pre,

        &[Val::I64(numer), Val::I64(denom)],

}

pub async fn alloc_entity_via_export<T>(

    caller: &mut Caller<'_, T>,

    export_name: &str,

    args: &[Val],

) -> wasmtime::Result<Rooted<StructRef>>

where

    T: Send,

{

    let alloc = caller

        .get_export(export_name)

        .and_then(|e| e.into_func())

        .ok_or_else(|| {

    let mut results = [Val::AnyRef(None)];

    alloc

        .call_async(caller.as_context_mut(), args, &mut results)

        .await?;

    let new_entity_any = match &results[0] {

        Val::AnyRef(any) => *any,

    new_entity_any

        .ok_or_else(|| {

        .checked_struct(caller.as_context_mut())

}

pub fn read_string_arg<T>(

    caller: &mut Caller<'_, T>,

    arg: Option<Rooted<wasmtime::ArrayRef>>,

) -> wasmtime::Result<Option<String>> {

    let Some(arr) = arg else {

    let len = arr.len(caller.as_context_mut())?;

    let mut bytes = Vec::with_capacity(len as usize);

    for i in 0..len {

        let val = arr.get(caller.as_context_mut(), i)?;

        let byte_i32 = val

            .i32()

            .ok_or_else(|| wasmtime::Error::msg("string arg element is not i32"))?;

        bytes.push(byte_i32 as u8);

    String::from_utf8(bytes)

        .map(Some)

        .map_err(|err| wasmtime::Error::msg(format!("string arg is not valid UTF-8: {err}")))

}

pub fn read_commodity_arg<T>(

    caller: &mut Caller<'_, T>,

    arg: Option<Rooted<StructRef>>,

) -> wasmtime::Result<Option<(i64, i64, Uuid)>> {

    let Some(s) = arg else {

    let read_i64 = |c: &mut Caller<'_, T>, idx: usize| -> wasmtime::Result<i64> {

        let v = s.field(c.as_context_mut(), idx)?;

        v.i64()

            .ok_or_else(|| wasmtime::Error::msg(format!("commodity field {idx} is not i64")))

    };

    let numer = read_i64(caller, 0)?;

    let denom = read_i64(caller, 1)?;

    let hi = read_i64(caller, 2)?;

    let lo = read_i64(caller, 3)?;

    let raw = ((hi as u64 as u128) << 64) | (lo as u64 as u128);

    Ok(Some((numer, denom, Uuid::from_u128(raw))))

}

pub fn read_ratio_arg<T>(

    caller: &mut Caller<'_, T>,

    arg: Option<Rooted<StructRef>>,

) -> wasmtime::Result<Option<(i64, i64)>> {

    let Some(s) = arg else {

    let numer = s

        .field(caller.as_context_mut(), 0)?

        .i64()

        .ok_or_else(|| wasmtime::Error::msg("ratio field 0 (numer) is not i64"))?;

    let denom = s

        .field(caller.as_context_mut(), 1)?

        .i64()

        .ok_or_else(|| wasmtime::Error::msg("ratio field 1 (denom) is not i64"))?;

    if denom == 0 {

    }

    Ok(Some((numer, denom)))

}

pub fn read_entity_string_field<T>(

    caller: &mut Caller<'_, T>,

    arg: Option<Rooted<StructRef>>,

    kind: nomiscript::EntityKind,

    field_name: &str,

) -> wasmtime::Result<Option<String>> {

    let Some(s) = arg else {

        return Ok(None);

    read_entity_string_field_ctx(caller.as_context_mut(), s, kind, field_name).map(Some)

}

pub fn read_entity_string_field_ctx(

    mut store: impl AsContextMut,

    entity: Rooted<StructRef>,

    kind: nomiscript::EntityKind,

    field_name: &str,

) -> wasmtime::Result<String> {

    let layout = nomiscript::entity_layout(kind)

        .ok_or_else(|| wasmtime::Error::msg(format!("no entity layout for {kind:?}")))?;

    let idx = layout

        .fields

        .iter()

        .position(|f| f.name == field_name && f.kind == nomiscript::EntityFieldKind::String)

        .ok_or_else(|| {

            wasmtime::Error::msg(format!(

        })?;

    let arr = match entity.field(store.as_context_mut(), idx)? {

        Val::AnyRef(Some(any)) => any.checked_array(store.as_context_mut())?,

    let len = arr.len(store.as_context_mut())?;

    let mut bytes = Vec::with_capacity(len as usize);

    for i in 0..len {

        let byte = arr

            .get(store.as_context_mut(), i)?

            .i32()

            .ok_or_else(|| wasmtime::Error::msg("entity string element is not i32"))?;

        bytes.push(byte as u8);

    String::from_utf8(bytes)

        .map_err(|err| wasmtime::Error::msg(format!("entity string field not utf-8: {err}")))

}

pub async fn alloc_pair_chain<T>(

    caller: &mut Caller<'_, T>,

    items: impl IntoIterator<Item = Rooted<AnyRef>>,

) -> wasmtime::Result<Option<Rooted<StructRef>>>

where

    T: Send,

{

    let pair_new = caller

        .get_export("pair_new")

        .and_then(|e| e.into_func())

        .ok_or_else(|| {

            wasmtime::Error::msg(

        })?;

    let items: Vec<Rooted<AnyRef>> = items.into_iter().collect();

    let mut head: Option<Rooted<StructRef>> = None;

    for item in items.into_iter().rev() {

        let cdr_any = head.map(|p| p.to_anyref());

        let mut results = [Val::AnyRef(None)];

        pair_new

            .call_async(

                caller.as_context_mut(),

                &[Val::AnyRef(Some(item)), Val::AnyRef(cdr_any)],

                &mut results,

            )

            .await?;

        let new_pair_any = match &results[0] {

            Val::AnyRef(any) => *any,

            new_pair_any

                .ok_or_else(|| {

                .checked_struct(caller.as_context_mut())?,

    Ok(head)

}

pub fn call_i64_export<T>(

    engine: &Engine,

    store: &mut Store<T>,

    module: &Module,

    export: &str,

) -> Result<i64, EngineError> {

    let linker = Linker::<T>::new(engine);

    let instance = linker

        .instantiate(&mut *store, module)

        .map_err(|e| classify_runtime_error(&e))?;

    let func = instance

        .get_typed_func::<(), i64>(&mut *store, export)

        .map_err(|_| EngineError::MissingExport(export.to_string()))?;

    func.call(&mut *store, ())

        .map_err(|e| classify_runtime_error(&e))

}

    fn from(value: EvalValue) -> Self {

        match value {

            EvalValue::Nil => nomiscript::Value::Nil,

            EvalValue::T => nomiscript::Value::T,

            EvalValue::I32(n) => {

                nomiscript::Value::Number(nomiscript::Fraction::from_integer(i64::from(n)))

            EvalValue::Ratio { numer, denom } => {

                nomiscript::Value::Number(nomiscript::Fraction::new(numer, denom))

                numer,

                denom,

                commodity_hi,

                commodity_lo,

                let raw = ((commodity_hi as u64 as u128) << 64) | (commodity_lo as u64 as u128);

                nomiscript::Value::Commodity {

                    amount: nomiscript::Fraction::new(numer, denom),

                    commodity_id: uuid::Uuid::from_u128(raw),

                }

            EvalValue::String(s) => nomiscript::Value::String(s),

    }

pub fn decode_eval_result(

    mut store: impl AsContextMut,

    value: Option<Rooted<AnyRef>>,

    result_ty: Option<nomiscript::WasmType>,

) -> wasmtime::Result<EvalValue> {

    let Some(ty) = result_ty else {

        return Ok(EvalValue::Nil);

    let Some(any) = value else {

        return match ty {

            _ => Ok(EvalValue::Nil),

    decode_anyref(&mut store, any, ty)

}

fn decode_index(mut store: impl AsContextMut, any: &Rooted<AnyRef>) -> wasmtime::Result<EvalValue> {

    let numer = any

        .checked_struct(&mut store)?

        .field(&mut store, 0)?

        .i64()

        .ok_or_else(|| wasmtime::Error::msg("index result field 0 (numer) is not i64"))?;

    i32::try_from(numer)

        .map(EvalValue::I32)

        .map_err(|_| wasmtime::Error::msg(format!("index result {numer} exceeds i32")))

}

fn decode_anyref(

    mut store: impl AsContextMut,

    any: Rooted<AnyRef>,

    ty: nomiscript::WasmType,

) -> wasmtime::Result<EvalValue> {

    match ty {

        WasmType::I32 => decode_index(&mut store, &any),

            let i31 = any.checked_i31(&mut store)?;

            if i31.get_i32() == 0 {

                Ok(EvalValue::T)

            let s = any.checked_struct(&mut store)?;

            let numer = s

                .field(&mut store, 0)?

                .i64()

                .ok_or_else(|| wasmtime::Error::msg("ratio field 0 (numer) is not i64"))?;

            let denom = s

                .field(&mut store, 1)?

                .i64()

                .ok_or_else(|| wasmtime::Error::msg("ratio field 1 (denom) is not i64"))?;

            Ok(EvalValue::Ratio { numer, denom })

            let s = any.checked_struct(&mut store)?;

            let numer = s.field(&mut store, 0)?.i64().unwrap_or(0);

            let denom = s.field(&mut store, 1)?.i64().unwrap_or(1);

            match s.field(&mut store, 4)? {

                    let hi = s.field(&mut store, 2)?.i64().unwrap_or(0);

                    let lo = s.field(&mut store, 3)?.i64().unwrap_or(0);

                    Ok(EvalValue::Commodity {

                        numer,

                        denom,

                        commodity_hi: hi,

                        commodity_lo: lo,

                    })

                Val::AnyRef(Some(term)) => {

                    let arr = term.checked_array(&mut store)?;

                    if arr.len(&mut store)? == 0 {

                        Ok(EvalValue::Ratio { numer, denom })

                        Err(wasmtime::Error::msg(

                            "compound commodity (e.g. money × money) has no host \

                             representation yet",

                        ))

            let arr = any.checked_array(&mut store)?;

            let len = arr.len(&mut store)?;

            let mut bytes = Vec::with_capacity(len as usize);

            for i in 0..len {

                let v = arr.get(&mut store, i)?;

                let byte = v

                    .i32()

                    .ok_or_else(|| wasmtime::Error::msg("string element is not i32"))?;

                bytes.push(byte as u8);

            let s = String::from_utf8(bytes)

                .map_err(|err| wasmtime::Error::msg(format!("not valid utf-8: {err}")))?;

            Ok(EvalValue::String(s))

        WasmType::PairRef(elem) => {

            let head = render_pair_as_string(&mut store, any, elem)?;

            Ok(EvalValue::String(head))

        WasmType::EntityRef(kind) => {

            let entity = any.checked_struct(&mut store)?;

            Ok(EvalValue::String(render_entity(&mut store, entity, kind)?))

            let _ = any;

            Ok(EvalValue::String("<anyref>".into()))

}

fn render_pair_as_string(

    mut store: impl AsContextMut,

    head_any: Rooted<AnyRef>,

    elem: nomiscript::PairElement,

) -> wasmtime::Result<String> {

    let mut out = String::from("(");

    let mut cur: Option<Rooted<StructRef>> = Some(head_any.checked_struct(&mut store)?);

    let mut first = true;

    while let Some(node) = cur {

        if !first {

            out.push(' ');

        }

        first = false;

        let car_val = node.field(&mut store, 0)?;

        let car_any = match car_val {

            Val::AnyRef(Some(a)) => a,

                out.push_str("nil");

                let cdr_val = node.field(&mut store, 1)?;

                cur = match cdr_val {

                    Val::AnyRef(Some(a)) => Some(a.checked_struct(&mut store)?),

                    _ => None,

                continue;

        let car_str = render_car(&mut store, car_any, elem)?;

        out.push_str(&car_str);

        let cdr_val = node.field(&mut store, 1)?;

        cur = match cdr_val {

            Val::AnyRef(Some(a)) => Some(a.checked_struct(&mut store)?),

            _ => None,

    out.push(')');

    Ok(out)

}

fn render_car(

    mut store: impl AsContextMut,

    car_any: Rooted<AnyRef>,

    elem: nomiscript::PairElement,

) -> wasmtime::Result<String> {

    match elem {

            let i31 = car_any.checked_i31(&mut store)?;

            Ok(i31.get_i32().to_string())

            let i31 = car_any.checked_i31(&mut store)?;

            Ok(if i31.get_i32() == 0 { "nil" } else { "t" }.to_string())

            let s = car_any.checked_struct(&mut store)?;

            let n = s.field(&mut store, 0)?.i64().unwrap_or(0);

            let d = s.field(&mut store, 1)?.i64().unwrap_or(1);

            if d == 1 {

                Ok(n.to_string())

                Ok(format!("{n}/{d}"))

            let s = car_any.checked_struct(&mut store)?;

            let n = s.field(&mut store, 0)?.i64().unwrap_or(0);

            let d = s.field(&mut store, 1)?.i64().unwrap_or(1);

            match s.field(&mut store, 4)? {

                    let hi = s.field(&mut store, 2)?.i64().unwrap_or(0);

                    let lo = s.field(&mut store, 3)?.i64().unwrap_or(0);

                    let raw = ((hi as u64 as u128) << 64) | (lo as u64 as u128);

                    let id = Uuid::from_u128(raw);

                    if d == 1 {

                        Ok(format!("(:commodity {n} :id \"{id}\")"))

                Val::AnyRef(Some(term)) => {

                    let arr = term.checked_array(&mut store)?;

                    if arr.len(&mut store)? == 0 {

                        Err(wasmtime::Error::msg(

                            "compound commodity (e.g. money × money) has no host \

                             representation yet",

                        ))

            let arr = car_any.checked_array(&mut store)?;

            let len = arr.len(&mut store)?;

            let mut bytes = Vec::with_capacity(len as usize);

            for i in 0..len {

                let v = arr.get(&mut store, i)?;

                bytes.push(v.i32().unwrap_or(0) as u8);

            let s = String::from_utf8(bytes).unwrap_or_else(|_| "<invalid-utf8>".into());

            Ok(nomiscript::format_value(&nomiscript::Value::String(s)))

        PairElement::Entity(kind) => {

            let entity = car_any.checked_struct(&mut store)?;

            render_entity(&mut store, entity, kind)

        PairElement::AnyRef => Ok("<anyref>".into()),

}

fn render_entity(

    mut store: impl AsContextMut,

    entity: Rooted<StructRef>,

    kind: nomiscript::EntityKind,

) -> wasmtime::Result<String> {

    let Some(layout) = nomiscript::entity_layout(kind) else {

    let mut out = format!("(:{}", layout.label);

    for (slot, field) in layout.fields.iter().enumerate() {

        let rendered = match field.kind {

            EntityFieldKind::String => read_string_slot(&mut store, entity, slot)?,

        out.push_str(&format!(" :{} {rendered}", field.name));

    out.push(')');

    Ok(out)

}

fn read_string_slot(

    mut store: impl AsContextMut,

    entity: Rooted<StructRef>,

    slot: usize,

) -> wasmtime::Result<String> {

    match entity.field(&mut store, slot)? {

        Val::AnyRef(Some(a)) => {

            let arr = a.checked_array(&mut store)?;

            let len = arr.len(&mut store)?;

            let mut bytes = Vec::with_capacity(len as usize);

            for i in 0..len {

                bytes.push(arr.get(&mut store, i)?.i32().unwrap_or(0) as u8);

            let s = String::from_utf8(bytes).unwrap_or_else(|_| "<invalid-utf8>".into());

            Ok(nomiscript::format_value(&nomiscript::Value::String(s)))

        _ => Ok("\"\"".to_string()),

}