numcodecs_wasm_host_reproducible/
engine.rs

1use wasm_runtime_layer::{
2    backend::{
3        AsContext, AsContextMut, Export, Extern, Imports, Value, WasmEngine, WasmExternRef,
4        WasmFunc, WasmGlobal, WasmInstance, WasmMemory, WasmModule, WasmStore, WasmStoreContext,
5        WasmStoreContextMut, WasmTable,
6    },
7    ExportType, ExternType, FuncType, GlobalType, ImportType, MemoryType, TableType,
8};
9
10use crate::transform::{
11    instcnt::{InstructionCounterInjecter, PerfWitInterfaces},
12    nan::NaNCanonicaliser,
13};
14
15#[derive(Clone)]
16#[repr(transparent)]
17pub struct ReproducibleEngine<E: WasmEngine>(E);
18
19impl<E: WasmEngine> WasmEngine for ReproducibleEngine<E> {
20    type ExternRef = ReproducibleExternRef<E>;
21    type Func = ReproducibleFunc<E>;
22    type Global = ReproducibleGlobal<E>;
23    type Instance = ReproducibleInstance<E>;
24    type Memory = ReproducibleMemory<E>;
25    type Module = ReproducibleModule<E>;
26    type Store<T> = ReproducibleStore<T, E>;
27    type StoreContext<'a, T: 'a> = ReproducibleStoreContext<'a, T, E>;
28    type StoreContextMut<'a, T: 'a> = ReproducibleStoreContextMut<'a, T, E>;
29    type Table = ReproducibleTable<E>;
30}
31
32impl<E: WasmEngine> ReproducibleEngine<E> {
33    pub const fn new(engine: E) -> Self {
34        Self(engine)
35    }
36
37    const fn as_ref(&self) -> &E {
38        &self.0
39    }
40
41    const fn from_ref(engine: &E) -> &Self {
42        // Safety: Self is a transparent newtype around E
43        #[expect(unsafe_code)]
44        unsafe {
45            &*std::ptr::from_ref(engine).cast()
46        }
47    }
48}
49
50#[derive(Clone)]
51#[repr(transparent)]
52pub struct ReproducibleExternRef<E: WasmEngine>(E::ExternRef);
53
54impl<E: WasmEngine> WasmExternRef<ReproducibleEngine<E>> for ReproducibleExternRef<E> {
55    fn new<T: 'static + Send + Sync>(
56        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
57        object: T,
58    ) -> Self {
59        Self(<E::ExternRef as WasmExternRef<E>>::new(
60            ctx.as_context_mut().as_inner_context_mut(),
61            object,
62        ))
63    }
64
65    fn downcast<'a, 's: 'a, T: 'static, S: 'a>(
66        &'a self,
67        store: ReproducibleStoreContext<'s, S, E>,
68    ) -> anyhow::Result<&'a T> {
69        WasmExternRef::downcast(&self.0, store.0)
70    }
71}
72
73#[derive(Clone)]
74#[repr(transparent)]
75pub struct ReproducibleFunc<E: WasmEngine>(E::Func);
76
77impl<E: WasmEngine> WasmFunc<ReproducibleEngine<E>> for ReproducibleFunc<E> {
78    fn new<T>(
79        mut ctx: impl AsContextMut<ReproducibleEngine<E>, UserState = T>,
80        ty: FuncType,
81        func: impl 'static
82            + Send
83            + Sync
84            + Fn(
85                ReproducibleStoreContextMut<T, E>,
86                &[Value<ReproducibleEngine<E>>],
87                &mut [Value<ReproducibleEngine<E>>],
88            ) -> anyhow::Result<()>,
89    ) -> Self {
90        Self(<E::Func as WasmFunc<E>>::new(
91            ctx.as_context_mut().as_inner_context_mut(),
92            ty,
93            move |ctx, args, results| {
94                func(
95                    ReproducibleStoreContextMut(ctx),
96                    from_values(args),
97                    from_values_mut(results),
98                )
99            },
100        ))
101    }
102
103    fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> FuncType {
104        WasmFunc::ty(&self.0, ctx.as_context().as_inner_context())
105    }
106
107    fn call<T>(
108        &self,
109        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
110        args: &[Value<ReproducibleEngine<E>>],
111        results: &mut [Value<ReproducibleEngine<E>>],
112    ) -> anyhow::Result<()> {
113        WasmFunc::call::<T>(
114            &self.0,
115            ctx.as_context_mut().as_inner_context_mut(),
116            as_values(args),
117            as_values_mut(results),
118        )
119    }
120}
121
122#[derive(Clone)]
123#[repr(transparent)]
124pub struct ReproducibleGlobal<E: WasmEngine>(E::Global);
125
126impl<E: WasmEngine> WasmGlobal<ReproducibleEngine<E>> for ReproducibleGlobal<E> {
127    fn new(
128        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
129        value: Value<ReproducibleEngine<E>>,
130        mutable: bool,
131    ) -> Self {
132        Self(<E::Global as WasmGlobal<E>>::new(
133            ctx.as_context_mut().as_inner_context_mut(),
134            into_value(value),
135            mutable,
136        ))
137    }
138
139    fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> GlobalType {
140        WasmGlobal::ty(&self.0, ctx.as_context().as_inner_context())
141    }
142
143    fn set(
144        &self,
145        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
146        new_value: Value<ReproducibleEngine<E>>,
147    ) -> anyhow::Result<()> {
148        WasmGlobal::set(
149            &self.0,
150            ctx.as_context_mut().as_inner_context_mut(),
151            into_value(new_value),
152        )
153    }
154
155    fn get(
156        &self,
157        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
158    ) -> Value<ReproducibleEngine<E>> {
159        from_value(WasmGlobal::get(
160            &self.0,
161            ctx.as_context_mut().as_inner_context_mut(),
162        ))
163    }
164}
165
166#[derive(Clone)]
167#[repr(transparent)]
168pub struct ReproducibleInstance<E: WasmEngine>(E::Instance);
169
170impl<E: WasmEngine> WasmInstance<ReproducibleEngine<E>> for ReproducibleInstance<E> {
171    fn new(
172        mut store: impl AsContextMut<ReproducibleEngine<E>>,
173        module: &ReproducibleModule<E>,
174        imports: &Imports<ReproducibleEngine<E>>,
175    ) -> anyhow::Result<Self> {
176        let mut new_imports = Imports::new();
177        new_imports.extend(
178            imports
179                .into_iter()
180                .map(|((module, name), value)| ((module, name), into_extern(value))),
181        );
182
183        let PerfWitInterfaces {
184            perf: perf_interface,
185            instruction_counter,
186        } = PerfWitInterfaces::get();
187        new_imports.define(
188            &format!("{perf_interface}"),
189            instruction_counter,
190            Extern::Global(
191                store
192                    .as_context_mut()
193                    .get_instruction_counter_global()
194                    .0
195                    .clone(),
196            ),
197        );
198
199        Ok(Self(<E::Instance as WasmInstance<E>>::new(
200            store.as_context_mut().as_inner_context_mut(),
201            &module.0,
202            &new_imports,
203        )?))
204    }
205
206    fn exports(
207        &self,
208        store: impl AsContext<ReproducibleEngine<E>>,
209    ) -> Box<dyn Iterator<Item = Export<ReproducibleEngine<E>>>> {
210        Box::new(
211            WasmInstance::exports(&self.0, store.as_context().as_inner_context()).map(
212                |Export { name, value }| Export {
213                    name,
214                    value: from_extern(value),
215                },
216            ),
217        )
218    }
219
220    fn get_export(
221        &self,
222        store: impl AsContext<ReproducibleEngine<E>>,
223        name: &str,
224    ) -> Option<Extern<ReproducibleEngine<E>>> {
225        WasmInstance::get_export(&self.0, store.as_context().as_inner_context(), name)
226            .map(from_extern)
227    }
228}
229
230#[derive(Clone)]
231#[repr(transparent)]
232pub struct ReproducibleMemory<E: WasmEngine>(E::Memory);
233
234impl<E: WasmEngine> WasmMemory<ReproducibleEngine<E>> for ReproducibleMemory<E> {
235    fn new(
236        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
237        ty: MemoryType,
238    ) -> anyhow::Result<Self> {
239        Ok(Self(<E::Memory as WasmMemory<E>>::new(
240            ctx.as_context_mut().as_inner_context_mut(),
241            ty,
242        )?))
243    }
244
245    fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> MemoryType {
246        WasmMemory::ty(&self.0, ctx.as_context().as_inner_context())
247    }
248
249    fn grow(
250        &self,
251        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
252        additional: u32,
253    ) -> anyhow::Result<u32> {
254        WasmMemory::grow(
255            &self.0,
256            ctx.as_context_mut().as_inner_context_mut(),
257            additional,
258        )
259    }
260
261    fn current_pages(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> u32 {
262        WasmMemory::current_pages(&self.0, ctx.as_context().as_inner_context())
263    }
264
265    fn read(
266        &self,
267        ctx: impl AsContext<ReproducibleEngine<E>>,
268        offset: usize,
269        buffer: &mut [u8],
270    ) -> anyhow::Result<()> {
271        WasmMemory::read(&self.0, ctx.as_context().as_inner_context(), offset, buffer)
272    }
273
274    fn write(
275        &self,
276        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
277        offset: usize,
278        buffer: &[u8],
279    ) -> anyhow::Result<()> {
280        WasmMemory::write(
281            &self.0,
282            ctx.as_context_mut().as_inner_context_mut(),
283            offset,
284            buffer,
285        )
286    }
287}
288
289pub const DETERMINISTIC_WASM_MODULE_FEATURES: wasmparser::WasmFeaturesInflated =
290    wasmparser::WasmFeaturesInflated {
291        // MUST: mutable globals do not introduce non-determinism, as long
292        //       as the host does not change their value to be non-
293        //       deterministic
294        mutable_global: true,
295        // OK: saturating float -> int conversions only produce finite values
296        saturating_float_to_int: true,
297        // MUST: arithmetic sign extension operators are deterministic
298        sign_extension: true,
299        // (unsure): disabled for now, needs further research
300        reference_types: false,
301        // OK: returning multiple values does not interact with determinism
302        multi_value: true,
303        // MUST: operations like memcpy and memset are deterministic
304        bulk_memory: true,
305        // (ok): fixed-width SIMD replicates scalar float semantics
306        simd: true,
307        // BAD: exposes platform-dependent behaviour and non-determinism
308        relaxed_simd: false,
309        // BAD: allows non-deterministic concurrency and race conditions
310        threads: false,
311        // BAD: allows non-deterministic concurrency and race conditions
312        shared_everything_threads: false,
313        // (ok): using tail calls does not interact with determinism
314        //       but support is not universal yet:
315        //       https://webassembly.org/features/
316        tail_call: false,
317        // BAD: float operations can introduce non-deterministic NaNs
318        floats: false,
319        // MUST: using multiple memories does not interact with determinism
320        multi_memory: true,
321        // (unsure): disabled for now, needs further research
322        exceptions: false,
323        // (nope): using a 64bit memory space does not interact with
324        //         determinism but encourages large memory usage
325        memory64: false,
326        // (ok): const i[32|64] add, sub, and mul are deterministic
327        //       but support is not universal yet:
328        //       https://webassembly.org/features/
329        extended_const: false,
330        // NO-CORE: components must have been translated into core WASM
331        //          modules by now
332        component_model: false,
333        // (unsure): disabled for now, needs further research
334        function_references: false,
335        // (unsure): disabled for now, needs further research
336        memory_control: false,
337        // (unsure): disabled for now, needs further research
338        gc: false,
339        // (ok): statically declaring a custom page size is deterministic
340        //       and could reduce resource consumption
341        //       but there is no support yet
342        custom_page_sizes: false,
343        // NO-CORE: components must have been translated into core WASM
344        //          modules by now
345        component_model_values: false,
346        // NO-CORE: components must have been translated into core WASM
347        //          modules by now
348        component_model_nested_names: false,
349        // (unsure): disabled for now, needs further research
350        legacy_exceptions: false,
351        // (unsure): disabled for now, depends on reference types and gc,
352        //           needs further research
353        gc_types: false,
354        // (unsure): disabled for now, not needed since codecs are sync for now
355        stack_switching: false,
356        // OK: wide integer add, sub, and mul are deterministic
357        wide_arithmetic: true,
358        // NO-CORE: components must have been translated into core WASM
359        //          modules by now
360        component_model_async: false,
361    };
362
363#[derive(Clone)]
364#[repr(transparent)]
365pub struct ReproducibleModule<E: WasmEngine>(E::Module);
366
367impl<E: WasmEngine> WasmModule<ReproducibleEngine<E>> for ReproducibleModule<E> {
368    fn new(engine: &ReproducibleEngine<E>, mut stream: impl std::io::Read) -> anyhow::Result<Self> {
369        let features = wasmparser::WasmFeatures::from(wasmparser::WasmFeaturesInflated {
370            // MUST: floats are required and we are running the NaN
371            //       canonicalisation transform to make them deterministic
372            floats: true,
373            ..DETERMINISTIC_WASM_MODULE_FEATURES
374        });
375
376        let mut bytes = Vec::new();
377        stream.read_to_end(&mut bytes)?;
378
379        wasmparser::Validator::new_with_features(features).validate_all(&bytes)?;
380
381        // Inject an instruction counter into the WASM module
382        let bytes = InstructionCounterInjecter::apply_to_module(&bytes, features)?;
383
384        // Normalise NaNs to ensure floating point operations are deterministic
385        let bytes = NaNCanonicaliser::apply_to_module(&bytes, features)?;
386
387        Ok(Self(<E::Module as WasmModule<E>>::new(
388            engine.as_ref(),
389            bytes.as_slice(),
390        )?))
391    }
392
393    fn exports(&self) -> Box<dyn '_ + Iterator<Item = ExportType<'_>>> {
394        WasmModule::exports(&self.0)
395    }
396
397    fn get_export(&self, name: &str) -> Option<ExternType> {
398        WasmModule::get_export(&self.0, name)
399    }
400
401    fn imports(&self) -> Box<dyn '_ + Iterator<Item = ImportType<'_>>> {
402        WasmModule::imports(&self.0)
403    }
404}
405
406struct StoreData<T, E: WasmEngine> {
407    data: T,
408    instruction_counter: Option<ReproducibleGlobal<E>>,
409}
410
411#[derive(Clone)]
412#[repr(transparent)]
413pub struct ReproducibleStore<T, E: WasmEngine>(E::Store<StoreData<T, E>>);
414
415impl<T, E: WasmEngine> WasmStore<T, ReproducibleEngine<E>> for ReproducibleStore<T, E> {
416    fn new(engine: &ReproducibleEngine<E>, data: T) -> Self {
417        Self(<E::Store<StoreData<T, E>> as WasmStore<
418            StoreData<T, E>,
419            E,
420        >>::new(
421            engine.as_ref(),
422            StoreData {
423                data,
424                instruction_counter: None,
425            },
426        ))
427    }
428
429    fn engine(&self) -> &ReproducibleEngine<E> {
430        ReproducibleEngine::from_ref(WasmStore::engine(&self.0))
431    }
432
433    fn data(&self) -> &T {
434        &WasmStore::data(&self.0).data
435    }
436
437    fn data_mut(&mut self) -> &mut T {
438        &mut WasmStore::data_mut(&mut self.0).data
439    }
440
441    fn into_data(self) -> T {
442        WasmStore::into_data(self.0).data
443    }
444}
445
446impl<T, E: WasmEngine> AsContext<ReproducibleEngine<E>> for ReproducibleStore<T, E> {
447    type UserState = T;
448
449    fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
450        ReproducibleStoreContext(AsContext::as_context(&self.0))
451    }
452}
453
454impl<T, E: WasmEngine> AsContextMut<ReproducibleEngine<E>> for ReproducibleStore<T, E> {
455    fn as_context_mut(&mut self) -> ReproducibleStoreContextMut<'_, Self::UserState, E> {
456        ReproducibleStoreContextMut(AsContextMut::as_context_mut(&mut self.0))
457    }
458}
459
460#[repr(transparent)]
461pub struct ReproducibleStoreContext<'a, T: 'a, E: WasmEngine>(E::StoreContext<'a, StoreData<T, E>>);
462
463impl<'a, T: 'a, E: WasmEngine> WasmStoreContext<'a, T, ReproducibleEngine<E>>
464    for ReproducibleStoreContext<'a, T, E>
465{
466    fn engine(&self) -> &ReproducibleEngine<E> {
467        ReproducibleEngine::from_ref(WasmStoreContext::engine(&self.0))
468    }
469
470    fn data(&self) -> &T {
471        &WasmStoreContext::data(&self.0).data
472    }
473}
474
475impl<'a, T: 'a, E: WasmEngine> AsContext<ReproducibleEngine<E>>
476    for ReproducibleStoreContext<'a, T, E>
477{
478    type UserState = T;
479
480    fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
481        ReproducibleStoreContext(AsContext::as_context(&self.0))
482    }
483}
484
485impl<'a, T: 'a, E: WasmEngine> ReproducibleStoreContext<'a, T, E> {
486    fn as_inner_context(&self) -> E::StoreContext<'_, StoreData<T, E>> {
487        self.0.as_context()
488    }
489}
490
491#[repr(transparent)]
492pub struct ReproducibleStoreContextMut<'a, T: 'a, E: WasmEngine>(
493    E::StoreContextMut<'a, StoreData<T, E>>,
494);
495
496impl<'a, T: 'a, E: WasmEngine> WasmStoreContext<'a, T, ReproducibleEngine<E>>
497    for ReproducibleStoreContextMut<'a, T, E>
498{
499    fn engine(&self) -> &ReproducibleEngine<E> {
500        ReproducibleEngine::from_ref(WasmStoreContext::engine(&self.0))
501    }
502
503    fn data(&self) -> &T {
504        &WasmStoreContext::data(&self.0).data
505    }
506}
507
508impl<'a, T: 'a, E: WasmEngine> WasmStoreContextMut<'a, T, ReproducibleEngine<E>>
509    for ReproducibleStoreContextMut<'a, T, E>
510{
511    fn data_mut(&mut self) -> &mut T {
512        &mut WasmStoreContextMut::data_mut(&mut self.0).data
513    }
514}
515
516impl<'a, T: 'a, E: WasmEngine> AsContext<ReproducibleEngine<E>>
517    for ReproducibleStoreContextMut<'a, T, E>
518{
519    type UserState = T;
520
521    fn as_context(&self) -> ReproducibleStoreContext<'_, Self::UserState, E> {
522        ReproducibleStoreContext(AsContext::as_context(&self.0))
523    }
524}
525
526impl<'a, T: 'a, E: WasmEngine> AsContextMut<ReproducibleEngine<E>>
527    for ReproducibleStoreContextMut<'a, T, E>
528{
529    fn as_context_mut(&mut self) -> ReproducibleStoreContextMut<'_, Self::UserState, E> {
530        ReproducibleStoreContextMut(AsContextMut::as_context_mut(&mut self.0))
531    }
532}
533
534impl<'a, T: 'a, E: WasmEngine> ReproducibleStoreContextMut<'a, T, E> {
535    fn as_inner_context_mut(&mut self) -> E::StoreContextMut<'_, StoreData<T, E>> {
536        self.0.as_context_mut()
537    }
538
539    fn get_instruction_counter_global(&mut self) -> &ReproducibleGlobal<E> {
540        let mut this = self;
541
542        // NLL cannot prove this to be safe, but Polonius can
543        polonius_the_crab::polonius!(|this| -> &'polonius ReproducibleGlobal<E> {
544            let data: &mut StoreData<T, E> = WasmStoreContextMut::data_mut(&mut this.0);
545            if let Some(global) = &data.instruction_counter {
546                polonius_the_crab::polonius_return!(global);
547            }
548        });
549
550        let global = WasmGlobal::new(AsContextMut::as_context_mut(this), Value::I64(0), true);
551
552        let data: &mut StoreData<T, E> = WasmStoreContextMut::data_mut(&mut this.0);
553        data.instruction_counter.insert(global)
554    }
555}
556
557#[derive(Clone)]
558#[repr(transparent)]
559pub struct ReproducibleTable<E: WasmEngine>(E::Table);
560
561impl<E: WasmEngine> WasmTable<ReproducibleEngine<E>> for ReproducibleTable<E> {
562    fn new(
563        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
564        ty: TableType,
565        init: Value<ReproducibleEngine<E>>,
566    ) -> anyhow::Result<Self> {
567        Ok(Self(<E::Table as WasmTable<E>>::new(
568            ctx.as_context_mut().as_inner_context_mut(),
569            ty,
570            into_value(init),
571        )?))
572    }
573
574    fn ty(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> TableType {
575        WasmTable::ty(&self.0, ctx.as_context().as_inner_context())
576    }
577
578    fn size(&self, ctx: impl AsContext<ReproducibleEngine<E>>) -> u32 {
579        WasmTable::size(&self.0, ctx.as_context().as_inner_context())
580    }
581
582    fn grow(
583        &self,
584        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
585        delta: u32,
586        init: Value<ReproducibleEngine<E>>,
587    ) -> anyhow::Result<u32> {
588        WasmTable::grow(
589            &self.0,
590            ctx.as_context_mut().as_inner_context_mut(),
591            delta,
592            into_value(init),
593        )
594    }
595
596    fn get(
597        &self,
598        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
599        index: u32,
600    ) -> Option<Value<ReproducibleEngine<E>>> {
601        WasmTable::get(&self.0, ctx.as_context_mut().as_inner_context_mut(), index).map(from_value)
602    }
603
604    fn set(
605        &self,
606        mut ctx: impl AsContextMut<ReproducibleEngine<E>>,
607        index: u32,
608        value: Value<ReproducibleEngine<E>>,
609    ) -> anyhow::Result<()> {
610        WasmTable::set(
611            &self.0,
612            ctx.as_context_mut().as_inner_context_mut(),
613            index,
614            into_value(value),
615        )
616    }
617}
618
619const fn as_values<E: WasmEngine>(values: &[Value<ReproducibleEngine<E>>]) -> &[Value<E>] {
620    // Safety: all of our WASM runtime type wrappers are transparent newtypes
621    #[expect(unsafe_code)]
622    unsafe {
623        std::slice::from_raw_parts(values.as_ptr().cast(), values.len())
624    }
625}
626
627fn as_values_mut<E: WasmEngine>(values: &mut [Value<ReproducibleEngine<E>>]) -> &mut [Value<E>] {
628    // Safety: all of our WASM runtime type wrappers are transparent newtypes
629    #[expect(unsafe_code)]
630    unsafe {
631        std::slice::from_raw_parts_mut(values.as_mut_ptr().cast(), values.len())
632    }
633}
634
635const fn from_values<E: WasmEngine>(values: &[Value<E>]) -> &[Value<ReproducibleEngine<E>>] {
636    // Safety: all of our WASM runtime type wrappers are transparent newtypes
637    #[expect(unsafe_code)]
638    unsafe {
639        std::slice::from_raw_parts(values.as_ptr().cast(), values.len())
640    }
641}
642
643fn from_values_mut<E: WasmEngine>(values: &mut [Value<E>]) -> &mut [Value<ReproducibleEngine<E>>] {
644    // Safety: all of our WASM runtime type wrappers are transparent newtypes
645    #[expect(unsafe_code)]
646    unsafe {
647        std::slice::from_raw_parts_mut(values.as_mut_ptr().cast(), values.len())
648    }
649}
650
651fn into_value<E: WasmEngine>(value: Value<ReproducibleEngine<E>>) -> Value<E> {
652    match value {
653        Value::I32(v) => Value::I32(v),
654        Value::I64(v) => Value::I64(v),
655        Value::F32(v) => Value::F32(v),
656        Value::F64(v) => Value::F64(v),
657        Value::FuncRef(v) => Value::FuncRef(v.map(|v| v.0)),
658        Value::ExternRef(v) => Value::ExternRef(v.map(|v| v.0)),
659    }
660}
661
662fn from_value<E: WasmEngine>(value: Value<E>) -> Value<ReproducibleEngine<E>> {
663    match value {
664        Value::I32(v) => Value::I32(v),
665        Value::I64(v) => Value::I64(v),
666        Value::F32(v) => Value::F32(v),
667        Value::F64(v) => Value::F64(v),
668        Value::FuncRef(v) => Value::FuncRef(v.map(ReproducibleFunc)),
669        Value::ExternRef(v) => Value::ExternRef(v.map(ReproducibleExternRef)),
670    }
671}
672
673fn into_extern<E: WasmEngine>(value: Extern<ReproducibleEngine<E>>) -> Extern<E> {
674    match value {
675        Extern::Global(v) => Extern::Global(v.0),
676        Extern::Table(v) => Extern::Table(v.0),
677        Extern::Memory(v) => Extern::Memory(v.0),
678        Extern::Func(v) => Extern::Func(v.0),
679    }
680}
681
682fn from_extern<E: WasmEngine>(value: Extern<E>) -> Extern<ReproducibleEngine<E>> {
683    match value {
684        Extern::Global(v) => Extern::Global(ReproducibleGlobal(v)),
685        Extern::Table(v) => Extern::Table(ReproducibleTable(v)),
686        Extern::Memory(v) => Extern::Memory(ReproducibleMemory(v)),
687        Extern::Func(v) => Extern::Func(ReproducibleFunc(v)),
688    }
689}
numcodecs_wasm_host_reproducible/engine.rs

numcodecs_wasm_host_reproducible/
engine.rs
