diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 195b0db..84e333a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -123,6 +123,40 @@ jobs:
       working-directory: build/test-suite
       run: ctest -C Release -V
 
+  build-on-ubuntu-for-wasm:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: asdf-vm/actions/install@v1
+    - name: Install dependencies
+      uses: py-actions/py-dependency-install@v3
+      with:
+        path: "requirements.txt"
+    - name: Install node
+      uses: actions/setup-node@v3
+      with:
+        node-version: 20.9.0
+    - name: Install browserify
+      run: npm install -g browserify
+    - name: Setup EMSDK
+      uses: mymindstorm/setup-emsdk@v11
+      with:
+        version: 3.1.44
+    - name: Install chrome
+      uses: browser-actions/setup-chrome@latest
+    - name: Use local djinni on branch for now
+      if: ${{ github.ref != 'refs/heads/master' }}
+      run: export CMAKE_DJINNI_OPT="-DDJINNI_EXECUTABLE=$(pwd)/bin/djinni"
+    - name: Report cmake version
+      run: cmake --version
+    - name: Configure cmake
+      run: cmake  -DCMAKE_TOOLCHAIN_FILE=$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -S . -B build -DDJINNI_WITH_WASM=ON -DDJINNI_EXECUTABLE=$(pwd)/bin/djinni
+    - name: Build release
+      run: cmake --build build --parallel $(nproc) --config Release
+    - name: Run headless test
+      run: pushd build && ctest --output-on-failure
+    - name: Run integration test on sample app
+      run: pushd build/examples && ./run.sh && python3 run-tests-selenium.py 
 
   build-on-windows-for-cppcli:
     runs-on: windows-latest
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f6691c9..ccb8545 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,6 +10,8 @@ project(djinni_support_lib CXX ${PROJECT_LANGUAGES})
 
 include(GNUInstallDirs)
 
+include(cmake/Djinni.cmake)
+
 set(SRC_SHARED
   "djinni/djinni_common.hpp"
   "djinni/proxy_cache_interface.hpp"
@@ -48,6 +50,11 @@ set(SRC_CPPCLI
   "djinni/cppcli/WrapperCache.cpp"
 )
 
+set(SRC_WASM
+  "djinni/wasm/djinni_wasm.hpp"
+  "djinni/wasm/djinni_wasm.cpp"
+)
+
 # set `DJINNI_LIBRARY_TYPE` to `STATIC` or `SHARED` to define the type of library.
 # If undefined, the type will be determined based on `BUILD_SHARED_LIBS`
 add_library(djinni_support_lib ${DJINNI_LIBRARY_TYPE} ${SRC_SHARED})
@@ -151,13 +158,14 @@ if(DJINNI_WITH_PYTHON)
 endif()
 
 option(DJINNI_WITH_CPPCLI "Include the C++/CLI support code in Djinni support library." OFF)
+option(DJINNI_WITH_WASM "Include the WASM/TS support code in Djinni support library." OFF)
 if(DJINNI_WITH_CPPCLI)
 
   if(NOT MSVC)
     message(FATAL_ERROR "Enabling DJINNI_WITH_CPPCLI without MSVC is not supported")
   endif()
 
-  if(DJINNI_WITH_OBJC OR DJINNI_WITH_JNI OR DJINNI_WITH_PYTHON)
+  if(DJINNI_WITH_OBJC OR DJINNI_WITH_JNI OR DJINNI_WITH_PYTHON OR DJINNI_WITH_WASM)
     message(FATAL_ERROR "DJINNI_WITH_CPPCLI can not be used with other bindings enabled.")
   endif()
 
@@ -180,13 +188,31 @@ if(DJINNI_WITH_CPPCLI)
   )
 endif()
 
-if(NOT (DJINNI_WITH_OBJC OR DJINNI_WITH_JNI OR DJINNI_WITH_PYTHON OR DJINNI_WITH_CPPCLI))
-  message(FATAL_ERROR "At least one of DJINNI_WITH_OBJC or DJINNI_WITH_JNI or DJINNI_WITH_PYTHON or DJINNI_WITH_CPPCLI must be enabled.")
+if(DJINNI_WITH_WASM)
+
+  if(DJINNI_WITH_OBJC OR DJINNI_WITH_JNI OR DJINNI_WITH_PYTHON OR DJINNI_WITH_CPPCLI)
+    message(FATAL_ERROR "DJINNI_WITH_WASM can not be used with other bindings enabled.")
+  endif()
+
+  target_include_directories(djinni_support_lib PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/djinni/wasm>")
+  target_sources(djinni_support_lib PRIVATE ${SRC_WASM})
+  source_group("wasm" FILES ${SRC_WASM})
+  install(
+    FILES
+      "djinni/wasm/djinni_wasm.hpp"
+    DESTINATION
+      ${CMAKE_INSTALL_INCLUDEDIR}/djinni/wasm
+  )
+endif()
+
+if(NOT (DJINNI_WITH_OBJC OR DJINNI_WITH_JNI OR DJINNI_WITH_PYTHON OR DJINNI_WITH_CPPCLI OR DJINNI_WITH_WASM))
+  message(FATAL_ERROR "At least one of DJINNI_WITH_OBJC or DJINNI_WITH_JNI or DJINNI_WITH_PYTHON or DJINNI_WITH_CPPCLI or DJINNI_WITH_WASM must be enabled.")
 endif()
 
 option(DJINNI_BUILD_TESTING "Build tests" ON)
 
 include(CTest)
 if (BUILD_TESTING AND DJINNI_BUILD_TESTING)
+  add_subdirectory(examples)
   add_subdirectory(test-suite)
 endif()
diff --git a/bin/djinni b/bin/djinni
new file mode 100755
index 0000000..9629bab
Binary files /dev/null and b/bin/djinni differ
diff --git a/test-suite/Djinni.cmake b/cmake/Djinni.cmake
similarity index 91%
rename from test-suite/Djinni.cmake
rename to cmake/Djinni.cmake
index 19a188f..577f6a0 100644
--- a/test-suite/Djinni.cmake
+++ b/cmake/Djinni.cmake
@@ -15,7 +15,6 @@ execute_process(COMMAND ${DJINNI_EXECUTABLE} "--version" OUTPUT_VARIABLE DJINNI_
 string(REGEX REPLACE "\n+$" "" DJINNI_VERSION "${DJINNI_VERSION}")
 message(STATUS "Found Djinni: ${DJINNI_EXECUTABLE} (${DJINNI_VERSION})")
 
-
 macro(append_if_defined LIST OPTION)
   if(NOT "${ARGN}" STREQUAL "")
     list(APPEND ${LIST} ${OPTION} ${ARGN})
@@ -178,6 +177,15 @@ function(add_djinni_target)
     CPPCLI_NAMESPACE
     CPPCLI_INCLUDE_CPP_PREFIX
 
+    WASM_OUT
+    WASM_OUT_FILES
+    WASM_NAMESPACE
+    
+    TS_OUT
+    TS_OUT_FILES
+    TS_MODULE
+    TS_SUPPORT_FILES_OUT
+
     YAML_OUT
     YAML_OUT_FILE
     YAML_PREFIX
@@ -270,6 +278,10 @@ function(add_djinni_target)
   append_if_defined(DJINNI_GENERATION_COMMAND "--cppcli-namespace" ${DJINNI_CPPCLI_NAMESPACE})
   append_if_defined(DJINNI_GENERATION_COMMAND "--cppcli-include-cpp-prefix" ${DJINNI_CPPCLI_INCLUDE_CPP_PREFIX})
 
+  append_if_defined(DJINNI_GENERATION_COMMAND "--wasm-namespace" ${DJINNI_WASM_NAMESPACE})
+  append_if_defined(DJINNI_GENERATION_COMMAND "--ts-module" ${DJINNI_TS_MODULE})
+  append_if_defined(DJINNI_GENERATION_COMMAND "--ts-support-files-out" ${DJINNI_TS_SUPPORT_FILES_OUT})
+
   if(DEFINED DJINNI_CPP_OUT_FILES)
     set(DJINNI_CPP_GENERATION_COMMAND ${DJINNI_GENERATION_COMMAND})
     append_if_defined(DJINNI_CPP_GENERATION_COMMAND "--cpp-out" ${DJINNI_CPP_OUT})
@@ -418,5 +430,38 @@ function(add_djinni_target)
     set(${DJINNI_CPPCLI_OUT_FILES} ${CPPCLI_OUT_FILES} PARENT_SCOPE)
   endif()
 
+  if(DEFINED DJINNI_WASM_OUT_FILES)
+    set(DJINNI_WASM_GENERATION_COMMAND ${DJINNI_GENERATION_COMMAND})
+    append_if_defined(DJINNI_WASM_GENERATION_COMMAND "--wasm-out" ${DJINNI_WASM_OUT})
+
+    resolve_djinni_outputs(COMMAND "${DJINNI_WASM_GENERATION_COMMAND}" RESULT WASM_OUT_FILES)
+
+    add_custom_command(
+      OUTPUT ${WASM_OUT_FILES}
+      DEPENDS ${DJINNI_INPUTS}
+      COMMAND ${DJINNI_WASM_GENERATION_COMMAND}
+      COMMENT "Generating Djinni Web Assembly bindings from ${DJINNI_IDL}"
+      VERBATIM
+    )
+    set(${DJINNI_WASM_OUT_FILES} ${WASM_OUT_FILES} PARENT_SCOPE)
+  endif()  
+
+  if(DEFINED DJINNI_TS_OUT_FILES)
+    set(DJINNI_TS_GENERATION_COMMAND ${DJINNI_GENERATION_COMMAND})
+    append_if_defined(DJINNI_TS_GENERATION_COMMAND "--ts-out" ${DJINNI_TS_OUT})
+
+    resolve_djinni_outputs(COMMAND "${DJINNI_TS_GENERATION_COMMAND}" RESULT TS_OUT_FILES)
+
+    message(STATUS "Output: ${TS_OUT_FILES}, Depends: ${DJINNI_INPUTS}, Command: ${DJINNI_TS_GENERATION_COMMAND}")
+    add_custom_command(
+      OUTPUT ${TS_OUT_FILES}
+      DEPENDS ${DJINNI_INPUTS}
+      COMMAND ${DJINNI_TS_GENERATION_COMMAND}
+      COMMENT "Generating Djinni TS bindings from ${DJINNI_IDL}"
+      VERBATIM
+    )
+    set(${DJINNI_TS_OUT_FILES} ${TS_OUT_FILES} PARENT_SCOPE)
+  endif()  
+
 endfunction()
 
diff --git a/djinni/wasm/djinni_wasm.cpp b/djinni/wasm/djinni_wasm.cpp
new file mode 100644
index 0000000..0b05cb4
--- /dev/null
+++ b/djinni/wasm/djinni_wasm.cpp
@@ -0,0 +1,222 @@
+/**
+  * Copyright 2021 Snap, Inc.
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *    http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+#include "djinni_wasm.hpp"
+
+namespace djinni {
+
+Binary::CppType Binary::toCpp(const JsType& j) {
+    return PrimitiveArray<Primitive<uint8_t>, Binary>::toCpp(j);
+}
+Binary::JsType Binary::fromCpp(const CppType& c) {
+    static em::val arrayClass = em::val::global("Uint8Array");
+    return PrimitiveArray<Primitive<uint8_t>, Binary>::fromCpp(c);
+}
+em::val Binary::getArrayClass() {
+    static em::val arrayClass = em::val::global("Uint8Array");
+    return arrayClass;
+}
+
+Date::CppType Date::toCpp(const JsType& j) {
+    auto nanosSinceEpoch = std::chrono::nanoseconds(static_cast<int64_t>(j.call<em::val>("getTime").as<double>() * 1'000'000));
+    return CppType(std::chrono::duration_cast<std::chrono::system_clock::duration>(nanosSinceEpoch));
+}
+Date::JsType Date::fromCpp(const CppType& c) {
+    auto nanosSinceEpoch = std::chrono::duration_cast<std::chrono::nanoseconds>(c.time_since_epoch());
+    static em::val dateType = em::val::global("Date");
+    return dateType.new_(static_cast<double>(nanosSinceEpoch.count()) / 1'000'000.0);
+}
+
+JsProxyId nextId = 0;
+std::unordered_map<JsProxyId, std::weak_ptr<JsProxyBase>> jsProxyCache;
+std::unordered_map<void*, CppProxyCacheEntry> cppProxyCache;
+std::mutex jsProxyCacheMutex;
+std::mutex cppProxyCacheMutex;
+
+JsProxyBase::JsProxyBase(const em::val& v) : _js(v), _id(_js["_djinni_js_proxy_id"].as<JsProxyId>()) {
+}
+
+JsProxyBase::~JsProxyBase() {
+    std::lock_guard lk(jsProxyCacheMutex);
+    jsProxyCache.erase(_id);
+}
+
+const em::val& JsProxyBase::_jsRef() const {
+    return _js;
+}
+
+void JsProxyBase::checkError(const em::val& v) {
+    if (v.instanceof(em::val::global("Error"))) {
+        auto cppExceptionPtr = v["_djinni_cpp_exception_ptr"];
+        if (!cppExceptionPtr.isUndefined()) {
+            std::exception_ptr* exptr = reinterpret_cast<std::exception_ptr*>(cppExceptionPtr.as<int>());
+            std::rethrow_exception(*exptr);
+        } else {
+            throw JsException(v);
+        }
+    }
+}
+
+void checkForNull(void* ptr, const char* context) {
+    if (!ptr) {
+        throw std::invalid_argument(std::string("nullptr is not allowed in ") + context);
+    }
+}
+
+em::val getCppProxyFinalizerRegistry() {
+    static auto inst  = em::val::module_property("cppProxyFinalizerRegistry");
+    return inst;
+}
+
+em::val getCppProxyClass() {
+    static auto inst  = em::val::module_property("DjinniCppProxy");
+    return inst;
+}
+
+em::val getWasmMemoryBuffer() {
+    // When ALLOW_MEMORY_GROWTH is turned on, the WebAssembly.Memory object's underlying buffer changes as it grows,
+    // and the HEAP* views in the Emscripten module object get reset to new views over the bigger memory buffer.
+    // In this mode, capturing the heap here as a static variable is incorrect, and leads to runtime errors.
+    // https://github.com/emscripten-core/emscripten/blob/3.1.7/src/settings.js#L194-L207 is the growth setting
+    // https://github.com/emscripten-core/emscripten/blob/3.1.7/src/library.js#L127 is the call to reset the views after grow()
+    // https://github.com/emscripten-core/emscripten/blob/3.1.7/src/preamble.js#L269-L286 is where the views get reset
+    return em::val::module_property("HEAPU32")["buffer"];
+}
+
+em::val DataObject::createJsObject() {
+    static auto finalizerRegistry = em::val::module_property("directBufferFinalizerRegistry");
+    static auto uint8ArrayClass = em::val::global("Uint8Array");
+    em::val jsObj = uint8ArrayClass.new_(getWasmMemoryBuffer(), addr(), size());
+    finalizerRegistry.call<void>("register", jsObj, reinterpret_cast<unsigned>(this));
+    return jsObj;
+}
+
+static em::val allocateWasmBuffer(unsigned size) {
+    auto* dbuf = new GenericBuffer<std::vector<uint8_t>>(size);
+    return dbuf->createJsObject();
+}
+
+extern "C" EMSCRIPTEN_KEEPALIVE
+void releaseWasmBuffer(unsigned addr) {
+    delete reinterpret_cast<DataObject*>(addr);
+}
+
+EM_JS(void, djinni_init_wasm, (), {
+        // console.log("djinni_init_wasm");
+        Module.cppProxyFinalizerRegistry = new FinalizationRegistry(nativeRef => {
+            // console.log("finalizing cpp object @" + nativeRef);
+            nativeRef.nativeDestroy();
+            nativeRef.delete();
+        });
+
+        Module.directBufferFinalizerRegistry = new FinalizationRegistry(addr => {
+            Module._releaseWasmBuffer(addr);
+        });
+
+        class DjinniCppProxy {
+            constructor(nativeRef, methods) {
+                // console.log('new cpp proxy');
+                this._djinni_native_ref = nativeRef;
+                let self = this;
+                methods.forEach(function(method) {
+                    self[method] = function(...args) {
+                        return nativeRef[method](...args);
+                    }
+                });
+            }
+        }
+        Module.DjinniCppProxy = DjinniCppProxy;
+
+        class DjinniJsPromiseBuilder {
+            constructor(cppHandlerPtr) {
+                this.promise = new Promise((resolveFunc, rejectFunc) => {
+                        Module.initCppResolveHandler(cppHandlerPtr, resolveFunc, rejectFunc);
+                    });
+            }
+        }
+        Module.DjinniJsPromiseBuilder = DjinniJsPromiseBuilder;
+
+        Module.makeNativePromiseResolver = function(func, pNativePromise) {
+            return function(res) {
+                Module.resolveNativePromise(func, pNativePromise, res);
+            };
+        };
+        Module.makeNativePromiseRejecter = function(func, pNativePromise) {
+            return function(err) {
+                Module.rejectNativePromise(func, pNativePromise, err);
+            };
+        };
+
+        Module.writeNativeMemory = function(src, nativePtr) {
+            var srcByteView = new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+            Module.HEAPU8.set(srcByteView, nativePtr);
+        };
+        Module.readNativeMemory = function(cls, nativePtr, nativeSize) {
+            return new cls(Module.HEAPU8.buffer.slice(nativePtr, nativePtr + nativeSize));
+        };
+
+        Module.protobuf = {};
+        Module.registerProtobufLib = function(name, proto) {
+            Module.protobuf[name] = proto;
+        };
+
+        Module.callJsProxyMethod = function(obj, method, ...args) {
+            try {
+                return obj[method].apply(obj, args);
+            } catch (e) {
+                return e;
+            }
+        };
+});
+
+EM_JS(void, djinni_register_name_in_ns, (const char* prefixedName, const char* namespacedName), {
+        prefixedName = readLatin1String(prefixedName);
+        namespacedName = readLatin1String(namespacedName);
+        let parts = namespacedName.split('.');
+        let name = parts.pop();
+        let ns = parts.reduce(function(path, part) {
+            if (!path.hasOwnProperty(part)) { path[part] = {}}; 
+            return path[part]
+        }, Module);
+        ns[name] = Module[prefixedName];
+});
+
+em::val djinni_native_exception_to_js(const std::exception& e) {
+    if (const auto* jsEx = dynamic_cast<const JsException*>(&e)) {
+        return jsEx->cause();
+    } else {
+        static std::exception_ptr exptr;
+        static auto ErrorClass = em::val::global("Error");
+        auto error = ErrorClass.new_(std::string("C++: ") + e.what());
+        exptr = std::current_exception();
+        error.set("_djinni_cpp_exception_ptr", em::val(reinterpret_cast<int>(&exptr)));
+        return error;
+    }
+}
+
+void djinni_throw_native_exception(const std::exception& e) {
+    djinni_native_exception_to_js(e).throw_();
+}
+
+EMSCRIPTEN_BINDINGS(djinni_wasm) {
+    djinni_init_wasm();    
+    em::function("allocateWasmBuffer", &allocateWasmBuffer);
+    em::function("initCppResolveHandler", &CppResolveHandlerBase::initInstance);
+    em::function("resolveNativePromise", &CppResolveHandlerBase::resolveNativePromise);
+    em::function("rejectNativePromise", &CppResolveHandlerBase::rejectNativePromise);
+}
+
+}
diff --git a/djinni/wasm/djinni_wasm.hpp b/djinni/wasm/djinni_wasm.hpp
new file mode 100644
index 0000000..8add002
--- /dev/null
+++ b/djinni/wasm/djinni_wasm.hpp
@@ -0,0 +1,657 @@
+/**
+  * Copyright 2021 Snap, Inc.
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *    http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+#pragma once
+
+#include <emscripten.h>
+#include <emscripten/bind.h>
+
+#ifdef __EMSCRIPTEN_PTHREADS__
+#include <emscripten/threading.h>
+#endif
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <optional>
+#include <stdexcept>
+#include <iostream>
+
+namespace em = emscripten;
+
+namespace djinni {
+
+extern em::val getCppProxyFinalizerRegistry();
+extern em::val getCppProxyClass();
+extern em::val getWasmMemoryBuffer();
+
+template<typename T>
+class InstanceTracker {
+#ifdef DJINNI_WASM_TRACK_INSTANCES
+    static int& count() {
+        static int theCount = 0;
+        return theCount;
+    }
+public:
+    InstanceTracker() {
+        std::cout << "++" << typeid(this).name() << " => " << ++count() << std::endl;
+    }
+    virtual ~InstanceTracker() {
+        std::cout << "--" << typeid(this).name() << " => " << --count() << std::endl;
+    }
+#endif
+};
+
+template<typename T>
+class Primitive {
+public:
+    using CppType = T;
+    using JsType = T;
+
+    struct Boxed {
+        using JsType = em::val;
+        static CppType toCpp(JsType j) {
+            return j.as<CppType>();
+        }
+        static JsType fromCpp(CppType c) {
+            return JsType(c);
+        }
+    };
+
+    static CppType toCpp(const JsType& j) {
+        return j;
+    }
+    static JsType fromCpp(const CppType& c) {
+        return c;
+    }
+};
+
+using Bool = Primitive<bool>;
+using I8 = Primitive<int8_t>;
+using I16 = Primitive<int16_t>;
+using I32 = Primitive<int32_t>;
+using I64 = Primitive<int64_t>;
+using F32 = Primitive<float>;
+using F64 = Primitive<double>;
+using String = Primitive<std::string>;
+using WString = Primitive<std::wstring>;
+
+template<typename T>
+class WasmEnum {
+public:
+    using CppType = T;
+    using JsType = int32_t;
+
+    struct Boxed {
+        using JsType = em::val;
+        static CppType toCpp(JsType j) {
+            return static_cast<CppType>(j.as<int32_t>());
+        }
+        static JsType fromCpp(CppType c) {
+            return JsType(static_cast<int32_t>(c));
+        }
+    };
+
+    static CppType toCpp(const JsType& j) {
+        return static_cast<CppType>(j);
+    }
+    static JsType fromCpp(const CppType& c) {
+        return static_cast<JsType>(c);
+    }
+};
+
+class Binary {
+public:
+    using CppType = std::vector<uint8_t>;
+    using JsType = em::val;
+    using Boxed = Binary;
+    
+    static CppType toCpp(const JsType& j);
+    static JsType fromCpp(const CppType& c);
+
+    static em::val getArrayClass();
+};
+
+class Date {
+public:
+    using CppType = std::chrono::system_clock::time_point;
+    using JsType = em::val;
+    using Boxed = Date;
+    
+    static CppType toCpp(const JsType& j);
+    static JsType fromCpp(const CppType& c);
+};
+
+template <template <class> class OptionalType, class T>
+struct Optional
+{
+    template <typename C> static OptionalType<typename C::CppType> opt_type(...);
+    template <typename C> static typename C::CppOptType opt_type(typename C::CppOptType *);
+    using CppType = decltype(opt_type<T>(nullptr));
+    using JsType = em::val;
+    using Boxed = Optional;
+    
+    static CppType toCpp(const JsType& j) {
+        if (j.isUndefined() || j.isNull()) {
+            return CppType{};
+        } else {
+            return T::Boxed::toCpp(j);
+        }
+    }
+    static JsType fromCpp(const OptionalType<typename T::CppType>& c) {
+        return c ? T::Boxed::fromCpp(*c) : em::val::undefined();
+    }
+    template <typename C = T>
+    static JsType fromCpp(const typename C::CppOptType& cppOpt) {
+        return T::Boxed::fromCppOpt(cppOpt);
+    }
+};
+
+template <typename T> 
+class List {
+    using ECppType = typename T::CppType;
+    using EJsType = typename T::Boxed::JsType;
+public:
+    using CppType = std::vector<ECppType>;
+    using JsType = em::val;
+    using Boxed = List;
+
+    static CppType toCpp(const JsType& j) {
+        const size_t l = j["length"].as<size_t>();
+        CppType rv;
+        rv.reserve(l);
+        for (size_t i = 0; i < l; ++i) {
+            rv.push_back(T::Boxed::toCpp(j[i]));
+        }
+        return rv;
+    }
+    static JsType fromCpp(const CppType& c) {
+        em::val new_array = em::val::array();
+        for (const auto& e: c) {
+            new_array.call<void>("push", T::Boxed::fromCpp(e));
+        }
+        return new_array;
+    }
+};
+
+template <typename T>
+class Set  {
+    using ECppType = typename T::CppType;
+    using EJsType = typename T::Boxed::JsType;
+public:
+    using CppType = std::unordered_set<ECppType>;
+    using JsType = em::val;
+    using Boxed = Set;
+
+    static CppType toCpp(const JsType& j) {
+        static em::val arrayClass = em::val::global("Array");
+        em::val entries = arrayClass.call<em::val>("from", j);
+        const size_t l = entries["length"].as<size_t>();
+        CppType rs;
+        for (size_t i = 0; i < l; ++i) {
+            rs.insert(T::Boxed::toCpp(entries[i]));
+        }
+        return rs;
+    }
+    static JsType fromCpp(const CppType& c) {
+        static em::val setClass = em::val::global("Set");
+        em::val newSet = setClass.new_();
+        for (const auto& e: c) {
+            newSet.call<void>("add", T::Boxed::fromCpp(e));
+        }
+        return newSet;
+    }
+};
+
+template <typename Key, typename Value>
+class Map {
+    using CppKeyType = typename Key::CppType;
+    using CppValueType = typename Value::CppType;
+    using JsKeyType = typename Key::Boxed::JsType;
+    using JsValueType = typename Value::Boxed::JsType;
+public:
+    using CppType = std::unordered_map<CppKeyType, CppValueType>;
+    using JsType = em::val;
+    using Boxed = Map;
+
+    static CppType toCpp(const JsType& j) {
+        static em::val arrayClass = em::val::global("Array");
+        em::val entries = arrayClass.call<em::val>("from", j);
+        const size_t l = entries["length"].as<size_t>();
+        CppType rm;
+        for (size_t i = 0; i < l; ++i) {
+            rm.emplace(Key::Boxed::toCpp(entries[i][0]),
+                       Value::Boxed::toCpp(entries[i][1]));
+        }
+        return rm;
+    }
+    static JsType fromCpp(const CppType& c) {
+        static em::val mapClass = em::val::global("Map");
+        em::val newMap = mapClass.new_();
+        for (const auto &[k, v] : c) {
+            newMap.call<void>("set", Key::Boxed::fromCpp(k), Value::Boxed::fromCpp(v));
+        }
+        return newMap;
+    }
+};
+
+template<char... chars>
+class JsClassName {
+public:
+    static em::val resolve() {
+        static em::val cls = [] {
+            std::string name = {chars...};
+            em::val ns = em::val::module_property("protobuf");
+            std::string::size_type i = 0;
+            std::string::size_type j = name.find('.', i);
+            while (j != std::string::npos) {
+                ns = ns[name.substr(i, j - i)];
+                i = j + 1;
+                j = name.find('.', i);
+            }
+            return ns[name.substr(i)];
+        }();
+        return cls;
+    }
+};
+
+template<typename CppProto, typename JsProto>
+class Protobuf {
+public:
+    using CppType = CppProto;
+    using JsType = em::val;
+
+    using Boxed = Protobuf;
+
+    static CppType toCpp(JsType j)
+    {
+        em::val jsClass = JsProto::resolve();
+        auto writer = jsClass.call<em::val>("encode", j);
+        auto bytes = writer.call<em::val>("finish");
+        size_t length = bytes["byteLength"].as<int>();
+        CppProto ret;
+        if (bytes["buffer"] == getWasmMemoryBuffer()) {
+            const void* pbytes = reinterpret_cast<void*>(bytes["byteOffset"].as<unsigned>());
+            ret.ParseFromArray(pbytes, static_cast<int>(length));
+        } else {
+            std::vector<uint8_t> cbuf(length);
+            static em::val writeNativeMemory = em::val::module_property("writeNativeMemory");
+            writeNativeMemory(bytes, reinterpret_cast<uint32_t>(cbuf.data()));
+            ret.ParseFromArray(cbuf.data(), static_cast<int>(length));
+        }
+        return ret;
+    }
+        
+    static JsType fromCpp(const CppType& c)
+    {
+        std::vector<uint8_t> cbuf(c.ByteSizeLong());
+        c.SerializeToArray(cbuf.data(), static_cast<int>(cbuf.size()));
+
+        unsigned addr = reinterpret_cast<unsigned>(cbuf.data());
+        unsigned size = static_cast<unsigned>(cbuf.size());
+        static auto uint8ArrayClass = em::val::global("Uint8Array");
+        em::val array = uint8ArrayClass.new_(::djinni::getWasmMemoryBuffer(), addr, size);
+        em::val jsClass = JsProto::resolve();
+        return jsClass.call<em::val>("decode", array);
+    }
+};
+
+template <typename T>
+struct Array {
+    using CppType = std::vector<typename T::CppType>;
+    using JsType = em::val;
+    using Boxed = Array;
+
+    static CppType toCpp(const JsType& j) {
+        return List<T>::toCpp(j);
+    }
+    static JsType fromCpp(const CppType& c) {
+        return List<T>::fromCpp(c);
+    }
+};
+
+template <typename T, typename U = Array<T>>
+struct PrimitiveArray {
+    using CppType = std::vector<typename T::CppType>;
+    using JsType = em::val;
+    using Boxed = PrimitiveArray;
+
+    static CppType toCpp(const JsType& j) {
+        const size_t length = j["length"].as<size_t>();
+        std::vector<typename T::CppType> c(length);
+        static em::val writeNativeMemory = em::val::module_property("writeNativeMemory");
+        writeNativeMemory(j, reinterpret_cast<uint32_t>(c.data()));
+        return c;
+    }
+    static JsType fromCpp(const CppType& c) {
+        static em::val readNativeMemory = em::val::module_property("readNativeMemory");
+        return readNativeMemory(U::getArrayClass(), reinterpret_cast<uint32_t>(c.data()),
+                                static_cast<uint32_t>(c.size() * sizeof(typename T::CppType)));
+    }
+};
+template <>
+struct Array<I8> : PrimitiveArray<I8> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("Int8Array");
+        return arrayClass;
+    }
+};
+template <>
+struct Array<I16> : PrimitiveArray<I16> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("Int16Array");
+        return arrayClass;
+    }
+};
+template <>
+struct Array<I32> : PrimitiveArray<I32> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("Int32Array");
+        return arrayClass;
+    }
+};
+template <>
+struct Array<I64> : PrimitiveArray<I64> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("BigInt64Array");
+        return arrayClass;
+    }
+};
+template <>
+struct Array<F32> : PrimitiveArray<F32> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("Float32Array");
+        return arrayClass;
+    }
+};
+template <>
+struct Array<F64> : PrimitiveArray<F64> {
+    static em::val getArrayClass() {
+        static em::val arrayClass = em::val::global("Float64Array");
+        return arrayClass;
+    }
+};
+
+class Void {
+public:
+    using CppType = void;
+    using JsType = em::val;
+    using Boxed = Void;
+};
+
+class CppResolveHandlerBase {
+public:
+    virtual ~CppResolveHandlerBase() = default;
+    virtual void init(em::val resolveFunc, em::val rejectFunc) = 0;
+
+    static void initInstance(int handlerPtr, em::val resolveFunc, em::val rejectFunc) {
+        auto* handler = reinterpret_cast<CppResolveHandlerBase*>(handlerPtr);
+        handler->init(resolveFunc, rejectFunc);
+    }
+    
+    static void resolveNativePromise(int func, int context, em::val res) {
+        typedef void (*ResolveNativePromiseFunc)(int context, em::val res);
+        auto resolveNativePromiseFunc = reinterpret_cast<ResolveNativePromiseFunc>(func);
+        resolveNativePromiseFunc(context, res);
+    }
+
+    static void rejectNativePromise(int func, int context, em::val err) {
+        typedef void (*RejectNativePromiseFunc)(int context, em::val err);
+        auto rejectNativePromiseFunc = reinterpret_cast<RejectNativePromiseFunc>(func);
+        rejectNativePromiseFunc(context, err);
+    }
+};
+
+using JsProxyId = uint64_t;
+
+class JsException : public std::runtime_error {
+public:
+    // Input must be an instanceof an Error Type
+    JsException(const em::val& e):
+        std::runtime_error(resolveCppErrorString(e)),
+        _jsEx(e)
+    {}
+
+    static std::string resolveCppErrorString(const em::val& e) {
+        // The stack property is non-standard, but well supported in browsers
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack#browser_compatibility
+        // It also seems to include the name and message properties, so no need to access them separately
+        // However, DOMExceptions tend not to include the stack as they originate from C++ inside the browser engine, so
+        // check for presence, and fallback if necessary.
+        if (e["stack"].isString()) {
+            return e["stack"].as<std::string>();
+        }
+
+        // toString() will include the name and message, but not the stack. All wasm browsers support this.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/toString
+        return e.call<std::string>("toString");
+    }
+
+    const em::val& cause() const { return _jsEx; }
+private:
+    em::val _jsEx;
+};
+
+class JsProxyBase {
+public:
+    JsProxyBase(const em::val& v);
+    virtual ~JsProxyBase();
+    const em::val& _jsRef() const;
+    template<typename ...Args>
+    em::val callMethod(const std::string& name, Args&&... args) {
+        em::val caller = em::val::module_property("callJsProxyMethod");
+        return caller(_js, name, std::forward<Args>(args)...);
+    }
+protected:
+    void checkError(const em::val& v);
+private:
+    em::val _js;
+    JsProxyId _id;
+};
+
+struct CppProxyCacheEntry {
+    em::val ref;
+    int count;
+};
+
+extern JsProxyId nextId;
+extern std::unordered_map<JsProxyId, std::weak_ptr<JsProxyBase>> jsProxyCache;
+extern std::unordered_map<void*, CppProxyCacheEntry> cppProxyCache;
+extern std::mutex jsProxyCacheMutex;
+extern std::mutex cppProxyCacheMutex;
+
+void checkForNull(void* ptr, const char* context);
+
+template<typename I, typename Self>
+struct JsInterface {
+    static void nativeDestroy(const std::shared_ptr<I>& cpp) {
+        std::lock_guard lk(cppProxyCacheMutex);
+        auto i = cppProxyCache.find(cpp.get());
+        assert(i != cppProxyCache.end());
+        if (--(i->second.count) == 0) {
+            cppProxyCache.erase(cpp.get());
+        }
+    }
+    // enable this only when the derived class has `cppProxyMethods` defined
+    // (interface +c)
+    template <typename, typename>
+    struct GetOrCreateCppProxy {
+        em::val operator() (const std::shared_ptr<I>& c) {
+            assert(false && "Attempting to pass C++ object but interface lacks +c");
+            return em::val::undefined();
+        }
+    };
+    template <typename T>
+    struct GetOrCreateCppProxy<T, std::void_t<decltype(T::cppProxyMethods)>> {
+        em::val operator() (const std::shared_ptr<I>& c) {
+            // look up in cpp proxy cache
+            std::lock_guard lk(cppProxyCacheMutex);
+            auto i = cppProxyCache.find(c.get());
+            int jsRefCount = 1;
+            if (i != cppProxyCache.end()) {
+                // found existing cpp proxy
+                jsRefCount += i->second.count;
+                auto strongRef = i->second.ref.template call<em::val>("deref");
+                if (!strongRef.isUndefined()) {
+                    // and it's not expired
+                    return strongRef;
+                }
+            }
+            // not found or cache entry expired
+            // create a new cpp proxy and store it in cache
+            static em::val weakRefClass = em::val::global("WeakRef");
+            em::val nativeRef(c);
+            em::val cppProxy = getCppProxyClass().new_(nativeRef, Self::cppProxyMethods());
+            em::val weakRef = weakRefClass.new_(cppProxy);
+            if (i == cppProxyCache.end()) {
+                cppProxyCache.emplace(c.get(), CppProxyCacheEntry{weakRef, jsRefCount});
+            } else {
+                i->second = CppProxyCacheEntry{weakRef, jsRefCount};
+            }
+            getCppProxyFinalizerRegistry().call<void>("register", cppProxy, nativeRef);
+            return cppProxy;
+        }
+    };
+    static em::val _toJs(const std::shared_ptr<I>& c) {
+        if (c == nullptr) {
+            // null object
+            return em::val::undefined();
+        }
+        else if (auto* p = dynamic_cast<JsProxyBase*>(c.get())) {
+            // unwrap existing js proxy
+            return p->_jsRef();
+        } else {
+            return GetOrCreateCppProxy<Self, void>()(c);
+        }
+    }
+    // enable this only when the derived class has `JsProxy` defined
+    // (interface +w)
+    template <typename, typename>
+    struct GetOrCreateJsProxy {
+        std::shared_ptr<I> operator() (em::val js) {
+            assert(false && "Attempting to pass JS object but interface lacks +w");
+            return {};
+        }
+    };
+    template <typename T>
+    struct GetOrCreateJsProxy<T, std::void_t<typename T::JsProxy>> {
+        std::shared_ptr<I> operator() (em::val js) {
+            std::lock_guard lk(jsProxyCacheMutex);
+            // check prsence of proxy id in js object
+            JsProxyId id;
+            auto idProp = js["_djinni_js_proxy_id"];
+            if (idProp.isUndefined()) {
+                // no id, assign a new id
+                id = nextId++;
+                js.set("_djinni_js_proxy_id", id);
+            } else {
+                // already has id, look up in js proxy cache
+                id = idProp.as<JsProxyId>();
+                auto i = jsProxyCache.find(id);
+                if (i != jsProxyCache.end()) {
+                    auto strongProxyRef = i->second.lock();
+                    if (strongProxyRef) {
+                        return std::dynamic_pointer_cast<typename Self::JsProxy>(strongProxyRef);
+                    }
+                }
+            }
+            // not found or cache entry expired
+            // create new js proxy and store it in cache
+            auto newJsProxy = std::make_shared<typename Self::JsProxy>(js);
+            jsProxyCache.emplace(id, newJsProxy);
+            return newJsProxy;
+        }
+    };
+
+    static std::shared_ptr<I> _fromJs(em::val js) {
+        static const em::val nativeRef("_djinni_native_ref");
+        // null object
+        if (js.isUndefined() || js.isNull()) {
+            return {};
+        }
+        else if (nativeRef.in(js)) {
+            // existing cpp proxy
+            return js[nativeRef].as<std::shared_ptr<I>>();
+        } else {
+            return GetOrCreateJsProxy<Self, void>()(js);
+        }
+    }
+};
+
+struct DataObject {
+    virtual ~DataObject() = default;
+    em::val createJsObject();
+    virtual unsigned addr() = 0;
+    virtual unsigned size() = 0;
+};
+
+template<typename T>
+class GenericBuffer: public DataObject {
+public:
+    GenericBuffer(size_t size) : _buffer(size, {}) {}
+    GenericBuffer(const typename T::value_type* data, typename T::size_type size) :
+        _buffer(data, data + size) {}
+    GenericBuffer(T&& toTakeOver) : _buffer(std::move(toTakeOver)) {}
+    unsigned addr() override {
+        return reinterpret_cast<unsigned>(_buffer.data());
+    }
+    unsigned size() override {
+        return static_cast<unsigned>(_buffer.size());
+    }
+private:
+    T _buffer;
+};
+
+extern "C" void djinni_register_name_in_ns(const char* prefixedName, const char* namespacedName);
+extern "C" void djinni_throw_native_exception(const std::exception& e);
+em::val djinni_native_exception_to_js(const std::exception& e);
+
+template<typename U>
+struct DefaultInit {
+    static U get() { return U{}; }
+};
+template<>
+struct DefaultInit<em::val> {
+    static em::val get() { return em::val::undefined(); }
+};
+
+template<typename T>
+struct ExceptionHandlingTraits {
+    using R = typename T::JsType;
+    static R handleNativeException(const std::exception& e) {
+        djinni_throw_native_exception(e);
+        return DefaultInit<R>::get();
+    }
+};
+template<>
+struct ExceptionHandlingTraits<void> {
+    static void handleNativeException(const std::exception& e) {
+        djinni_throw_native_exception(e);
+    }
+};
+
+template<typename ClassType>
+class DjinniClass_ : public em::class_<ClassType> {
+public:
+    DjinniClass_ () = delete;
+
+    EMSCRIPTEN_ALWAYS_INLINE explicit DjinniClass_(const char* prefixedName, const char* namespacedName)
+        : em::class_<ClassType>(prefixedName) {
+        djinni_register_name_in_ns(prefixedName, namespacedName);
+    }
+};
+
+}
diff --git a/docs/developer-guide.md b/docs/developer-guide.md
index 176ab03..10b78f7 100644
--- a/docs/developer-guide.md
+++ b/docs/developer-guide.md
@@ -28,7 +28,7 @@ cmake --build . --parallel
 ```
 
 A custom `djinni` executable can be specified with the CMake option
-`DJINNI_EXECUTABLE_PATH`.
+`DJINNI_EXECUTABLE`.
 
 ### Running Tests
 
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..1aba9a3
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,102 @@
+cmake_minimum_required(VERSION 3.6.0)
+
+set(CMAKE_CXX_STANDARD 17)
+
+if(APPLE)
+    set(MACOSX_RPATH TRUE)
+    set(CMAKE_MACOSX_RPATH ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
+enable_testing()
+
+add_djinni_target(DjinniTextSort
+  IDL "example.djinni"
+#  IDL_INCLUDE_PATH "djinni/vendor"
+  CPP_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/cpp"
+  CPP_NAMESPACE "textsort"
+  IDENT_CPP_ENUM_TYPE "foo_bar"
+  CPP_EXTENDED_RECORD_INCLUDE_PREFIX "handwritten-src/cpp/"
+  CPP_ENUM_HASH_WORKAROUND
+  JAVA_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/java"
+  JAVA_PACKAGE "com.dropbox.textsort"
+  JAVA_GENERATE_INTERFACES
+  JAVA_IMPLEMENT_ANDROID_OS_PARCELABLE
+  JAVA_NULLABLE_ANNOTATION "javax.annotation.CheckForNull"
+  JAVA_NONNULL_ANNOTATION "javax.annotation.Nonnull"
+  IDENT_JAVA_FIELD "mFooBar"
+  JNI_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/jni"
+  IDENT_JNI_CLASS "NativeFooBar"
+  IDENT_JNI_FILE "NativeFooBar"
+  OBJC_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/objc"
+  OBJC_TYPE_PREFIX "DB"
+  OBJCPP_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/objc"
+  CPPCLI_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/cppcli"
+  CPPCLI_NAMESPACE "Djinni::TestSuite"
+  CPPCLI_INCLUDE_CPP_PREFIX "cpp/"
+  WASM_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/wasm"
+  TS_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/ts"
+  TS_MODULE "example"
+  TS_SUPPORT_FILES_OUT "${CMAKE_CURRENT_BINARY_DIR}/ts-support-lib"
+  YAML_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/yaml"
+  YAML_PREFIX "test_"
+
+  CPP_OUT_FILES     CPP_GENERATED_SRCS
+  JAVA_OUT_FILES    JAVA_GENERATED_SRCS
+  JNI_OUT_FILES     JNI_GENERATED_SRCS
+  OBJC_OUT_FILES    OBJC_GENERATED_SRCS
+  OBJCPP_OUT_FILES  OBJCPP_GENERATED_SRCS
+  CPPCLI_OUT_FILES  CPPCLI_GENERATED_SRCS
+  WASM_OUT_FILES    WASM_GENERATED_SRCS
+  TS_OUT_FILES      TS_GENERATED_SRCS
+  YAML_OUT_FILE     YAML_GENERATED_SRCS
+)
+
+if(DJINNI_WITH_WASM)
+  set(DjinniTextsortWasm "textsort-wasm")
+
+  set(CPP_HANDWRITTEN_SRCS 
+      ${CMAKE_CURRENT_SOURCE_DIR}/handwritten-src/cpp/sort_items_impl.cpp
+  )
+
+  add_executable(${DjinniTextsortWasm} 
+      ${CPP_HANDWRITTEN_SRCS}
+      ${CPP_GENERATED_SRCS}
+      ${WASM_GENERATED_SRCS}
+      ${TS_GENERATED_SRCS}
+    )
+    target_include_directories(${DjinniTextsortWasm} PUBLIC
+      ${CMAKE_SOURCE_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/handwritten-src/cpp
+      ${CMAKE_CURRENT_BINARY_DIR}/generated-src/cpp
+      ${CMAKE_CURRENT_BINARY_DIR}/generated-src/wasm
+    )
+
+    set(WASM_CC_FLAGS "-s MAIN_MODULE=1 -fexceptions")
+    set_target_properties(${DjinniTextsortWasm} PROPERTIES COMPILE_FLAGS ${WASM_CC_FLAGS})
+    
+    string(JOIN " " EMSCRIPTEN_LINK_OPTIONS
+      "-s WASM=1"
+      "--bind"  # Compiles the source code using the Embind bindings to connect C/C++ and JavaScript
+      "-s MALLOC=emmalloc"  # Switch to using the much smaller implementation
+      "-s MODULARIZE=1"  # Allows us to manually invoke the initialization of wasm
+      "-s WASM_BIGINT=1" # We need to pass int64_t
+    )
+
+    set(WASM_LINK_FLAGS "${EMSCRIPTEN_LINK_OPTIONS} -fexceptions")
+    set_target_properties(${DjinniTextsortWasm} PROPERTIES LINK_FLAGS ${WASM_LINK_FLAGS})
+    set(CMAKE_EXECUTABLE_SUFFIX ".js")
+    
+    target_link_libraries(${DjinniTextsortWasm} PUBLIC djinni-support-lib::djinni-support-lib embind)
+
+    add_custom_target(DjinniTextsortWasmCopy)
+    file(GLOB DjinniTextsortWasmResources ${CMAKE_CURRENT_SOURCE_DIR}/ts/*)
+    foreach(ResourceFile ${DjinniTextsortWasmResources})
+      add_custom_command(TARGET ${DjinniTextsortWasm} PRE_BUILD
+                        COMMAND ${CMAKE_COMMAND} -E
+                            copy ${ResourceFile} $<TARGET_FILE_DIR:${DjinniTextsortWasm}>)
+    endforeach()
+    add_dependencies(${DjinniTextsortWasm} DjinniTextsortWasmCopy)
+
+    # add_test(NAME DjinniWasmTestTests COMMAND bash -c "${CMAKE_CURRENT_BINARY_DIR}/run.sh")
+
+endif()
diff --git a/examples/example.djinni b/examples/example.djinni
new file mode 100755
index 0000000..4c13eea
--- /dev/null
+++ b/examples/example.djinni
@@ -0,0 +1,22 @@
+item_list = record {
+    items: list<string>;
+}
+
+sort_order = enum {
+    ascending;
+    descending;
+    random;
+}
+
+sort_items = interface +c {
+    # For the iOS / Android demo
+    sort(order: sort_order, items: item_list);
+    static create_with_listener(listener: textbox_listener): sort_items;
+
+    # For the localhost / command-line demo
+    static run_sort(items: item_list): item_list;
+}
+
+textbox_listener = interface +j +o +w {
+    update(items: item_list);
+}
diff --git a/examples/example.yaml b/examples/example.yaml
new file mode 100644
index 0000000..1d345c1
--- /dev/null
+++ b/examples/example.yaml
@@ -0,0 +1,71 @@
+# This is an example YAML file for being imported in other projects.
+# It holds all necessary information for Djinni to integrate foreign types into the generated code.
+# All fields are mandatory.
+---
+# The name to refer to this type in other .djinni files.
+# It must be unique in the entire Djinni run, so you should pick a unique prefix for your framework/library.
+name: mylib_record1
+# Specifies what kind of type this is.
+# Supports the same syntax as is used to declare types in .djinni files.
+# Examples: 'interface +c', 'record deriving(eq, or)', 'enum', 'flags', 'interface +j +o'
+# This determines how Djinni integrates this type into function parameters, fields or return types and operators.
+typedef: 'record +c deriving(eq, ord)'
+# The (potentially empty) list of required type parameters.
+params: [type_param1, type_param2]
+# This string is stripped from the value specified under "name" to ensure Djinni is referencing the correct typename in code.
+# May be an empty string if you don't have a prefix (bad!)
+prefix: 'mylib'
+cpp:
+  # The name of this type in C++ (without template arguments). Should be fully qualified.
+  typename: '::mylib::Record1'
+  # The header required in C++ to use your type. Must include "" or <>.
+  header: '"MyLib/Record1.hpp"'
+  # Only used for "record" types: determines whether it should be passed by-value in C++.
+  # If this is false it is always passed as const&
+  byValue: false
+objc:
+  # The name of this type in Objective-C.
+  typename: 'MLBRecord1'
+  # The header required in Objective-C to use your type.
+  header: '"MLB/MLBRecord1.h"'
+  # Only used for "record" types: determines the type used when boxing the record is required.
+  # Should not contain the pointer asterisk "*", protocols are not supported.
+  # This files is the same as "typename" most of the time as records are typically NSObjects and require no special boxing.
+  # However, some may not, for example NSTimeInterval is boxed to NSNumber.
+  boxed: 'MLBRecord1'
+  # Specifies whether the unboxed type is a pointer.
+  pointer: true
+  # If the type is a "record" and has "eq" deriving then this string must not be empty.
+  # It declares a well-formed expression with a single "%s" format placeholder replaced with the variable for which the hash code is needed
+  hash: '%s.hash'
+objcpp:
+  # The fully qualified name of the class containing the toCpp/fromCpp methods.
+  translator: '::mylib::djinni::objc::Record1'
+  # Where to find the translator class.
+  header: '"mylib/djinni/objc/Record1.hpp"'
+java:
+  # The name of the (fully qualified) Java type to be used.
+  typename: 'com.example.mylib.Record1'
+  # Only used for "record" types: determines the type used when boxing the record is required.
+  # This field is the same as "typename" most of the time as records are typically Objects and require no special boxing.
+  # However maybe your record has a dedicated boxed type and this field allows you to control that.
+  boxed: 'com.example.mylib.Record1'
+  # If this is true "typename" is an Object reference (and not a builtin).
+  reference: true
+  # Controls whether the type parameters as specified in "params" are forwarded as generics to Java.
+  # This is useful when templates are only used in C++ (e.g. std::chrono::duration<rep, period> versus java.time.Duration)
+  # This should be true by default (even if your type has no parameters) and only set to false if required
+  generic: true
+  # If the type is a "record" and has "eq" deriving then this string must not be empty.
+  # It declares a well-formed expression with a single "%s" format placeholder replaced with the variable for which the hash code is needed
+  hash: '%s.hashCode()'
+jni:
+  # The fully qualified name of the class containing the toCpp/fromCpp methods.
+  translator: '::mylib::djinni::jni::Record1'
+  # Where to find the translator class.
+  header: '"mylib/djinni/jni/Record1.hpp"'
+  # The type used for representations in JNI (jobject, jint, jbyteArray, etc)
+  typename: jobject
+  # The mangled type signature of your type to be found by JNI.
+  # See the JNI docs for its format
+  typeSignature: 'Lcom/example/mylib/Record1;'
diff --git a/examples/handwritten-src/cpp/sort_items_impl.cpp b/examples/handwritten-src/cpp/sort_items_impl.cpp
new file mode 100644
index 0000000..2ee7bea
--- /dev/null
+++ b/examples/handwritten-src/cpp/sort_items_impl.cpp
@@ -0,0 +1,46 @@
+#include <algorithm>
+#include <random>
+
+#include "item_list.hpp"
+#include "sort_order.hpp"
+
+#include "sort_items_impl.hpp"
+
+namespace textsort {
+
+std::shared_ptr<SortItems> SortItems::create_with_listener(const std::shared_ptr<TextboxListener>& listener) {
+    return std::make_shared<SortItemsImpl>(listener);
+}
+
+SortItemsImpl::SortItemsImpl (const std::shared_ptr<TextboxListener> & listener) {
+    this->m_listener = listener;
+}
+
+void SortItemsImpl::sort(sort_order order, const ItemList & items) {
+    auto lines = items.items;
+    switch (order) {
+        case sort_order::ASCENDING: {
+            std::sort(lines.begin(), lines.end(), std::less<std::string>());
+            break;
+        }
+        case sort_order::DESCENDING: {
+            std::sort(lines.begin(), lines.end(), std::greater<std::string>());
+            break;
+        }
+        case sort_order::RANDOM: {
+            std::shuffle(lines.begin(), lines.end(), std::default_random_engine{});
+            break;
+        }
+    }
+
+    // Pass result to client interface
+    this->m_listener->update(ItemList(lines));
+}
+
+ItemList SortItems::run_sort(const ItemList & items) {
+    auto lines = items.items;
+    std::sort(lines.begin(), lines.end(), std::less<std::string>());
+    return ItemList(lines);
+}
+
+}
diff --git a/examples/handwritten-src/cpp/sort_items_impl.hpp b/examples/handwritten-src/cpp/sort_items_impl.hpp
new file mode 100644
index 0000000..56e91ff
--- /dev/null
+++ b/examples/handwritten-src/cpp/sort_items_impl.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "sort_items.hpp"
+#include "textbox_listener.hpp"
+
+namespace textsort {
+
+class SortItemsImpl : public SortItems {
+
+public:
+    SortItemsImpl(const std::shared_ptr<TextboxListener> & listener);
+    virtual void sort(sort_order order, const ItemList & items) override;
+
+private:
+    std::shared_ptr<TextboxListener> m_listener;
+
+};
+
+}
diff --git a/examples/handwritten-src/java/com/dropbox/textsort/MainActivity.java b/examples/handwritten-src/java/com/dropbox/textsort/MainActivity.java
new file mode 100644
index 0000000..d60ec5b
--- /dev/null
+++ b/examples/handwritten-src/java/com/dropbox/textsort/MainActivity.java
@@ -0,0 +1,50 @@
+package com.dropbox.textsort;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.EditText;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class MainActivity extends Activity {
+
+    private EditText text;
+    private SortItems sortItemsInterface;
+    private TextboxListener textboxListener;
+
+    static {
+        System.loadLibrary("android-app");
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        text = (EditText) findViewById(R.id.editText);
+        textboxListener = new TextboxListenerImpl(text);
+        // Call JNI to initiate the SortItems object from the given textboxListener and translate to Java
+        sortItemsInterface = SortItems.createWithListener(textboxListener);
+    }
+
+    public void sort(SortOrder order) {
+        String str = text.getText().toString();
+        ArrayList<String> items = new ArrayList<String>(Arrays.asList(str.split("\n")));
+        ItemList itemList = new ItemList(items);
+        sortItemsInterface.sort(order, itemList);
+    }
+
+    public void sortAsc(View view) {
+        this.sort(SortOrder.ASCENDING);
+    }
+
+    public void sortDesc(View view) {
+        this.sort(SortOrder.DESCENDING);
+    }
+
+    public void sortRandom(View view) {
+        this.sort(SortOrder.RANDOM);
+    }
+}
diff --git a/examples/handwritten-src/java/com/dropbox/textsort/TextboxListenerImpl.java b/examples/handwritten-src/java/com/dropbox/textsort/TextboxListenerImpl.java
new file mode 100644
index 0000000..38c34a0
--- /dev/null
+++ b/examples/handwritten-src/java/com/dropbox/textsort/TextboxListenerImpl.java
@@ -0,0 +1,25 @@
+package com.dropbox.textsort;
+
+import android.widget.EditText;
+
+import java.util.ArrayList;
+
+public class TextboxListenerImpl extends TextboxListener {
+
+    private EditText mTextArea;
+
+    public TextboxListenerImpl(EditText textArea) {
+        this.mTextArea = textArea;
+    }
+
+    @Override
+    public void update(ItemList items) {
+        ArrayList<String> list = items.getItems();
+        StringBuilder builder = new StringBuilder();
+        for (String str : list) {
+            builder.append(str);
+            builder.append("\n");
+        }
+        mTextArea.setText(builder);
+    }
+}
diff --git a/examples/handwritten-src/objc/TXSAppDelegate.h b/examples/handwritten-src/objc/TXSAppDelegate.h
new file mode 100644
index 0000000..a55a45f
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSAppDelegate.h
@@ -0,0 +1,7 @@
+#import <UIKit/UIKit.h>
+
+@interface TXSAppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (strong, nonatomic) UIWindow *window;
+
+@end
diff --git a/examples/handwritten-src/objc/TXSAppDelegate.m b/examples/handwritten-src/objc/TXSAppDelegate.m
new file mode 100644
index 0000000..c2a8403
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSAppDelegate.m
@@ -0,0 +1,38 @@
+#import "TXSAppDelegate.h"
+
+@implementation TXSAppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+    // Override point for customization after application launch.
+    return YES;
+}
+
+- (void)applicationWillResignActive:(UIApplication *)application
+{
+    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
+    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
+}
+
+- (void)applicationDidEnterBackground:(UIApplication *)application
+{
+    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
+    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
+}
+
+- (void)applicationWillEnterForeground:(UIApplication *)application
+{
+    // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
+}
+
+- (void)applicationDidBecomeActive:(UIApplication *)application
+{
+    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
+}
+
+- (void)applicationWillTerminate:(UIApplication *)application
+{
+    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
+}
+
+@end
diff --git a/examples/handwritten-src/objc/TXSTextboxListenerImpl.h b/examples/handwritten-src/objc/TXSTextboxListenerImpl.h
new file mode 100644
index 0000000..7c05eff
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSTextboxListenerImpl.h
@@ -0,0 +1,9 @@
+#import "TXSTextboxListener.h"
+#import <Foundation/Foundation.h>
+#import <UIKit/UITextView.h>
+
+@interface TXSTextboxListenerImpl : NSObject <TXSTextboxListener>
+
+- (id)initWithUITextView:(UITextView *)textView;
+
+@end
diff --git a/examples/handwritten-src/objc/TXSTextboxListenerImpl.m b/examples/handwritten-src/objc/TXSTextboxListenerImpl.m
new file mode 100644
index 0000000..be7be09
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSTextboxListenerImpl.m
@@ -0,0 +1,22 @@
+#import "TXSTextboxListenerImpl.h"
+#import "TXSItemList.h"
+
+@implementation TXSTextboxListenerImpl {
+    UITextView * _textView;
+}
+
+- (id)initWithUITextView:(UITextView *)textView
+{
+    if (self = [super init]) {
+        _textView = textView;
+    }
+    return self;
+}
+
+- (void)update:(TXSItemList *)items
+{
+    NSString *str = [items.items componentsJoinedByString:@"\n"];
+    _textView.text = str;
+}
+
+@end
diff --git a/examples/handwritten-src/objc/TXSViewController.h b/examples/handwritten-src/objc/TXSViewController.h
new file mode 100644
index 0000000..b9477af
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSViewController.h
@@ -0,0 +1,5 @@
+#import <UIKit/UIKit.h>
+
+@interface TXSViewController : UIViewController
+
+@end
diff --git a/examples/handwritten-src/objc/TXSViewController.m b/examples/handwritten-src/objc/TXSViewController.m
new file mode 100644
index 0000000..fc1eaa3
--- /dev/null
+++ b/examples/handwritten-src/objc/TXSViewController.m
@@ -0,0 +1,94 @@
+#import "TXSItemList.h"
+#import "TXSSortItems.h"
+#import "TextSort-Swift.h"
+#import "TXSTextboxListenerImpl.h"
+#import "TXSViewController.h"
+#import "TXSTextboxListener.h"
+
+#import <QuartzCore/QuartzCore.h>
+
+@interface TXSViewController ()
+
+@property (nonatomic) IBOutlet UITextView *textView;
+
+@property (nonatomic) IBOutlet UIButton *button;
+
+@property (nonatomic) IBOutlet UISwitch *switchDebugMode;
+
+@end
+
+@implementation TXSViewController {
+    TXSSortItems* _sortItemInterface;
+    id <TXSTextboxListener> _textboxListener;
+}
+
+- (void)viewDidLoad
+{
+    [super viewDidLoad];
+    // Set border for the TextArea
+    [[self.textView layer] setBorderColor:[[UIColor grayColor] CGColor]];
+    [[self.textView layer] setBorderWidth:2.3];
+    [[self.textView layer] setCornerRadius:5];
+
+    // Dismiss keyboard when not used
+    UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc]
+                                   initWithTarget:self
+                                   action:@selector(dismissKeyboard)];
+    [self.view addGestureRecognizer:tap];
+
+    [self createSorter];
+}
+
+-(void)createSorter
+{
+    if (_switchDebugMode.isOn) {
+        // Create the Swift TXSTextboxListener
+        _textboxListener = [[TXSTextboxListenerDebugableImpl alloc] initWithUITextView:self.textView];
+    }
+    else {
+        // Create the Objective-C TXSTextboxListener
+        _textboxListener = [[TXSTextboxListenerImpl alloc] initWithUITextView:self.textView];
+    }
+    
+    _sortItemInterface = [TXSSortItems createWithListener:_textboxListener];
+}
+
+-(IBAction)toggleDebugMode:(id)sender
+{
+    [self createSorter];
+}
+
+- (IBAction)sort:(id)sender
+{
+    [self sortWithOrder:TXSSortOrderAscending];
+}
+
+- (IBAction)reverseSort:(id)sender
+{
+    [self sortWithOrder:TXSSortOrderDescending];
+}
+
+- (IBAction)randomSort:(id)sender
+{
+    [self sortWithOrder:TXSSortOrderRandom];
+}
+
+- (void)sortWithOrder:(TXSSortOrder)order
+{
+    NSString *str = self.textView.text;
+    NSArray *strList = [str componentsSeparatedByString:@"\n"];
+    TXSItemList *list = [[TXSItemList alloc] initWithItems:strList];
+    [_sortItemInterface sort:order items:list];
+}
+
+- (void)dismissKeyboard
+{
+    [self.textView resignFirstResponder];
+}
+
+- (void)didReceiveMemoryWarning
+{
+    [super didReceiveMemoryWarning];
+}
+
+@end
diff --git a/examples/handwritten-src/objc/main.m b/examples/handwritten-src/objc/main.m
new file mode 100644
index 0000000..22a1d4b
--- /dev/null
+++ b/examples/handwritten-src/objc/main.m
@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+#import "TXSAppDelegate.h"
+
+int main(int argc, char * argv[])
+{
+    @autoreleasepool {
+        return UIApplicationMain(argc, argv, nil, NSStringFromClass([TXSAppDelegate class]));
+    }
+}
diff --git a/examples/handwritten-src/swift/TXSTextboxListenerDebugableImpl.swift b/examples/handwritten-src/swift/TXSTextboxListenerDebugableImpl.swift
new file mode 100644
index 0000000..015a3b7
--- /dev/null
+++ b/examples/handwritten-src/swift/TXSTextboxListenerDebugableImpl.swift
@@ -0,0 +1,21 @@
+import UIKit
+
+final class TXSTextboxListenerDebugableImpl : NSObject, TXSTextboxListener {
+    private var textView: UITextView
+    
+    @available(*, unavailable)
+    override init() {
+        fatalError("Unsupported")
+    }
+    
+    @objc(initWithUITextView:)
+    init(textView: UITextView) {
+        self.textView = textView
+    }
+    
+    func update(_ items: TXSItemList) {
+        let string = items.items.joined(separator: "\n")
+        print("TXSTextboxListenerDebugableImpl -> update \n\(string)")
+        textView.text = string
+    }
+}
diff --git a/examples/ts/demo.html b/examples/ts/demo.html
new file mode 100644
index 0000000..4fdf667
--- /dev/null
+++ b/examples/ts/demo.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>WASM Demo</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <script src="textsort-wasm.js"></script>
+  </head>
+  <body>
+    <h1>WASM Demo</h1>
+    <p>
+    <textarea id="txt" cols="40" rows="5">item1
+item3
+item5
+item2
+item4</textarea>
+    </p>
+    <button id="btnAsc">Sort Asc</button>
+    <button id="btnDesc">Sort Desc</button>
+    <button id="btnRandom">Sort Random</button>
+    <script src="bundle.js"> </script>
+  </body>
+</html>
diff --git a/examples/ts/demo.ts b/examples/ts/demo.ts
new file mode 100644
index 0000000..2e59ef9
--- /dev/null
+++ b/examples/ts/demo.ts
@@ -0,0 +1,33 @@
+import * as example from "./generated-src/ts/example";
+
+declare function Module(): Promise<example.Example_statics>;
+
+var sorter: example.SortItems;
+
+Module().then(m => {
+    sorter = m.SortItems.createWithListener(new SortListener());
+})
+
+class SortListener implements example.TextboxListener {
+    update(itemList: example.ItemList) {
+        var txt = <HTMLTextAreaElement>document.getElementById('txt');
+        txt.value = itemList.items.join('\n')
+    }
+}
+
+function sort(order: example.SortOrder): void {
+    var txt = <HTMLTextAreaElement>document.getElementById('txt');
+    var lines = txt.value.split('\n');
+    var itemList: example.ItemList = {items: lines};
+    sorter.sort(order, itemList);
+}
+
+document.getElementById('btnAsc')!.addEventListener('click', e => {
+    sort(example.SortOrder.ASCENDING)
+})
+document.getElementById('btnDesc')!.addEventListener('click', e => {
+    sort(example.SortOrder.DESCENDING)
+})
+document.getElementById('btnRandom')!.addEventListener('click', e => {
+    sort(example.SortOrder.RANDOM)
+})
diff --git a/examples/ts/run-tests-selenium.py b/examples/ts/run-tests-selenium.py
new file mode 100755
index 0000000..42f7e18
--- /dev/null
+++ b/examples/ts/run-tests-selenium.py
@@ -0,0 +1,53 @@
+#! /usr/bin/env python3
+
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+import sys
+import time
+import threading
+
+port = "8050"
+httpd = HTTPServer(("127.0.0.1", int(port)), SimpleHTTPRequestHandler)
+
+def run_server():
+    print("Serving HTTP on localhost port " + port + " (http://localhost:" + port + "/) ...")
+    httpd.serve_forever()
+
+server_thread = threading.Thread(target=run_server)
+server_thread.start()
+
+service = Service(executable_path=r'/usr/bin/chromedriver')
+options = webdriver.ChromeOptions()
+options.add_argument('--headless')
+options.add_argument('--no-sandbox')
+options.add_argument('--disable-dev-shm-usage')
+options.add_argument('--disable-gpu')
+driver = webdriver.Chrome(service=service, options=options)
+print(f"connecting web driver to http://localhost:{port}/")
+driver.get(f"http://localhost:{port}/demo.html")
+asc_button = driver.find_element(By.ID, "btnAsc")
+desc_button = driver.find_element(By.ID, "btnDesc")
+
+asc_button.click()
+print("Wait for Asc button press")
+time.sleep(0.5)
+value =  driver.find_element(By.ID, "txt").get_attribute("value")
+is_ascending_ok = value == "item1\nitem2\nitem3\nitem4\nitem5"
+print(f"text area on Sort Asc pressed:\n{value}")
+desc_button.click()
+print("Wait for Desc button press")
+time.sleep(0.5)
+value = driver.find_element(By.ID, "txt").get_attribute("value")
+print(f"text area on Sort Desc pressed:\n{value}")
+is_descending_ok = value == "item5\nitem4\nitem3\nitem2\nitem1"
+
+driver.quit()
+httpd.shutdown()
+server_thread.join()
+if is_ascending_ok and is_descending_ok:
+    exit(0)
+print(f"is_ascending_ok = {is_ascending_ok}")
+print(f"is_descending_ok = {is_descending_ok}")
+exit(1)
diff --git a/examples/ts/run.sh b/examples/ts/run.sh
new file mode 100755
index 0000000..c6a0082
--- /dev/null
+++ b/examples/ts/run.sh
@@ -0,0 +1,4 @@
+#! /usr/bin/env bash
+set -eu
+tsc
+browserify demo.js -o bundle.js
diff --git a/examples/ts/tsconfig.json b/examples/ts/tsconfig.json
new file mode 100644
index 0000000..d519cca
--- /dev/null
+++ b/examples/ts/tsconfig.json
@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "lib": ["es2020", "dom"],
+        "baseUrl": ".",
+        "strict": true,
+    },
+    "include": ["./*.ts"],
+}
diff --git a/requirements.txt b/requirements.txt
index fc947f6..19d6b76 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,4 @@
 cffi==1.14.5
 future==0.18.2
 pytest==6.2.5
+selenium==4.15.2
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 92c4709..7e4aa2e 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -9,8 +9,6 @@ endif()
 
 enable_testing()
 
-include(Djinni.cmake)
-
 add_djinni_target(DjinniAllTests
   IDL "djinni/all.djinni"
   IDL_INCLUDE_PATH "djinni/vendor"
@@ -35,6 +33,11 @@ add_djinni_target(DjinniAllTests
   CPPCLI_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/cppcli"
   CPPCLI_NAMESPACE "Djinni::TestSuite"
   CPPCLI_INCLUDE_CPP_PREFIX "cpp/"
+  WASM_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/wasm"
+  WASM_NAMESPACE "testsuite"
+  TS_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/ts"
+  TS_MODULE "test"
+  TS_SUPPORT_FILES_OUT "${CMAKE_CURRENT_BINARY_DIR}/ts-support-lib"
   YAML_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/yaml"
   YAML_PREFIX "test_"
 
@@ -44,6 +47,8 @@ add_djinni_target(DjinniAllTests
   OBJC_OUT_FILES    OBJC_GENERATED_SRCS
   OBJCPP_OUT_FILES  OBJCPP_GENERATED_SRCS
   CPPCLI_OUT_FILES  CPPCLI_GENERATED_SRCS
+  WASM_OUT_FILES    WASM_GENERATED_SRCS
+  TS_OUT_FILES      TS_GENERATED_SRCS
   YAML_OUT_FILE     YAML_GENERATED_SRCS
 )
 
@@ -72,6 +77,10 @@ add_djinni_target(DjinniWCharTests
   CPPCLI_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/cppcli"
   CPPCLI_NAMESPACE "Djinni::TestSuite"
   CPPCLI_INCLUDE_CPP_PREFIX "cpp/"
+  WASM_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/wasm"
+  WASM_NAMESPACE "testsuite"
+  TS_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/ts"
+  TS_MODULE "test_wchar"
   YAML_OUT "${CMAKE_CURRENT_BINARY_DIR}/generated-src/yaml"
   YAML_PREFIX "test_"
 
@@ -81,6 +90,8 @@ add_djinni_target(DjinniWCharTests
   OBJC_OUT_FILES    WCHAR_OBJC_GENERATED_SRCS
   OBJCPP_OUT_FILES  WCHAR_OBJCPP_GENERATED_SRCS
   CPPCLI_OUT_FILES  WCHAR_CPPCLI_GENERATED_SRCS
+  WASM_OUT_FILES    WCHAR_WASM_GENERATED_SRCS
+  TS_OUT_FILES      WCHAR_TS_GENERATED_SRCS
   YAML_OUT_FILE     WCHAR_YAML_GENERATED_SRCS
 )
 
@@ -106,17 +117,22 @@ file(GLOB_RECURSE OBJC_HANDWRITTEN_SRCS "handwritten-src/objc/impl/*")
 file(GLOB_RECURSE OBJC_TEST_SRCS "handwritten-src/objc/tests/*")
 file(GLOB_RECURSE C_WRAPPER_HANDWRITTEN_SRCS "handwritten-src/cwrapper/*")
 file(GLOB_RECURSE PYCPP_HANDWRITTEN_SRCS "handwritten-src/pycpp/*")
+file(GLOB_RECURSE WASM_HANDWRITTEN_SRCS "handwritten-src/wasm/*")
+file(GLOB_RECURSE TS_HANDWRITTEN_SRCS "handwritten-src/ts/*")
 
 source_group("handwritten-cpp"  FILES ${CPP_HANDWRITTEN_SRCS})
 source_group("handwritten-objc" FILES ${OBJC_HANDWRITTEN_SRCS})
 source_group("java-tests"       FILES ${JAVA_TEST_SRCS})
 source_group("objc-tests"       FILES ${OBJC_TEST_SRCS})
+source_group("wasm-tests")
 
 source_group("generated-cpp"    FILES ${CPP_GENERATED_SRCS})
 source_group("generated-java"   FILES ${JAVA_GENERATED_SRCS})
 source_group("generated-jni"    FILES ${JNI_GENERATED_SRCS})
 source_group("generated-objc"   FILES ${OBJC_GENERATED_SRCS})
 source_group("generated-objcpp" FILES ${OBJCPP_GENERATED_SRCS})
+source_group("generated-wasm"   FILES ${WASM_GENERATED_SRCS})
+source_group("generated-ts"     FILES ${TS_GENERATED_SRCS})
 source_group("generated-yaml"   FILES ${YAML_GENERATED_SRCS})
 
 source_group("generated-cpp"    FILES ${WCHAR_CPP_GENERATED_SRCS})
@@ -124,6 +140,8 @@ source_group("generated-java"   FILES ${WCHAR_JAVA_GENERATED_SRCS})
 source_group("generated-jni"    FILES ${WCHAR_JNI_GENERATED_SRCS})
 source_group("generated-objc"   FILES ${WCHAR_OBJC_GENERATED_SRCS})
 source_group("generated-objcpp" FILES ${WCHAR_OBJCPP_GENERATED_SRCS})
+source_group("generated-wasm"   FILES ${WCHAR_WASM_GENERATED_SRCS})
+source_group("generated-ts"     FILES ${WCHAR_TS_GENERATED_SRCS})
 source_group("generated-yaml"   FILES ${WCHAR_YAML_GENERATED_SRCS})
 
 if(DJINNI_WITH_JNI)
@@ -203,6 +221,56 @@ if(DJINNI_WITH_OBJC)
 endif()
 
 
+if(DJINNI_WITH_WASM)
+  set(DjinniWasmTest "test-wasm")
+
+  add_executable(${DjinniWasmTest} 
+      ${CPP_HANDWRITTEN_SRCS}
+      ${CPP_GENERATED_SRCS}
+      ${WASM_GENERATED_SRCS}
+      ${TS_GENERATED_SRCS}
+      ${WCHAR_CPP_GENERATED_SRCS}
+      ${WCHAR_WASM_GENERATED_SRCS}
+      ${WCHAR_TS_GENERATED_SRCS}
+    )
+    target_include_directories(${DjinniWasmTest} PUBLIC
+      ${CMAKE_SOURCE_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/handwritten-src/cpp
+      ${CMAKE_CURRENT_BINARY_DIR}/generated-src/cpp
+      ${CMAKE_CURRENT_BINARY_DIR}/generated-src/wasm
+    )
+
+    set(WASM_CC_FLAGS "-s MAIN_MODULE=1 -fexceptions")
+    set_target_properties(${DjinniWasmTest} PROPERTIES COMPILE_FLAGS ${WASM_CC_FLAGS})
+    
+    string(JOIN " " EMSCRIPTEN_LINK_OPTIONS
+      "-s WASM=1"
+      "--bind"  # Compiles the source code using the Embind bindings to connect C/C++ and JavaScript
+      "-s MALLOC=emmalloc"  # Switch to using the much smaller implementation
+      "-s MODULARIZE=1"  # Allows us to manually invoke the initialization of wasm
+      "-s WASM_BIGINT=1" # We need to pass int64_t
+    )
+
+    set(WASM_LINK_FLAGS "${EMSCRIPTEN_LINK_OPTIONS} -fexceptions")
+    set_target_properties(${DjinniWasmTest} PROPERTIES LINK_FLAGS ${WASM_LINK_FLAGS})
+    set(CMAKE_EXECUTABLE_SUFFIX ".js")
+    
+    target_link_libraries(${DjinniWasmTest} PUBLIC djinni-support-lib::djinni-support-lib embind)
+
+    add_custom_target(DjinniWasmTestCopy)
+    file(GLOB DjinniWasmTestResources ${CMAKE_CURRENT_SOURCE_DIR}/handwritten-src/ts/*)
+    foreach(ResourceFile ${DjinniWasmTestResources})
+      add_custom_command(TARGET ${DjinniWasmTest} PRE_BUILD
+                        COMMAND ${CMAKE_COMMAND} -E
+                            copy ${ResourceFile} $<TARGET_FILE_DIR:${DjinniWasmTest}>)
+    endforeach()
+    add_dependencies(${DjinniWasmTest} DjinniWasmTestCopy)
+
+    add_test(NAME DjinniWasmTestTests COMMAND bash -c "${CMAKE_CURRENT_BINARY_DIR}/run.sh")
+
+endif()
+
+
 if(DJINNI_WITH_PYTHON)
   # There's no YAML support in Djinni for Python yet.
   set(FILTERED_CPP_HANDWRITTEN_SRCS ${CPP_HANDWRITTEN_SRCS})
diff --git a/test-suite/djinni/client_interface.djinni b/test-suite/djinni/client_interface.djinni
index 87a88ea..63ae16f 100755
--- a/test-suite/djinni/client_interface.djinni
+++ b/test-suite/djinni/client_interface.djinni
@@ -6,7 +6,7 @@ client_returned_record = record {
 } deriving (parcelable)
 
 # Client interface
-client_interface = interface +j +o +p +s {
+client_interface = interface +j +o +w +p +s {
     # Returns record of given string
     get_record(record_id: i64, utf8string: string, misc: optional<string>): client_returned_record;
 	identifier_check(data: binary, r: i32, jret: i64): f64;
diff --git a/test-suite/djinni/enum.djinni b/test-suite/djinni/enum.djinni
index ce4061d..01bd26a 100644
--- a/test-suite/djinni/enum.djinni
+++ b/test-suite/djinni/enum.djinni
@@ -19,7 +19,7 @@ enum_usage_record = record {
     m: map<color, color>;
 } deriving(parcelable)
 
-enum_usage_interface = interface +c +j +o {
+enum_usage_interface = interface +c +j +o +w {
     e(e: color): color;
     o(o: optional<color>): optional<color>;
     l(l: list<color>): list<color>;
diff --git a/test-suite/djinni/exception.djinni b/test-suite/djinni/exception.djinni
index fe8ab12..92b81a0 100644
--- a/test-suite/djinni/exception.djinni
+++ b/test-suite/djinni/exception.djinni
@@ -1,4 +1,10 @@
+throwing_interface = interface +w {
+    throw_exception();
+}
+
 cpp_exception = interface +c {
     throw_an_exception(): i32;
+    call_throwing_interface(cb: throwing_interface): i32;
+    call_throwing_and_catch(cb: throwing_interface): string;
     static get(): cpp_exception;
 }
diff --git a/test-suite/djinni/test.djinni b/test-suite/djinni/test.djinni
index 773555a..69027e9 100644
--- a/test-suite/djinni/test.djinni
+++ b/test-suite/djinni/test.djinni
@@ -29,7 +29,7 @@ test_helpers = interface +c {
     static check_enum_map(m: map<color, string>);
     static check_enum(c: color);
 
-    static token_id(t: user_token): user_token;
+    static token_id(t: optional<user_token>): optional<user_token>;
     static create_cpp_token(): user_token;
     static check_cpp_token(t: user_token);
     static cpp_token_id(t: user_token): i64;
diff --git a/test-suite/djinni/user_token.djinni b/test-suite/djinni/user_token.djinni
index 92424f3..f58aeed 100644
--- a/test-suite/djinni/user_token.djinni
+++ b/test-suite/djinni/user_token.djinni
@@ -1,3 +1,3 @@
-user_token = interface +c +j +o +s {
+user_token = interface +c +j +o +w +s {
   whoami() : string;
 }
diff --git a/test-suite/djinni/vendor/third-party/date.yaml b/test-suite/djinni/vendor/third-party/date.yaml
index 0006794..ac28448 100644
--- a/test-suite/djinni/vendor/third-party/date.yaml
+++ b/test-suite/djinni/vendor/third-party/date.yaml
@@ -35,3 +35,10 @@ cs:
   header: '"djinni/cppcli/Marshal.hpp"'
   typename: 'System::DateTime'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Date'
+  header: '"djinni_wasm.hpp"'
+ts:
+  typename: 'Date'
+  module: ''
diff --git a/test-suite/djinni/vendor/third-party/duration.yaml b/test-suite/djinni/vendor/third-party/duration.yaml
index 70f13ed..cf13883 100755
--- a/test-suite/djinni/vendor/third-party/duration.yaml
+++ b/test-suite/djinni/vendor/third-party/duration.yaml
@@ -36,6 +36,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: h
 typedef: 'record'
@@ -70,6 +77,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_h'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: min
 typedef: 'record'
@@ -104,6 +118,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_min'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: s
 typedef: 'record'
@@ -138,6 +159,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_s'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: ms
 typedef: 'record'
@@ -172,6 +200,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_ms'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: us
 typedef: 'record'
@@ -206,6 +241,13 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_us'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
 ---
 name: ns
 typedef: 'record'
@@ -240,3 +282,10 @@ cs:
   header: '"Duration-cs.hpp"'
   typename: 'System::TimeSpan'
   reference: false
+wasm:
+  typename: 'em::val'
+  translator: '::djinni::Duration_ns'
+  header: '"Duration-wasm.hpp"'
+ts:
+  typename: 'number'
+  module: ''
diff --git a/test-suite/handwritten-src/cpp/Duration-wasm.hpp b/test-suite/handwritten-src/cpp/Duration-wasm.hpp
new file mode 100644
index 0000000..68c37f8
--- /dev/null
+++ b/test-suite/handwritten-src/cpp/Duration-wasm.hpp
@@ -0,0 +1,38 @@
+#pragma once
+#include "djinni_wasm.hpp"
+#include <cassert>
+#include <chrono>
+
+namespace djinni
+{
+    template<class Ratio>
+    struct DurationPeriod;
+
+    using Duration_h   = DurationPeriod<std::ratio<3600>>;
+    using Duration_min = DurationPeriod<std::ratio<60>>;
+    using Duration_s   = DurationPeriod<std::ratio<1>>;
+    using Duration_ms  = DurationPeriod<std::milli>;
+    using Duration_us  = DurationPeriod<std::micro>;
+    using Duration_ns  = DurationPeriod<std::nano>;
+
+    template<class Rep, class Period>
+    struct Duration;
+
+    template<class Rep, class Ratio>
+    struct Duration<Rep, DurationPeriod<Ratio>>
+    {
+        using CppType = std::chrono::duration<typename Rep::CppType, Ratio>;
+        using JsType = em::val; // js duration is a plain number (milliseconds in double)
+
+        using Boxed = Duration;
+
+        static CppType toCpp(const JsType& j)
+        {
+            return std::chrono::duration_cast<CppType>(std::chrono::nanoseconds(static_cast<int64_t>(j.as<double>() * 1000000)));
+        }
+        static JsType fromCpp(const CppType& c)
+        {
+            return JsType{static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(c).count()) / 1000000};
+        }
+    };
+}
diff --git a/test-suite/handwritten-src/cpp/cpp_exception_impl.cpp b/test-suite/handwritten-src/cpp/cpp_exception_impl.cpp
index e420cef..936f21c 100644
--- a/test-suite/handwritten-src/cpp/cpp_exception_impl.cpp
+++ b/test-suite/handwritten-src/cpp/cpp_exception_impl.cpp
@@ -1,14 +1,29 @@
-#include "cpp_exception_impl.hpp"
-#include <exception>
-
-namespace testsuite {
-
-int32_t CppExceptionImpl::throw_an_exception() {
-    throw ExampleException();
-}
-
-std::shared_ptr<CppException> CppException::get() {
-    return std::make_shared<CppExceptionImpl>();
-}
-
-} // namespace testsuite
+#include "cpp_exception_impl.hpp"
+#include "throwing_interface.hpp"
+#include <exception>
+
+namespace testsuite {
+
+int32_t CppExceptionImpl::throw_an_exception() {
+    throw ExampleException();
+}
+
+int32_t CppExceptionImpl::call_throwing_interface(const /*not-null*/ std::shared_ptr<ThrowingInterface>& cb) {
+    cb->throw_exception();
+    return 0;
+}
+
+std::string CppExceptionImpl::call_throwing_and_catch(const /*not-null*/ std::shared_ptr<ThrowingInterface>& cb) {
+    try {
+        cb->throw_exception();
+    } catch (std::exception& e) {
+        return e.what();
+    }
+    return {};
+}
+
+std::shared_ptr<CppException> CppException::get() {
+    return std::make_shared<CppExceptionImpl>();
+}
+
+} // namespace testsuite
diff --git a/test-suite/handwritten-src/cpp/cpp_exception_impl.hpp b/test-suite/handwritten-src/cpp/cpp_exception_impl.hpp
index a0a7b87..7cd6ae7 100644
--- a/test-suite/handwritten-src/cpp/cpp_exception_impl.hpp
+++ b/test-suite/handwritten-src/cpp/cpp_exception_impl.hpp
@@ -1,23 +1,25 @@
-#include "cpp_exception.hpp"
-#include <exception>
-
-namespace testsuite {
-
-class ExampleException: public std::exception {
-    virtual const char* what() const throw() {
-        return "Exception Thrown";
-    }
-};
-
-extern ExampleException EXAMPLE_EXCEPTION;
-
-class CppExceptionImpl : public CppException {
-    public:
-    CppExceptionImpl() {}
-    virtual ~CppExceptionImpl() {}
-
-    virtual int32_t throw_an_exception () override;
-};
-
-} // namespace testsuite
-
+#include "cpp_exception.hpp"
+#include <exception>
+
+namespace testsuite {
+
+class ExampleException: public std::exception {
+    virtual const char* what() const throw() {
+        return "Exception Thrown";
+    }
+};
+
+extern ExampleException EXAMPLE_EXCEPTION;
+
+class CppExceptionImpl : public CppException {
+    public:
+    CppExceptionImpl() {}
+    virtual ~CppExceptionImpl() {}
+
+    virtual int32_t throw_an_exception () override;
+    virtual int32_t call_throwing_interface(const /*not-null*/ std::shared_ptr<ThrowingInterface>& cb) override;
+    virtual std::string call_throwing_and_catch(const /*not-null*/ std::shared_ptr<ThrowingInterface>& cb) override;
+};
+
+} // namespace testsuite
+
diff --git a/test-suite/handwritten-src/js/ArrayTests.js b/test-suite/handwritten-src/js/ArrayTests.js
new file mode 100644
index 0000000..0c091db
--- /dev/null
+++ b/test-suite/handwritten-src/js/ArrayTests.js
@@ -0,0 +1,31 @@
+class ArrayTest {
+    constructor(module) {
+        this.module = module;
+    }
+    testStringArray() {
+        var inputStrings = ['1', '2', '3'];
+        var expectedStrings = ['3', '2', '1'];
+        assertArrayEq(this.module.testsuite.TestArray.testStringArray(inputStrings), expectedStrings);
+    }
+
+    testIntArray() {
+        var inputIntegers = new Uint32Array([1,2,3]);
+        var expectedIntegers = new Uint32Array([3,2,1]);
+        assertArrayEq(this.module.testsuite.TestArray.testIntArray(inputIntegers), expectedIntegers);
+    }
+
+    testRecordArray() {
+        var inputRecords = [{x:1, y:1}, {x:2, y:2}, {x:3, y:3}];
+        var expectedRecords = [{x:3, y:3}, {x:2, y:2}, {x:1, y:1}];
+        assertArrayEq(this.module.testsuite.TestArray.testRecordArray(inputRecords), expectedRecords);
+    }
+    
+    testArrayofArray() {
+        var inputArrays = [new Uint32Array([1,1,1]), new Uint32Array([2,2,2]), new Uint32Array([3,3,3])];
+        var expectedArrays = [new Uint32Array([3,3,3]), new Uint32Array([2,2,2]), new Uint32Array([1,1,1])];
+        var outputArrays = this.module.testsuite.TestArray.testArrayOfArray(inputArrays);
+        assertArrayEq(outputArrays, expectedArrays);
+    }
+}
+
+allTests.push(ArrayTest);
diff --git a/test-suite/handwritten-src/js/AsyncTest.js b/test-suite/handwritten-src/js/AsyncTest.js
new file mode 100644
index 0000000..acd3e32
--- /dev/null
+++ b/test-suite/handwritten-src/js/AsyncTest.js
@@ -0,0 +1,103 @@
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function asyncFunc() {
+    await sleep(10);
+    return 36;
+}
+
+async function asyncException() {
+    await sleep(10);
+    throw new Error("123");
+}
+
+class AsyncInterfaceImpl {
+    async futureRoundtrip(f) {
+        const i = await f;
+        return i.toString();
+    }
+}
+
+class AsyncTest {
+    constructor(module) {
+        this.module = module;
+    }
+    async testConsumeNativeFuture() {
+        const r = await this.module.testsuite.TestHelpers.getAsyncResult();
+        assertEq(r, 42);
+    }
+
+    async testConsumeNativeFutureAltSyntax() {
+        return this.module.testsuite.TestHelpers.getAsyncResult().then(res => assertEq(res, 42)).catch(e => assertTrue(false));
+    }
+
+    async testFutureRoundtrip() {
+        const s = await this.module.testsuite.TestHelpers.futureRoundtrip(asyncFunc());
+        const r = parseInt(s);
+        assertEq(r, 36);
+    }
+
+    async testVoidRoundTrip() {
+        await this.m.testsuite.TestHelpers.voidAsyncMethod(sleep(10));
+    }
+
+    async testOptionalFutureUnsetValue() {
+        assertUndefined(await this.m.testsuite.TestHelpers.addOneIfPresent(Promise.resolve(undefined)));
+    }
+
+    async testOptionalFutureSetValue() {
+        assertEq(await this.m.testsuite.TestHelpers.addOneIfPresent(Promise.resolve(10)), 11);
+    }
+
+    async testFutureRoundtripWithException() {
+        var s = null;
+        try {
+            const s = await this.module.testsuite.TestHelpers.futureRoundtrip(asyncException());
+            const r = parseInt(s);
+            assertEq(r, 36);
+        } catch (e) {
+            s = e.message;
+        }
+        console.log(s);
+        assertEq(s, "123");
+    }
+
+    async testFutureRoundtripBackwards() {
+        const s = await this.module.testsuite.TestHelpers.checkAsyncInterface(new AsyncInterfaceImpl());
+        assertEq(s, "36");
+    }
+
+    async testFutureComposition() {
+        const s = await this.module.testsuite.TestHelpers.checkAsyncComposition(new AsyncInterfaceImpl());
+        assertEq(s, "42");
+    }
+
+    async testEarlyThrow() {
+        const r = this.module.testsuite.TestHelpers.asyncEarlyThrow();
+        let s = null;
+        try {
+            await r;
+        } catch (e) {
+            s = e.message;
+        }
+        assertEq(s, "C++: error");
+    }
+
+    async testReturnExceptionString_valid() {
+        const result = await this.module.testsuite.TestHelpers.returnExceptionString(Promise.reject(new Error("hello")));
+        assertTrue(result.startsWith("Error: hello"));
+    }
+
+    async testReturnExceptionString_null() {
+        const result = await this.module.testsuite.TestHelpers.returnExceptionString(Promise.reject(null));
+        assertEq(result, "JS promise rejected with non-error type");
+    }
+
+    async testReturnExceptionString_undefined() {
+        const result = await this.module.testsuite.TestHelpers.returnExceptionString(Promise.reject(undefined));
+        assertEq(result, "JS promise rejected with non-error type");
+    }
+}
+
+allTests.push(AsyncTest);
diff --git a/test-suite/handwritten-src/js/ClientInterfaceTest.js b/test-suite/handwritten-src/js/ClientInterfaceTest.js
new file mode 100644
index 0000000..9b9a60f
--- /dev/null
+++ b/test-suite/handwritten-src/js/ClientInterfaceTest.js
@@ -0,0 +1,50 @@
+class ClientInterfaceImpl {
+    getRecord(id, utf8String, misc) {
+        if (utf8String != "Non-ASCII /\0 非 ASCII 字符" && utf8String != "Hello World!") {
+            throw new Error("Unexpected string. Check UTF-8?");
+        }
+        return {recordId: id,
+                content: utf8String,
+                misc: misc};
+    }
+    identifierCheck(data, r, jret) {
+        return 0.0;
+    }
+    returnStr() {
+        return "test";
+    }
+    methTakingInterface(i) {
+        if (i != null) {return i.returnStr();} else {return "";}
+    }
+    methTakingOptionalInterface(i) {
+        if (i != null) {return i.returnStr();} else {return "";}
+    }
+}
+
+class ClientInterfaceTest {
+    constructor(module) {
+        this.module = module;
+    }
+    setUp() {
+        this.jsClientInterface = new ClientInterfaceImpl();
+    }
+    testClientReturn() {
+        this.module.testsuite.TestHelpers.checkClientInterfaceAscii(this.jsClientInterface);
+    }
+
+    testClientReturnUTF8() {
+        this.module.testsuite.TestHelpers.checkClientInterfaceNonascii(this.jsClientInterface);
+    }
+
+    testClientInterfaceArgs() {
+        this.module.testsuite.TestHelpers.checkClientInterfaceArgs(this.jsClientInterface);
+    }
+
+    testReverseClientInterfaceArgs() {
+        var i = this.module.testsuite.ReverseClientInterface.create();
+        assertEq(i.methTakingInterface(i), "test");
+        assertEq(i.methTakingOptionalInterface(i), "test");
+    }
+}
+
+allTests.push(ClientInterfaceTest);
diff --git a/test-suite/handwritten-src/js/ConstantsTest.js b/test-suite/handwritten-src/js/ConstantsTest.js
new file mode 100644
index 0000000..f7d2be5
--- /dev/null
+++ b/test-suite/handwritten-src/js/ConstantsTest.js
@@ -0,0 +1,18 @@
+class ConstantsTest {
+    constructor(module) {
+        this.m = module;
+    }
+    testConstPrimitives() {
+        assertEq(this.m.testsuite.Constants.I8_CONSTANT, 1);
+        assertEq(this.m.testsuite.Constants.OPT_I8_CONSTANT, 1);
+        assertEq(this.m.testsuite.Constants.STRING_CONSTANT, "string-constant");
+    }
+    testConstRecords() {
+        assertEq(this.m.testsuite.Constants.OBJECT_CONSTANT, {
+            someInteger: 3,
+            someString: "string-constant"
+        });
+    }
+}
+
+allTests.push(ConstantsTest);
diff --git a/test-suite/handwritten-src/js/CppExceptionTest.js b/test-suite/handwritten-src/js/CppExceptionTest.js
new file mode 100644
index 0000000..1f85261
--- /dev/null
+++ b/test-suite/handwritten-src/js/CppExceptionTest.js
@@ -0,0 +1,61 @@
+class JsThrower {
+    throwException() {
+        throw new Error("JS Error");
+    }
+}
+
+class CppThrower {
+    constructor(cpp) {
+        this.cpp = cpp;
+    }
+    throwException() {
+        this.cpp.throwAnException();
+    }
+}
+
+class CppExceptionTest {
+    constructor(module) {
+        this.m = module;
+    }
+
+    setUp() {
+        this.cppInterface = this.m.testsuite.CppException.get();
+    }
+
+    // C++ exception can be handled in JS
+    testCppException() {
+        var thrown = null;
+        try {
+            this.cppInterface.throwAnException();
+        } catch (e) {
+            thrown = e;
+        }
+        assertEq(thrown.message, "C++: Exception Thrown");
+    }
+
+    // JS exception passes through C++ code and handled in JS higher up in the stack
+    testJsExceptionPassthrough() {
+        var thrown = null;
+        try {
+            this.cppInterface.callThrowingInterface(new JsThrower());
+        } catch (e) {
+            thrown = e;
+        }
+        assertTrue(thrown instanceof Error);
+        assertEq(thrown.message, "JS Error");
+    }
+    // JS exception can be handled in C++
+    testJsExceptionHandledByCpp() {
+        let res = this.cppInterface.callThrowingAndCatch(new JsThrower());
+        // the stack info from the js exception
+        assertTrue(res.length > 0 );
+    }
+
+    // C++ exception passes through JS code and handled in C++ higher up in the stack
+    testCppExceptionPassthrough() {
+        let res = this.cppInterface.callThrowingAndCatch(new CppThrower(this.cppInterface));
+        assertEq(res, "Exception Thrown");
+    }
+}
+
+allTests.push(CppExceptionTest);
diff --git a/test-suite/handwritten-src/js/DataTest.js b/test-suite/handwritten-src/js/DataTest.js
new file mode 100644
index 0000000..b104bf8
--- /dev/null
+++ b/test-suite/handwritten-src/js/DataTest.js
@@ -0,0 +1,57 @@
+class DataTest {
+    constructor(module) {
+        this.m = module;
+    }
+
+    setUp() {
+        this.test = this.m.testsuite.DataRefTest.create();
+    }
+
+    testSend() {
+        var input = [0, 1, 2, 3];
+        var buf = this.m.allocateWasmBuffer(4);
+        buf.set(input);
+        this.test.sendData(buf);
+        var output = this.test.retriveAsBin();
+        assertArrayEq(input, output);
+    }
+
+    testSendMutable() {
+        var input = [0, 1, 2, 3];
+        var buf = this.m.allocateWasmBuffer(4);
+        buf.set(input);
+        this.test.sendMutableData(buf);
+        assertArrayEq([3, 2, 1, 0], buf);
+    }
+
+    testGenerateData() {
+        var buf = this.test.generateData();
+        assertArrayEq([0, 1, 2, 3], buf);
+    };
+
+    testDataFromVec() {
+        var buf = this.test.dataFromVec();
+        assertArrayEq([0, 1, 2, 3], buf);
+    }
+
+    testDataFromStr() {
+        var buf = this.test.dataFromStr();
+        // codepoints of a, b, c, d
+        assertArrayEq([97, 98, 99, 100], buf);
+    }
+
+    testSendDataView() {
+        var input = [0, 1, 2, 3];
+        var buf = this.m.allocateWasmBuffer(4);
+        buf.set(input);
+        var output = this.test.sendDataView(buf);
+        assertArrayEq(input, output);
+    }
+    
+    testRecvDataView() {
+        var output = this.test.recvDataView();
+        assertArrayEq([0, 1, 2, 3], output);
+    }
+}
+
+allTests.push(DataTest);
diff --git a/test-suite/handwritten-src/js/DurationTest.js b/test-suite/handwritten-src/js/DurationTest.js
new file mode 100644
index 0000000..4581075
--- /dev/null
+++ b/test-suite/handwritten-src/js/DurationTest.js
@@ -0,0 +1,42 @@
+function nanos(x) { return x / 1000000; }
+function micros(x) { return x / 1000; }
+function millis(x) { return x; }
+function seconds(x) { return x * 1000; }
+function minutes(x) { return x * 1000 * 60; }
+function hours(x) { return x * 1000 * 3600; }
+
+class DurationTest {
+    constructor(module) {
+        this.m = module;
+    }
+    test() {
+        assertEq(this.m.testsuite.TestDuration.hoursString(hours(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.minutesString(minutes(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.secondsString(seconds(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.millisString(millis(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.microsString(micros(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.nanosString(nanos(1)), "1");
+
+        assertEq(this.m.testsuite.TestDuration.hours(1), hours(1));
+        assertEq(this.m.testsuite.TestDuration.minutes(1), minutes(1));
+        assertEq(this.m.testsuite.TestDuration.seconds(1), seconds(1));
+        assertEq(this.m.testsuite.TestDuration.millis(1), millis(1));
+        assertEq(this.m.testsuite.TestDuration.micros(1), micros(1));
+        assertEq(this.m.testsuite.TestDuration.nanos(1), nanos(1));
+
+        assertEq(this.m.testsuite.TestDuration.hoursf(1.5), minutes(90));
+        assertEq(this.m.testsuite.TestDuration.minutesf(1.5), seconds(90));
+        assertEq(this.m.testsuite.TestDuration.secondsf(1.5), millis(1500));
+        assertEq(this.m.testsuite.TestDuration.millisf(1.5), micros(1500));
+        assertEq(this.m.testsuite.TestDuration.microsf(1.5), nanos(1500));
+        assertEq(this.m.testsuite.TestDuration.nanosf(1.0), nanos(1));
+
+        assertEq(this.m.testsuite.TestDuration.box(BigInt(1)), seconds(1));
+        assertUndefined(this.m.testsuite.TestDuration.box(BigInt(-1)));
+
+        assertEq(this.m.testsuite.TestDuration.unbox(seconds(1)), 1);
+        assertEq(this.m.testsuite.TestDuration.unbox(null), -1);
+    }
+}
+
+allTests.push(DurationTest);
diff --git a/test-suite/handwritten-src/js/EnumTest.js b/test-suite/handwritten-src/js/EnumTest.js
new file mode 100644
index 0000000..f3426d6
--- /dev/null
+++ b/test-suite/handwritten-src/js/EnumTest.js
@@ -0,0 +1,63 @@
+class EnumTest {
+    constructor(module) {
+        this.m = module;
+    }
+
+    enumToString(v, e) {
+        for (var k in e) {
+            if (e[k] == v) {
+                return k;
+            }
+        }
+        return v;
+    }
+    
+    testEnumToString() {
+        assertEq(this.enumToString(this.m.testsuite.Color.RED, this.m.testsuite.Color), "RED");
+        assertEq(this.enumToString(this.m.testsuite.Color.ORANGE, this.m.testsuite.Color), "ORANGE");
+        assertEq(this.enumToString(this.m.testsuite.Color.YELLOW, this.m.testsuite.Color), "YELLOW");
+        assertEq(this.enumToString(this.m.testsuite.Color.GREEN, this.m.testsuite.Color), "GREEN");
+        assertEq(this.enumToString(this.m.testsuite.Color.BLUE, this.m.testsuite.Color), "BLUE");
+        assertEq(this.enumToString(this.m.testsuite.Color.INDIGO, this.m.testsuite.Color), "INDIGO");
+        assertEq(this.enumToString(this.m.testsuite.Color.VIOLET, this.m.testsuite.Color), "VIOLET");
+    }
+    
+    testEnumKey() {
+        var map = new Map();
+        map.set(this.m.testsuite.Color.RED, "red");
+        map.set(this.m.testsuite.Color.ORANGE, "orange");
+        map.set(this.m.testsuite.Color.YELLOW, "yellow");
+        map.set(this.m.testsuite.Color.GREEN, "green");
+        map.set(this.m.testsuite.Color.BLUE, "blue");
+        map.set(this.m.testsuite.Color.INDIGO, "indigo");
+        map.set(this.m.testsuite.Color.VIOLET, "violet");
+        this.m.testsuite.TestHelpers.checkEnumMap(map);
+    }
+    testAccessFlagRoundtrip() {
+        var flags = [
+            this.m.testsuite.AccessFlags.NOBODY,
+            this.m.testsuite.AccessFlags.EVERYBODY,
+            this.m.testsuite.AccessFlags.OWNER_READ,
+            this.m.testsuite.AccessFlags.OWNER_READ | this.m.testsuite.AccessFlags.OWNER_WRITE,
+            this.m.testsuite.AccessFlags.OWNER_READ | this.m.testsuite.AccessFlags.OWNER_WRITE | this.m.testsuite.AccessFlags.OWNER_EXECUTE,
+        ];
+        for (var i = 0; i < flags.length; ++i) {
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripAccess(flags[i]));
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripAccessBoxed(flags[i]));
+        }
+        assertUndefined(this.m.testsuite.FlagRoundtrip.roundtripAccessBoxed(null));
+    }
+    testEmptyFlagRoundtrip() {
+        var flags = [
+            this.m.testsuite.EmptyFlags.NONE,
+            this.m.testsuite.EmptyFlags.ALL,
+        ];
+        for (var i = 0; i < flags.length; ++i) {
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripEmpty(flags[i]));
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripEmptyBoxed(flags[i]));
+        }
+        assertUndefined(this.m.testsuite.FlagRoundtrip.roundtripEmptyBoxed(null));
+    }
+}
+
+allTests.push(EnumTest);
diff --git a/test-suite/handwritten-src/js/MapRecordTest.js b/test-suite/handwritten-src/js/MapRecordTest.js
new file mode 100644
index 0000000..6296443
--- /dev/null
+++ b/test-suite/handwritten-src/js/MapRecordTest.js
@@ -0,0 +1,51 @@
+class MapRecordTest {
+    constructor(module) {
+        this.m = module;
+    }
+
+    testCppMapToJavaMap() {
+        this.checkJsMap(this.m.testsuite.TestHelpers.getMap());
+    }
+
+    testEmptyCppMapToJsMap() {
+        assertEq(0, this.m.testsuite.TestHelpers.getEmptyMap().size);
+    }
+
+    testCppMapListToJsMapList() {
+        var jsMapListRecord = this.m.testsuite.TestHelpers.getMapListRecord();
+        var jsMapList = jsMapListRecord.mapList;
+        assertEq(1, jsMapList.length);
+        this.checkJsMap(jsMapList[0]);
+    }
+
+    testJsMapToCppMap() {
+        assertTrue(this.m.testsuite.TestHelpers.checkMap(this.getJsMap()));
+    }
+
+    testEmptyJsMapToCppMap() {
+        assertTrue(this.m.testsuite.TestHelpers.checkEmptyMap(new Map()));
+    }
+
+    testJsMapListToCppMapList() {
+        var jsMapList = [];
+        jsMapList.push(this.getJsMap());
+        assertTrue(this.m.testsuite.TestHelpers.checkMapListRecord({mapList: jsMapList}));
+    }
+
+    getJsMap() {
+        var jsMap = new Map();
+        jsMap.set("String1", BigInt(1));
+        jsMap.set("String2", BigInt(2));
+        jsMap.set("String3", BigInt(3));
+        return jsMap;
+    }
+
+    checkJsMap(jsMap) {
+        assertEq(3, jsMap.size);
+        assertEq(jsMap.get("String1"), BigInt(1));
+        assertEq(jsMap.get("String2"), BigInt(2));
+        assertEq(jsMap.get("String3"), BigInt(3));
+    }
+}
+
+allTests.push(MapRecordTest);
diff --git a/test-suite/handwritten-src/js/NestedCollectionTest.js b/test-suite/handwritten-src/js/NestedCollectionTest.js
new file mode 100644
index 0000000..5462894
--- /dev/null
+++ b/test-suite/handwritten-src/js/NestedCollectionTest.js
@@ -0,0 +1,27 @@
+class NestedCollectionTest {
+    constructor(module) {
+        this.m = module;
+    }
+    setUp() {
+        var jsSet1 = new Set();
+        jsSet1.add("String1");
+        jsSet1.add("String2");
+        var jsSet2 = new Set();
+        jsSet2.add("StringA");
+        jsSet2.add("StringB");
+        var jsList = [];
+        jsList.push(jsSet1);
+        jsList.push(jsSet2);
+        this.jsNestedCollection = { setList: jsList };
+    }
+    testCppNestedRecordToJsNestedCollection() {
+        var converted = this.m.testsuite.TestHelpers.getNestedCollection();
+        assertEq(this.jsNestedCollection.setList, converted.setList);
+    }
+
+    testJsNestedRecordToCppNestedCollection() {
+        assertTrue(this.m.testsuite.TestHelpers.checkNestedCollection(this.jsNestedCollection));
+    }
+}
+
+allTests.push(NestedCollectionTest);
diff --git a/test-suite/handwritten-src/js/OutcomeTest.js b/test-suite/handwritten-src/js/OutcomeTest.js
new file mode 100644
index 0000000..d041fc3
--- /dev/null
+++ b/test-suite/handwritten-src/js/OutcomeTest.js
@@ -0,0 +1,37 @@
+class OutcomeTest {
+    constructor(module) {
+        this.m = module;
+    }
+    test() {
+        // construct result outcome in native and pass to js
+        var r = this.m.testsuite.TestOutcome.getSuccessOutcome();
+        assertEq(r, {result: "hello"});
+
+        // construct error outcome in native and pass to js
+        var e = this.m.testsuite.TestOutcome.getErrorOutcome();
+        assertEq(e, {error: 42});
+
+        // result outcome and error outcome does not compare equal
+        assertNe(r, e);
+        
+        // construct result outcome in js then pass to native and back
+        assertEq(this.m.testsuite.TestOutcome.putSuccessOutcome({result:"hello"}), "hello");
+        // construct error outcome in js then pass to native and back
+        assertEq(this.m.testsuite.TestOutcome.putErrorOutcome({error:42}), 42);
+
+        // Hash equal tests are not applicable -
+        // Javascript does not support overloading the hash method
+
+        // test outcome as nested object
+        var nr = this.m.testsuite.TestOutcome.getNestedSuccessOutcome();
+        assertEq(nr.o, {result: 42});
+
+        var ne = this.m.testsuite.TestOutcome.getNestedErrorOutcome();
+        assertEq(ne.o, {error: "hello"});
+
+        assertEq(this.m.testsuite.TestOutcome.putNestedSuccessOutcome({o: {result:42}}), 42);
+        assertEq(this.m.testsuite.TestOutcome.putNestedErrorOutcome({o: {error:"hello"}}), "hello");
+    }
+}
+
+allTests.push(OutcomeTest);
diff --git a/test-suite/handwritten-src/js/PrimitiveListTest.js b/test-suite/handwritten-src/js/PrimitiveListTest.js
new file mode 100644
index 0000000..2899f4f
--- /dev/null
+++ b/test-suite/handwritten-src/js/PrimitiveListTest.js
@@ -0,0 +1,26 @@
+class PrimitiveListTest {
+    constructor(module) {
+        this.m = module;
+    }
+    setUp() {
+        var list = [BigInt(1), BigInt(2), BigInt(3)];
+        this.jsPrimitiveList = {list: list};
+    }
+    testJavaPrimitiveListToCpp()
+    {
+        assertTrue(this.m.testsuite.TestHelpers.checkPrimitiveList(this.jsPrimitiveList));
+    }
+
+    testCppPrimitiveListToJava()
+    {
+        var converted = this.m.testsuite.TestHelpers.getPrimitiveList();
+        assertArrayEq(converted.list, this.jsPrimitiveList.list);
+    }
+
+    testBinary()
+    {
+        var b = new Uint8Array([1, 2, 3]);
+        assertArrayEq(this.m.testsuite.TestHelpers.idBinary(b), b);
+    }
+}
+allTests.push(PrimitiveListTest);
diff --git a/test-suite/handwritten-src/js/PrimitivesTest.js b/test-suite/handwritten-src/js/PrimitivesTest.js
new file mode 100644
index 0000000..e0e615a
--- /dev/null
+++ b/test-suite/handwritten-src/js/PrimitivesTest.js
@@ -0,0 +1,28 @@
+class PrimitivesTest {
+    constructor(module) {
+        this.m = module;
+    }
+    testPrimitives() {
+        var p = {
+            b: true,                         // bool
+            eight: 123,                      // i8
+            sixteen: 20000,                  // i16
+            thirtytwo: 1000000000,           // i32
+            sixtyfour: 1234567890123456789n, // i64
+            fthirtytwo: 0,                   // f32
+            fsixtyfour: 1.23,                // f64
+
+            oB: true,                         // optional<bool>
+            oEight: 123,                      // optional<i8>
+            oSixteen: 20000,                  // optional<i16>
+            oThirtytwo: 1000000000,           // optional<i32>
+            oSixtyfour: 1234567890123456789n, // optional<i64>
+            oFthirtytwo: 0,                   // optional<f32>
+            oFsixtyfour: 1.23                 // optional<f64>
+        };
+        // f32 roundtrip test is not applicable to js because js has no native
+        // 32-bit floating point number.
+        assertEq(p, this.m.testsuite.TestHelpers.assortedPrimitivesId(p));
+    }
+}
+allTests.push(PrimitivesTest);
diff --git a/test-suite/handwritten-src/js/SetRecordTest.js b/test-suite/handwritten-src/js/SetRecordTest.js
new file mode 100644
index 0000000..0f397fa
--- /dev/null
+++ b/test-suite/handwritten-src/js/SetRecordTest.js
@@ -0,0 +1,24 @@
+class SetRecordTest {
+    constructor(module) {
+        this.m = module;
+    }
+    testCppSetToJavaSet() {
+        var jsSetRecord = this.m.testsuite.TestHelpers.getSetRecord();
+        var jsSet = jsSetRecord.set;
+        assertEq(3, jsSet.size);
+        assertTrue(jsSet.has("StringA"));
+        assertTrue(jsSet.has("StringB"));
+        assertTrue(jsSet.has("StringC"));
+    }
+
+    testJavaSetToCppSet() {
+        var jsSet = new Set();
+        var iSet = new Set();
+        jsSet.add("StringA");
+        jsSet.add("StringB");
+        jsSet.add("StringC");
+        var jsSetRecord = {set: jsSet, iset: iSet};
+        assertTrue(this.m.testsuite.TestHelpers.checkSetRecord(jsSetRecord));
+    }
+}
+allTests.push(SetRecordTest);
diff --git a/test-suite/handwritten-src/js/TokenTest.js b/test-suite/handwritten-src/js/TokenTest.js
new file mode 100644
index 0000000..72b1502
--- /dev/null
+++ b/test-suite/handwritten-src/js/TokenTest.js
@@ -0,0 +1,58 @@
+class JsToken {
+    whoami() {
+        return "Javascript";
+    }
+}
+
+class TokenTest {
+    constructor(module) {
+        this.m = module;
+    }
+    
+    testTokens() {
+        var jt = new JsToken();
+        assertSame(this.m.testsuite.TestHelpers.tokenId(jt), jt);
+    }
+
+    testNullToken() {
+        assertSame(this.m.testsuite.TestHelpers.tokenId(undefined), undefined);
+    }
+
+    testCppToken() {
+        var ct = this.m.testsuite.TestHelpers.createCppToken();
+        assertSame(this.m.testsuite.TestHelpers.tokenId(ct), ct);
+        this.m.testsuite.TestHelpers.checkCppToken(ct);
+        ct = null;
+    }
+
+    testTokenType() {
+        this.m.testsuite.TestHelpers.checkTokenType(new JsToken(), "Javascript");
+        this.m.testsuite.TestHelpers.checkTokenType(this.m.testsuite.TestHelpers.createCppToken(), "C++");
+        var threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkTokenType(new JsToken(), "foo");
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+        threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkTokenType(this.m.testsuite.TestHelpers.createCppToken(), "foo");
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+    }
+
+    testNotCppToken() {
+        var threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkCppToken(new JsToken());
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+    }
+}
+
+allTests.push(TokenTest);
diff --git a/test-suite/handwritten-src/js/WcharTest.js b/test-suite/handwritten-src/js/WcharTest.js
new file mode 100644
index 0000000..082395c
--- /dev/null
+++ b/test-suite/handwritten-src/js/WcharTest.js
@@ -0,0 +1,17 @@
+class WcharTest {
+    constructor(module) {
+        this.m = module;
+    }
+
+    static STR1 = "some string with unicode \u{0000}, \u{263A}, \u{D83D}\u{DCA9} symbols";
+    static STR2 = "another string with unicode \u{263B}, \u{D83D}\u{DCA8} symbols";
+
+    test() {
+        assertEq(this.m.testsuite.WcharTestHelpers.getRecord().s, WcharTest.STR1);
+        assertEq(this.m.testsuite.WcharTestHelpers.getString(), WcharTest.STR2);
+        assertEq(this.m.testsuite.WcharTestHelpers.checkString(WcharTest.STR2), true);
+        assertEq(this.m.testsuite.WcharTestHelpers.checkRecord({s: WcharTest.STR1}), true);
+    }
+}
+
+allTests.push(WcharTest);
diff --git a/test-suite/handwritten-src/js/run.sh b/test-suite/handwritten-src/js/run.sh
new file mode 100755
index 0000000..969db86
--- /dev/null
+++ b/test-suite/handwritten-src/js/run.sh
@@ -0,0 +1,4 @@
+#! /usr/bin/env bash
+set -eu
+sleep 1 && python3 -mwebbrowser http://localhost:8000/test.html &
+python3 -m http.server
diff --git a/test-suite/handwritten-src/js/test.html b/test-suite/handwritten-src/js/test.html
new file mode 100644
index 0000000..bc5b377
--- /dev/null
+++ b/test-suite/handwritten-src/js/test.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>Djinni/WASM Test</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <script src="testutils.js"></script>
+    <script src="test-wasm.js"></script>
+  </head>
+  <body>
+    <h1>Djinni/WASM Test</h1>
+    <pre id="output"></pre>
+    <script src="ConstantsTest.js"></script>
+    <script src="ClientInterfaceTest.js"></script>
+    <script src="CppExceptionTest.js"></script>
+    <script src="DurationTest.js"></script>
+    <script src="EnumTest.js"></script>
+    <script src="MapRecordTest.js"></script>
+    <script src="NestedCollectionTest.js"></script>
+    <script src="PrimitiveListTest.js"></script>
+    <script src="PrimitivesTest.js"></script>
+    <script src="SetRecordTest.js"></script>
+    <script src="TokenTest.js"></script>
+    <script src="WcharTest.js"></script>
+    <!-- Things we can't test in JS:
+         * Android parcelable
+         * Deriving ord hash nscopy
+         * Catching C++ exception (incomplete)
+         * Function prologue (not yet)
+         * Protobuf (not yet)
+      -->
+    <script>
+      Module().then(module => {
+          console.log(module);
+          runTests(module, allTests);
+      })
+    </script>
+  </body>
+</html>
diff --git a/test-suite/handwritten-src/js/testutils.js b/test-suite/handwritten-src/js/testutils.js
new file mode 100644
index 0000000..32475d2
--- /dev/null
+++ b/test-suite/handwritten-src/js/testutils.js
@@ -0,0 +1,129 @@
+var failed;
+var currentTest;
+
+function println(o) {
+    var output = document.getElementById('output');
+    if (o.startsWith('[  FAILED  ]')) {
+        var red = document.createElement("SPAN")
+        red.style.color="red";
+        red.innerText += String(o) + '\n';
+        output.appendChild(red)
+    } else if (o.startsWith('[')) {
+        var green = document.createElement("SPAN")
+        green.style.color="green";
+        green.innerText += String(o) + '\n';
+        output.appendChild(green)
+    } else {
+        var txt = document.createTextNode(String(o) + '\n')
+        output.appendChild(txt)
+    }
+}
+
+function units(n, u) {
+    u = (n == 1) ? u : u + 's';
+    return n + ' ' + u;
+}
+
+async function runTests(module, tests) {
+    failed = [];
+    var total = 0;
+    var t2 = performance.now();
+    for (const cls of tests) {
+        var t = new cls(module);
+        var count = 0;
+        var t1 = performance.now();
+        for (const m of Reflect.ownKeys(Reflect.getPrototypeOf(t))) {
+            if (m.startsWith('test')) {
+                currentTest = cls.name + '.' + m;
+                println('[ RUN      ] ' + currentTest)
+                var failedBefore = failed.length;
+                var t0 = performance.now();
+                try {
+                    if (t['setUp'] !== undefined) {t.setUp();}
+                    var r = t[m]();
+                    if (typeof r === 'object' && typeof r.then === 'function') {
+                        await r;
+                    }
+                    if (t['tearDown'] !== undefined) {t.tearDown();}
+                } catch (err) {
+                    console.log("C++ exception: " + err);
+                    assertTrue(false);
+                }
+                var status = failed.length > failedBefore ? '[  FAILED  ] ' : '[       OK ] ';
+                println(status + cls.name + '.' + m + ' (' + (performance.now() - t0) + ' ms)')
+                count++;
+            }
+        }
+        total += count;
+        println('[----------] ' + units(count, 'test') + ' from ' + cls.name + '(' + (performance.now() - t1) + ' ms total)')
+    }
+    println('[==========] ' + units(total, 'test') + ' from ' + units(tests.length, 'test suite') + ' ran. (' + (performance.now() - t2) + ' ms total)')
+    println('[  PASSED  ] ' + units(total - failed.length, 'test') + '.')
+    if (failed.length > 0) {
+        println('[  FAILED  ] ' + units(failed.length, 'test') + ', listed below:')
+        failed.forEach(function(f) {
+            println('[  FAILED  ] ' + f);
+        });
+    }
+}
+
+function deepEqual(object1, object2) {
+    if (!isObject(object1) || !isObject(object2)) {
+        return object1 == object2;
+    }
+
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = isObject(val1) && isObject(val2);
+        if (areObjects && !deepEqual(val1, val2) || !areObjects && val1 !== val2) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function isObject(object) {
+    return object != undefined && object != null && typeof object === 'object';
+}
+
+function assertTrue(a) {
+    if (!a) {
+        console.error("[  FAILED  ] " + currentTest);
+        failed.push(currentTest);
+    }
+}
+function assertFalse(a) {
+    assertTrue(!a);
+}
+function assertSame(a, b) {
+    assertTrue(a === b);
+}
+function assertNotSame(a, b) {
+    assertFalse(a === b);
+}
+function assertEq(a, b) {
+    assertTrue(deepEqual(a, b));
+}
+function assertNe(a, b) {
+    assertFalse(deepEqual(a, b));
+}
+function assertArrayEq(a, b) {
+    assertEq(a.length, b.length);
+    for (var i = 0; i < a.length; i++) {
+        assertEq(a[i], b[i]);
+    }
+}
+function assertUndefined(a) {
+    assertTrue (a === undefined);
+}
+
+var allTests = [];
diff --git a/test-suite/handwritten-src/ts/ClientInterfaceTest.ts b/test-suite/handwritten-src/ts/ClientInterfaceTest.ts
new file mode 100644
index 0000000..46023f0
--- /dev/null
+++ b/test-suite/handwritten-src/ts/ClientInterfaceTest.ts
@@ -0,0 +1,54 @@
+import {TestCase, allTests, assertEq} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class ClientInterfaceImpl implements test.ClientInterface {
+    getRecord(id: bigint, utf8String: string, misc: string | undefined) {
+        if (utf8String != "Non-ASCII /\0 非 ASCII 字符" && utf8String != "Hello World!") {
+            throw new Error("Unexpected string. Check UTF-8?");
+        }
+        return {recordId: id,
+                content: utf8String,
+                misc: misc};
+    }
+    identifierCheck(data: Uint8Array, r: number, jret: bigint) {
+        return 0.0;
+    }
+    returnStr() {
+        return "test";
+    }
+    methTakingInterface(i: test.ClientInterface | undefined) {
+        if (i) {return i.returnStr();} else {return "";}
+    }
+    methTakingOptionalInterface(i: test.ClientInterface | undefined) {
+        if (i) {return i.returnStr();} else {return "";}
+    }
+}
+
+class ClientInterfaceTest extends TestCase {
+    m: test.Test_statics;
+    jsClientInterface: test.ClientInterface;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+        this.jsClientInterface = new ClientInterfaceImpl();
+    }
+    testClientReturn() {
+        this.m.testsuite.TestHelpers.checkClientInterfaceAscii(this.jsClientInterface);
+    }
+
+    testClientReturnUTF8() {
+        this.m.testsuite.TestHelpers.checkClientInterfaceNonascii(this.jsClientInterface);
+    }
+
+    testClientInterfaceArgs() {
+        this.m.testsuite.TestHelpers.checkClientInterfaceArgs(this.jsClientInterface);
+    }
+
+    testReverseClientInterfaceArgs() {
+        var i = this.m.testsuite.ReverseClientInterface.create();
+        assertEq(i?.methTakingInterface(i), "test");
+        assertEq(i?.methTakingOptionalInterface(i), "test");
+    }
+}
+
+allTests.push(ClientInterfaceTest);
diff --git a/test-suite/handwritten-src/ts/ConstantsTest.ts b/test-suite/handwritten-src/ts/ConstantsTest.ts
new file mode 100644
index 0000000..57a48fb
--- /dev/null
+++ b/test-suite/handwritten-src/ts/ConstantsTest.ts
@@ -0,0 +1,21 @@
+import {TestCase, allTests, assertEq} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+export class ConstantsTest extends TestCase {
+    constructor(module: any) {
+        super(module);
+    }
+    testConstPrimitives() {
+        assertEq(test.Constants.I8_CONSTANT, 1);
+        assertEq(test.Constants.OPT_I8_CONSTANT, 1);
+        assertEq(test.Constants.STRING_CONSTANT, "string-constant");
+    }
+    testConstRecords() {
+        assertEq(test.Constants.OBJECT_CONSTANT, {
+            someInteger: 3,
+            someString: "string-constant"
+        });
+    }
+}
+
+allTests.push(ConstantsTest);
diff --git a/test-suite/handwritten-src/ts/CppExceptionTest.ts b/test-suite/handwritten-src/ts/CppExceptionTest.ts
new file mode 100644
index 0000000..257557a
--- /dev/null
+++ b/test-suite/handwritten-src/ts/CppExceptionTest.ts
@@ -0,0 +1,69 @@
+import {TestCase, allTests, assertEq, assertTrue} from "./testutils"
+import * as test from "./generated-src/ts/test";
+import {DjinniModule} from "@djinni_support/DjinniModule"
+
+class TsThrower implements test.ThrowingInterface {
+    throwException() {
+        throw new Error("TS Error");
+    }
+}
+
+class CppThrower implements test.ThrowingInterface {
+    cpp: test.CppException;
+    constructor(cpp: test.CppException) {
+        this.cpp = cpp;
+    }
+    throwException() {
+        this.cpp.throwAnException();
+    }
+}
+
+class CppExceptionTest extends TestCase  {
+    m: test.Test_statics & DjinniModule;
+    cppInterface: test.CppException;
+
+    constructor(module: test.Test_statics & DjinniModule) {
+        super(module);
+        this.m = module;
+        this.cppInterface = this.m.testsuite.CppException.get()!;
+    }
+
+    // C++ exception can be handled in TS
+    testCppException() {
+        var thrown = null;
+        try {
+            this.cppInterface.throwAnException();
+        } catch (e: any) {
+            thrown = e;
+        }
+        assertTrue(thrown instanceof Error);
+        assertEq(thrown.message, "C++: Exception Thrown");
+    }
+
+    // TS exception passes through C++ code and handled in TS higher up in the stack
+    testTsExceptionPassthrough() {
+        var thrown = null;
+        try {
+            this.cppInterface.callThrowingInterface(new TsThrower());
+        } catch (e: any) {
+            thrown = e;
+        }
+        assertTrue(thrown instanceof Error);
+        assertEq(thrown.message, "TS Error");
+    }
+
+    // TS exception can be handled in C++
+    testTsExceptionHandledByCpp() {
+        let res = this.cppInterface.callThrowingAndCatch(new TsThrower());
+        // the stack info from the js exception
+        assertTrue(res.length > 0 );
+    }
+
+    // C++ exception passes through TS code and handled in C++ higher up in the stack
+    testCppExceptionPassthrough() {
+        let res = this.cppInterface.callThrowingAndCatch(new CppThrower(this.cppInterface));
+        assertEq(res, "Exception Thrown");
+    }
+}
+
+allTests.push(CppExceptionTest);
diff --git a/test-suite/handwritten-src/ts/DurationTest.ts b/test-suite/handwritten-src/ts/DurationTest.ts
new file mode 100644
index 0000000..eaf2ff2
--- /dev/null
+++ b/test-suite/handwritten-src/ts/DurationTest.ts
@@ -0,0 +1,47 @@
+import {TestCase, allTests, assertEq, assertUndefined} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+function nanos(x: number) { return x / 1000000; }
+function micros(x: number) { return x / 1000; }
+function millis(x: number) { return x; }
+function seconds(x: number) { return x * 1000; }
+function minutes(x: number) { return x * 1000 * 60; }
+function hours(x: number) { return x * 1000 * 3600; }
+
+class DurationTest extends TestCase {
+    m: test.Test_statics;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+    test() {
+        assertEq(this.m.testsuite.TestDuration.hoursString(hours(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.minutesString(minutes(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.secondsString(seconds(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.millisString(millis(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.microsString(micros(1)), "1");
+        assertEq(this.m.testsuite.TestDuration.nanosString(nanos(1)), "1");
+
+        assertEq(this.m.testsuite.TestDuration.hours(1), hours(1));
+        assertEq(this.m.testsuite.TestDuration.minutes(1), minutes(1));
+        assertEq(this.m.testsuite.TestDuration.seconds(1), seconds(1));
+        assertEq(this.m.testsuite.TestDuration.millis(1), millis(1));
+        assertEq(this.m.testsuite.TestDuration.micros(1), micros(1));
+        assertEq(this.m.testsuite.TestDuration.nanos(1), nanos(1));
+
+        assertEq(this.m.testsuite.TestDuration.hoursf(1.5), minutes(90));
+        assertEq(this.m.testsuite.TestDuration.minutesf(1.5), seconds(90));
+        assertEq(this.m.testsuite.TestDuration.secondsf(1.5), millis(1500));
+        assertEq(this.m.testsuite.TestDuration.millisf(1.5), micros(1500));
+        assertEq(this.m.testsuite.TestDuration.microsf(1.5), nanos(1500));
+        assertEq(this.m.testsuite.TestDuration.nanosf(1.0), nanos(1));
+
+        assertEq(this.m.testsuite.TestDuration.box(BigInt(1)), seconds(1));
+        assertUndefined(this.m.testsuite.TestDuration.box(BigInt(-1)));
+
+        assertEq(this.m.testsuite.TestDuration.unbox(seconds(1)), 1);
+        assertEq(this.m.testsuite.TestDuration.unbox(undefined), -1);
+    }
+}
+
+allTests.push(DurationTest);
diff --git a/test-suite/handwritten-src/ts/EnumTest.ts b/test-suite/handwritten-src/ts/EnumTest.ts
new file mode 100644
index 0000000..c00e4c5
--- /dev/null
+++ b/test-suite/handwritten-src/ts/EnumTest.ts
@@ -0,0 +1,63 @@
+import {TestCase, allTests, assertEq, assertUndefined} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class EnumTest extends TestCase {
+    m: test.Test_statics;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+
+    enumToString(v: test.Color) {
+        return test.Color[v];
+    }
+    
+    testEnumToString() {
+        assertEq(this.enumToString(test.Color.RED), "RED");
+        assertEq(this.enumToString(test.Color.ORANGE), "ORANGE");
+        assertEq(this.enumToString(test.Color.YELLOW), "YELLOW");
+        assertEq(this.enumToString(test.Color.GREEN), "GREEN");
+        assertEq(this.enumToString(test.Color.BLUE), "BLUE");
+        assertEq(this.enumToString(test.Color.INDIGO), "INDIGO");
+        assertEq(this.enumToString(test.Color.VIOLET), "VIOLET");
+    }
+    
+    testEnumKey() {
+        var map = new Map();
+        map.set(test.Color.RED, "red");
+        map.set(test.Color.ORANGE, "orange");
+        map.set(test.Color.YELLOW, "yellow");
+        map.set(test.Color.GREEN, "green");
+        map.set(test.Color.BLUE, "blue");
+        map.set(test.Color.INDIGO, "indigo");
+        map.set(test.Color.VIOLET, "violet");
+        this.m.testsuite.TestHelpers.checkEnumMap(map);
+    }
+    testAccessFlagRoundtrip() {
+        var flags = [
+            test.AccessFlags.NOBODY,
+            test.AccessFlags.EVERYBODY,
+            test.AccessFlags.OWNER_READ,
+            test.AccessFlags.OWNER_READ | test.AccessFlags.OWNER_WRITE,
+            test.AccessFlags.OWNER_READ | test.AccessFlags.OWNER_WRITE | test.AccessFlags.OWNER_EXECUTE,
+        ];
+        for (var i = 0; i < flags.length; ++i) {
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripAccess(flags[i]));
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripAccessBoxed(flags[i]));
+        }
+        assertUndefined(this.m.testsuite.FlagRoundtrip.roundtripAccessBoxed(undefined));
+    }
+    testEmptyFlagRoundtrip() {
+        var flags = [
+            test.EmptyFlags.NONE,
+            test.EmptyFlags.ALL,
+        ];
+        for (var i = 0; i < flags.length; ++i) {
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripEmpty(flags[i]));
+            assertEq(flags[i], this.m.testsuite.FlagRoundtrip.roundtripEmptyBoxed(flags[i]));
+        }
+        assertUndefined(this.m.testsuite.FlagRoundtrip.roundtripEmptyBoxed(undefined));
+    }
+}
+
+allTests.push(EnumTest);
diff --git a/test-suite/handwritten-src/ts/MapRecordTest.ts b/test-suite/handwritten-src/ts/MapRecordTest.ts
new file mode 100644
index 0000000..b9544ff
--- /dev/null
+++ b/test-suite/handwritten-src/ts/MapRecordTest.ts
@@ -0,0 +1,56 @@
+import {TestCase, allTests, assertEq, assertTrue} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class MapRecordTest extends TestCase {
+    m: test.Test_statics;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+
+    testCppMapToJavaMap() {
+        this.checkJsMap(this.m.testsuite.TestHelpers.getMap());
+    }
+
+    testEmptyCppMapToJsMap() {
+        assertEq(0, this.m.testsuite.TestHelpers.getEmptyMap().size);
+    }
+
+    testCppMapListToJsMapList() {
+        var jsMapListRecord = this.m.testsuite.TestHelpers.getMapListRecord();
+        var jsMapList = jsMapListRecord.mapList;
+        assertEq(1, jsMapList.length);
+        this.checkJsMap(jsMapList[0]);
+    }
+
+    testJsMapToCppMap() {
+        assertTrue(this.m.testsuite.TestHelpers.checkMap(this.getJsMap()));
+    }
+
+    testEmptyJsMapToCppMap() {
+        assertTrue(this.m.testsuite.TestHelpers.checkEmptyMap(new Map()));
+    }
+
+    testJsMapListToCppMapList() {
+        var jsMapList = [];
+        jsMapList.push(this.getJsMap());
+        assertTrue(this.m.testsuite.TestHelpers.checkMapListRecord({mapList: jsMapList}));
+    }
+
+    getJsMap() {
+        var jsMap = new Map();
+        jsMap.set("String1", BigInt(1));
+        jsMap.set("String2", BigInt(2));
+        jsMap.set("String3", BigInt(3));
+        return jsMap;
+    }
+
+    checkJsMap(jsMap: Map<string, bigint>) {
+        assertEq(3, jsMap.size);
+        assertEq(jsMap.get("String1"), BigInt(1));
+        assertEq(jsMap.get("String2"), BigInt(2));
+        assertEq(jsMap.get("String3"), BigInt(3));
+    }
+}
+
+allTests.push(MapRecordTest);
diff --git a/test-suite/handwritten-src/ts/NestedCollectionTest.ts b/test-suite/handwritten-src/ts/NestedCollectionTest.ts
new file mode 100644
index 0000000..7b07e3e
--- /dev/null
+++ b/test-suite/handwritten-src/ts/NestedCollectionTest.ts
@@ -0,0 +1,33 @@
+import {TestCase, allTests, assertEq, assertTrue} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class NestedCollectionTest extends TestCase {
+    m: test.Test_statics;
+    jsNestedCollection: test.NestedCollection;
+
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+
+        var jsSet1 = new Set<string>();
+        jsSet1.add("String1");
+        jsSet1.add("String2");
+        var jsSet2 = new Set<string>();
+        jsSet2.add("StringA");
+        jsSet2.add("StringB");
+        var jsList = [];
+        jsList.push(jsSet1);
+        jsList.push(jsSet2);
+        this.jsNestedCollection = { setList: jsList };
+    }
+    testCppNestedRecordToJsNestedCollection() {
+        var converted = this.m.testsuite.TestHelpers.getNestedCollection();
+        assertEq(this.jsNestedCollection.setList, converted.setList);
+    }
+
+    testJsNestedRecordToCppNestedCollection() {
+        assertTrue(this.m.testsuite.TestHelpers.checkNestedCollection(this.jsNestedCollection));
+    }
+}
+
+allTests.push(NestedCollectionTest);
diff --git a/test-suite/handwritten-src/ts/PrimitiveListTest.ts b/test-suite/handwritten-src/ts/PrimitiveListTest.ts
new file mode 100644
index 0000000..44904b0
--- /dev/null
+++ b/test-suite/handwritten-src/ts/PrimitiveListTest.ts
@@ -0,0 +1,30 @@
+import {TestCase, allTests, assertArrayEq, assertTrue} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class PrimitiveListTest extends TestCase {
+    m: test.Test_statics;
+    jsPrimitiveList: test.PrimitiveList;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+        var list = [BigInt(1), BigInt(2), BigInt(3)];
+        this.jsPrimitiveList = {list: list};
+    }
+    testJavaPrimitiveListToCpp()
+    {
+        assertTrue(this.m.testsuite.TestHelpers.checkPrimitiveList(this.jsPrimitiveList));
+    }
+
+    testCppPrimitiveListToJava()
+    {
+        var converted = this.m.testsuite.TestHelpers.getPrimitiveList();
+        assertArrayEq(converted.list, this.jsPrimitiveList.list);
+    }
+
+    testBinary()
+    {
+        var b = new Uint8Array([1, 2, 3]);
+        assertArrayEq(this.m.testsuite.TestHelpers.idBinary(b), b);
+    }
+}
+allTests.push(PrimitiveListTest);
diff --git a/test-suite/handwritten-src/ts/PrimitivesTest.ts b/test-suite/handwritten-src/ts/PrimitivesTest.ts
new file mode 100644
index 0000000..df948d6
--- /dev/null
+++ b/test-suite/handwritten-src/ts/PrimitivesTest.ts
@@ -0,0 +1,33 @@
+import {TestCase, allTests, assertEq} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class PrimitivesTest extends TestCase {
+    m: test.Test_statics;
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+    testPrimitives() {
+        var p = {
+            b: true,                         // bool
+            eight: 123,                      // i8
+            sixteen: 20000,                  // i16
+            thirtytwo: 1000000000,           // i32
+            sixtyfour: BigInt("1234567890123456789"), // i64
+            fthirtytwo: 0,                   // f32
+            fsixtyfour: 1.23,                // f64
+
+            oB: true,                         // optional<bool>
+            oEight: 123,                      // optional<i8>
+            oSixteen: 20000,                  // optional<i16>
+            oThirtytwo: 1000000000,           // optional<i32>
+            oSixtyfour: BigInt("1234567890123456789"), // optional<i64>
+            oFthirtytwo: 0,                   // optional<f32>
+            oFsixtyfour: 1.23                 // optional<f64>
+        };
+        // f32 roundtrip test is not applicable to js because js has no native
+        // 32-bit floating point number.
+        assertEq(p, this.m.testsuite.TestHelpers.assortedPrimitivesId(p));
+    }
+}
+allTests.push(PrimitivesTest);
diff --git a/test-suite/handwritten-src/ts/SetRecordTest.ts b/test-suite/handwritten-src/ts/SetRecordTest.ts
new file mode 100644
index 0000000..f702ffb
--- /dev/null
+++ b/test-suite/handwritten-src/ts/SetRecordTest.ts
@@ -0,0 +1,30 @@
+import {TestCase, allTests, assertEq, assertTrue} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class SetRecordTest extends TestCase {
+    m: test.Test_statics;
+
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+    testCppSetToJavaSet() {
+        var jsSetRecord = this.m.testsuite.TestHelpers.getSetRecord();
+        var jsSet = jsSetRecord.set;
+        assertEq(3, jsSet.size);
+        assertTrue(jsSet.has("StringA"));
+        assertTrue(jsSet.has("StringB"));
+        assertTrue(jsSet.has("StringC"));
+    }
+
+    testJavaSetToCppSet() {
+        let jsSet: Set<string> = new Set();
+        let iSet: Set<number> = new Set();
+        jsSet.add("StringA");
+        jsSet.add("StringB");
+        jsSet.add("StringC");
+        let jsSetRecord: test.SetRecord = {set: jsSet, iset: iSet};
+        assertTrue(this.m.testsuite.TestHelpers.checkSetRecord(jsSetRecord));
+    }
+}
+allTests.push(SetRecordTest);
diff --git a/test-suite/handwritten-src/ts/TokenTest.ts b/test-suite/handwritten-src/ts/TokenTest.ts
new file mode 100644
index 0000000..9d3c845
--- /dev/null
+++ b/test-suite/handwritten-src/ts/TokenTest.ts
@@ -0,0 +1,63 @@
+import {TestCase, allTests, assertTrue, assertSame} from "./testutils"
+import * as test from "./generated-src/ts/test";
+
+class JsToken {
+    whoami() {
+        return "Javascript";
+    }
+}
+
+export class TokenTest extends TestCase {
+    m: test.Test_statics;
+
+    constructor(module: test.Test_statics) {
+        super(module);
+        this.m = module;
+    }
+    
+    testTokens() {
+        var jt = new JsToken();
+        assertSame(this.m.testsuite.TestHelpers.tokenId(jt), jt);
+    }
+
+    testNullToken() {
+        assertSame(this.m.testsuite.TestHelpers.tokenId(undefined), undefined);
+    }
+
+    testCppToken() {
+        var ct = this.m.testsuite.TestHelpers.createCppToken();
+        assertSame(this.m.testsuite.TestHelpers.tokenId(ct), ct);
+        this.m.testsuite.TestHelpers.checkCppToken(ct);
+    }
+
+    testTokenType() {
+        this.m.testsuite.TestHelpers.checkTokenType(new JsToken(), "Javascript");
+        this.m.testsuite.TestHelpers.checkTokenType(this.m.testsuite.TestHelpers.createCppToken(), "C++");
+        var threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkTokenType(new JsToken(), "foo");
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+        threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkTokenType(this.m.testsuite.TestHelpers.createCppToken(), "foo");
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+    }
+
+    testNotCppToken() {
+        var threw = false;
+        try {
+            this.m.testsuite.TestHelpers.checkCppToken(new JsToken());
+        } catch (e) {
+            threw = true;
+        }
+        assertTrue(threw);
+    }
+}
+
+allTests.push(TokenTest);
diff --git a/test-suite/handwritten-src/ts/WcharTest.ts b/test-suite/handwritten-src/ts/WcharTest.ts
new file mode 100644
index 0000000..a664577
--- /dev/null
+++ b/test-suite/handwritten-src/ts/WcharTest.ts
@@ -0,0 +1,22 @@
+import {TestCase, allTests, assertEq} from "./testutils"
+import * as test from "./generated-src/ts/test_wchar";
+
+class WcharTest extends TestCase {
+    m: test.TestWchar_statics;
+    constructor(module: test.TestWchar_statics) {
+        super(module);
+        this.m = module;
+    }
+
+    static STR1 = "some string with unicode \u{0000}, \u{263A}, \u{D83D}\u{DCA9} symbols";
+    static STR2 = "another string with unicode \u{263B}, \u{D83D}\u{DCA8} symbols";
+
+    test() {
+        assertEq(this.m.testsuite.WcharTestHelpers.getRecord().s, WcharTest.STR1);
+        assertEq(this.m.testsuite.WcharTestHelpers.getString(), WcharTest.STR2);
+        assertEq(this.m.testsuite.WcharTestHelpers.checkString(WcharTest.STR2), true);
+        assertEq(this.m.testsuite.WcharTestHelpers.checkRecord({s: WcharTest.STR1}), true);
+    }
+}
+
+allTests.push(WcharTest);
diff --git a/test-suite/handwritten-src/ts/main.ts b/test-suite/handwritten-src/ts/main.ts
new file mode 100644
index 0000000..a3c817a
--- /dev/null
+++ b/test-suite/handwritten-src/ts/main.ts
@@ -0,0 +1,19 @@
+import {DjinniModule} from "@djinni_support/DjinniModule"
+import {runTests, allTests} from "./testutils"
+import "./ClientInterfaceTest"
+import "./ConstantsTest"
+import "./CppExceptionTest"
+import "./DurationTest"
+import "./EnumTest"
+import "./MapRecordTest"
+import "./NestedCollectionTest"
+import "./PrimitiveListTest"
+import "./PrimitivesTest"
+import "./SetRecordTest"
+import "./TokenTest"
+import "./WcharTest"
+
+declare function Module(): Promise<DjinniModule>;
+Module().then(m => {
+    runTests(m, allTests);
+})
diff --git a/test-suite/handwritten-src/ts/run-tests-selenium.py b/test-suite/handwritten-src/ts/run-tests-selenium.py
new file mode 100755
index 0000000..76c4643
--- /dev/null
+++ b/test-suite/handwritten-src/ts/run-tests-selenium.py
@@ -0,0 +1,37 @@
+#! /usr/bin/env python3
+
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+import sys
+import threading
+
+port = "8080"
+httpd = HTTPServer(("127.0.0.1", int(port)), SimpleHTTPRequestHandler)
+
+def run_server():
+    print("Serving HTTP on localhost port " + port + " (http://localhost:" + port + "/) ...")
+    httpd.serve_forever()
+
+server_thread = threading.Thread(target=run_server)
+server_thread.start()
+
+service = Service(executable_path=r'/usr/bin/chromedriver')
+options = webdriver.ChromeOptions()
+options.add_argument('--headless')
+options.add_argument('--no-sandbox')
+options.add_argument('--disable-dev-shm-usage')
+options.add_argument('--disable-gpu')
+driver = webdriver.Chrome(service=service, options=options)
+print(f"connecting web driver to http://localhost:{port}/")
+driver.get(f"http://localhost:{port}/test.html")
+failed_elements = driver.find_elements(By.XPATH, "//pre[@id='output']/span[contains(text(), 'FAILED')]")
+for element in failed_elements:
+    print(f"{element.text}", file=sys.stderr)
+driver.quit()
+httpd.shutdown()
+server_thread.join()
+if len(failed_elements) > 0:
+    exit(1)
+exit(0)
diff --git a/test-suite/handwritten-src/ts/run.sh b/test-suite/handwritten-src/ts/run.sh
new file mode 100755
index 0000000..3d20f6c
--- /dev/null
+++ b/test-suite/handwritten-src/ts/run.sh
@@ -0,0 +1,10 @@
+#! /usr/bin/env bash
+#! /usr/bin/env bash
+set -eu
+# compile TS
+tsc
+# bundle
+browserify main.js -o bundle.js
+# then run the selenium tests
+sleep 1 && python3 run-tests-selenium.py
+
diff --git a/test-suite/handwritten-src/ts/test.html b/test-suite/handwritten-src/ts/test.html
new file mode 100644
index 0000000..66b7fff
--- /dev/null
+++ b/test-suite/handwritten-src/ts/test.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>Djinni/WASM Test</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <script src="test-wasm.js"></script>
+  </head>
+  <body>
+    <h1>Djinni/WASM Test</h1>
+    <pre id="output"></pre>
+    <!-- Things we can't test in JS:
+         * Android parcelable
+         * Deriving ord hash nscopy
+         * Catching C++ exception (incomplete)
+         * Function prologue (not yet)
+         * Protobuf (not yet)
+      -->
+    <script src="bundle.js"></script>
+  </body>
+</html>
diff --git a/test-suite/handwritten-src/ts/testutils.ts b/test-suite/handwritten-src/ts/testutils.ts
new file mode 100644
index 0000000..80bad34
--- /dev/null
+++ b/test-suite/handwritten-src/ts/testutils.ts
@@ -0,0 +1,137 @@
+import {DjinniModule} from "@djinni_support/DjinniModule"
+
+var failed: string[];
+var currentTest: string;
+
+function println(o: string) {
+    let output = document.getElementById('output')!;
+    if (o.startsWith('[  FAILED  ]')) {
+        var red = document.createElement("SPAN")
+        red.style.color="red";
+        red.innerText += String(o) + '\n';
+        output.appendChild(red)
+    } else if (o.startsWith('[')) {
+        var green = document.createElement("SPAN")
+        green.style.color="green";
+        green.innerText += String(o) + '\n';
+        output.appendChild(green)
+    } else {
+        var txt = document.createTextNode(String(o) + '\n')
+        output.appendChild(txt)
+    }
+}
+
+function units(n: number, u: string) {
+    u = (n == 1) ? u : u + 's';
+    return n + ' ' + u;
+}
+
+export class TestCase {
+    constructor(module: any) {}
+    setUp() {}
+    tearDown() {}
+}
+
+export async function runTests(module: DjinniModule, tests: Array<typeof TestCase>) {
+    failed = [];
+    var totalTests = 0;
+    let runStart = performance.now();
+    for (const testClass of tests) {
+        let testCase: any = new testClass(module);
+        var count = 0;
+        let testCaseStart = performance.now();
+        for (const method of Reflect.ownKeys(Reflect.getPrototypeOf(testCase)!)) {
+            let methodName = method.toString();
+            if (methodName.startsWith('test')) {
+                currentTest = testClass.name + '.' + methodName;
+                println('[ RUN      ] ' + currentTest)
+                let numberOfFailsBeforeThisTest = failed.length;
+                let testStart = performance.now();
+                try {
+                    testCase.setUp();
+                    var r = testCase[methodName]();
+                    if (typeof r === 'object' && typeof r.then === 'function') {
+                        await r;
+                    }
+                    testCase.tearDown();
+                }catch (err: any) {
+                    console.log('C++ exception: ' + err);
+                    assertTrue(false);
+                }
+                let status = failed.length > numberOfFailsBeforeThisTest ? '[  FAILED  ] ' : '[       OK ] ';
+                println(status + currentTest + ' (' + (performance.now() - testStart) + ' ms)')
+                count++;
+            }
+        }
+        totalTests += count;
+        println('[----------] ' + units(count, 'test') + ' from ' + testClass.name + '(' + (performance.now() - testCaseStart) + ' ms total)')
+    }
+    println('[==========] ' + units(totalTests, 'test') + ' from ' + units(tests.length, 'test suite') + ' ran. (' + (performance.now() - runStart) + ' ms total)')
+    println('[  PASSED  ] ' + units(totalTests - failed.length, 'test') + '.')
+    if (failed.length > 0) {
+        println('[  FAILED  ] ' + units(failed.length, 'test') + ', listed below:')
+        failed.forEach(function(f) {
+            println('[  FAILED  ] ' + f);
+        });
+    }
+}
+
+export function deepEqual(object1:any, object2:any) {
+    if (!isObject(object1) || !isObject(object2)) {
+        return object1 == object2;
+    }
+
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = isObject(val1) && isObject(val2);
+        if (areObjects && !deepEqual(val1, val2) || !areObjects && val1 !== val2) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+export function isObject(object: any) {
+    return object != null && typeof object === 'object';
+}
+export function assertTrue(a: boolean) {
+    if (!a) {
+        console.error("[  FAILED  ] " + currentTest);
+        failed.push(currentTest);
+    }
+}
+export function assertFalse(a:boolean) {
+    assertTrue(!a);
+}
+export function assertSame(a: any, b: any) {
+    assertTrue(a === b);
+}
+export function assertNotSame(a: any, b: any) {
+    assertFalse(a === b);
+}
+export function assertEq(a: any, b: any) {
+    assertTrue(deepEqual(a, b));
+}
+export function assertNe(a: any, b: any) {
+    assertFalse(deepEqual(a, b));
+}
+export function assertArrayEq(a: any, b: any) {
+    assertEq(a.length, b.length);
+    for (var i = 0; i < a.length; i++) {
+        assertEq(a[i], b[i]);
+    }
+}
+export function assertUndefined(a: any) {
+    assertTrue (a === undefined);
+}
+
+export var allTests: Array<typeof TestCase> = [];
diff --git a/test-suite/handwritten-src/ts/tsconfig.json b/test-suite/handwritten-src/ts/tsconfig.json
new file mode 100644
index 0000000..518591c
--- /dev/null
+++ b/test-suite/handwritten-src/ts/tsconfig.json
@@ -0,0 +1,11 @@
+{
+    "compilerOptions": {
+        "lib": ["es2020", "dom"],
+        "baseUrl": ".",
+        "paths": {
+            "@djinni_support/*": ["./ts-support-lib/*"]
+        },
+        "strict": true,
+    },
+    "include": ["./*.ts"],
+}
diff --git a/test/wasm_list.txt b/test/wasm_list.txt
new file mode 100644
index 0000000..bbf5fdf
--- /dev/null
+++ b/test/wasm_list.txt
@@ -0,0 +1,12 @@
+ .
+./usr
+./usr/local
+./usr/local/lib
+./usr/local/lib/libdjinni_support_lib.a
+./usr/local/include
+./usr/local/include/djinni
+./usr/local/include/djinni/djinni_common.hpp
+./usr/local/include/djinni/wasm
+./usr/local/include/djinni/wasm/djinni_wasm.hpp
+./usr/local/include/djinni/proxy_cache_impl.hpp
+./usr/local/include/djinni/proxy_cache_interface.hpp