src/wasm/wasm_natives_web_gen.hpp

// Generated by src/wasm/idl/generate.py from bindings.py. Do not edit.
//
// Browser-lane host entry points: one C function per op, found by
// the page through the kRiveWebCalls table, taking the owning VM
// as a u32 handle plus the native-convention args (pointers are
// librive-heap pointers, exactly what
// web/rive_module_imports.mjs stages into). Included at the end of
// wasm_scripting_vm.cpp so the impl cores are visible; expands to
// nothing off emscripten.
// clang-format off

#ifdef __EMSCRIPTEN__

#include <emscripten/emscripten.h>

extern "C" {

void rive_web_rt_log(uint32_t vmHandle, int32_t level, const char* message, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg messageUtf8(vm, message, length);
    rtLogImpl(vm, level, messageUtf8.data(), messageUtf8.size());
}
void rive_web_rt_mark_needs_update(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rtMarkNeedsUpdateImpl(vm, object);
}
void rive_web_rt_budget_exceeded(uint32_t vmHandle, uint32_t ms)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    rtBudgetExceededImpl(vm, ms);
}
void rive_web_rt_error(uint32_t vmHandle, const char* message, uint32_t length)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    WasmStringArg messageUtf8(vm, message, length);
    rtErrorImpl(vm, messageUtf8.data(), messageUtf8.size());
}
void rive_web_rt_debug_enter(uint32_t vmHandle, uint32_t func, uint32_t line)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rtDebugEnterImpl(vm, func, line);
}
uint32_t rive_web_rt_debug_line(uint32_t vmHandle, uint32_t line)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return rtDebugLineImpl(vm, line);
}
void rive_web_rt_debug_leave(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rtDebugLeaveImpl(vm);
}
uint32_t rive_web_rt_utc_offset(uint32_t vmHandle, double epochSeconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return rtUtcOffsetImpl(vm, epochSeconds);
}
uint32_t rive_web_rt_is_dst(uint32_t vmHandle, double epochSeconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return rtIsDstImpl(vm, epochSeconds);
}
uint32_t rive_web_rt_zone_name(uint32_t vmHandle, double epochSeconds, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return rtZoneNameImpl(vm, epochSeconds, buffer, capacity);
}
uint32_t rive_web_data_view_model(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataViewModelImpl(vm, object);
}
uint32_t rive_web_data_root_view_model(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataRootViewModelImpl(vm, object);
}
uint32_t rive_web_data_global_view_model(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataGlobalViewModelImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_global_view_model_names(uint32_t vmHandle, uint32_t object, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataGlobalViewModelNamesImpl(vm, object, buffer, capacity);
}
uint32_t rive_web_data_context(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataContextImpl(vm, object);
}
uint32_t rive_web_data_context_parent(uint32_t vmHandle, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataContextParentImpl(vm, dataContext);
}
uint32_t rive_web_data_context_view_model(uint32_t vmHandle, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataContextViewModelImpl(vm, dataContext);
}
void rive_web_data_context_release(uint32_t vmHandle, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataContextReleaseImpl(vm, dataContext);
}
uint32_t rive_web_data_has_view_model(uint32_t vmHandle, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataHasViewModelImpl(vm, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_new_view_model(uint32_t vmHandle, const char* name, uint32_t nameLength, const char* templateName, uint32_t templateLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    WasmStringArg templateNameUtf8(vm, templateName, templateLength);
    return dataNewViewModelImpl(vm, nameUtf8.data(), nameUtf8.size(), templateNameUtf8.data(), templateNameUtf8.size());
}
void rive_web_data_vmi_release(uint32_t vmHandle, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataVmiReleaseImpl(vm, vmi);
}
uint32_t rive_web_data_vmi_number(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiNumberImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_boolean(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiBooleanImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_string(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiStringImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_trigger(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiTriggerImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_color(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiColorImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_view_model(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiViewModelImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_property(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length, uint32_t* kindOut, uint32_t kindCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiPropertyImpl(vm, vmi, nameUtf8.data(), nameUtf8.size(), kindOut, kindCount);
}
uint32_t rive_web_data_vmi_instance(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataVmiInstanceImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_symbol_index(uint32_t vmHandle, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataVmiSymbolIndexImpl(vm, vmi);
}
uint32_t rive_web_data_vmi_equal(uint32_t vmHandle, uint32_t a, uint32_t b)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataVmiEqualImpl(vm, a, b);
}
uint32_t rive_web_data_view_model_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataViewModelGetImpl(vm, property);
}
uint32_t rive_web_data_vmi_list(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiListImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_enum(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiEnumImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_image(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiImageImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_font(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiFontImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_blob(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiBlobImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_vmi_artboard(uint32_t vmHandle, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiArtboardImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_data_image_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataImageGetImpl(vm, property);
}
void rive_web_data_image_set(uint32_t vmHandle, uint32_t property, uint32_t image)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataImageSetImpl(vm, property, image);
}
uint32_t rive_web_data_font_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataFontGetImpl(vm, property);
}
void rive_web_data_font_set(uint32_t vmHandle, uint32_t property, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataFontSetImpl(vm, property, font);
}
void rive_web_data_font_release(uint32_t vmHandle, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataFontReleaseImpl(vm, font);
}
uint32_t rive_web_data_blob_present(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataBlobPresentImpl(vm, property);
}
uint32_t rive_web_data_blob_get(uint32_t vmHandle, uint32_t property, uint8_t* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataBlobGetImpl(vm, property, buffer, capacity);
}
uint32_t rive_web_data_blob_name(uint32_t vmHandle, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataBlobNameImpl(vm, property, buffer, capacity);
}
void rive_web_data_blob_set(uint32_t vmHandle, uint32_t property, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataBlobSetImpl(vm, property, bytes, byteCount);
}
void rive_web_data_blob_clear(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataBlobClearImpl(vm, property);
}
uint32_t rive_web_data_artboard_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataArtboardGetImpl(vm, property);
}
void rive_web_data_artboard_set(uint32_t vmHandle, uint32_t property, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataArtboardSetImpl(vm, property, bindable);
}
uint32_t rive_web_data_enum_get(uint32_t vmHandle, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataEnumGetImpl(vm, property, buffer, capacity);
}
void rive_web_data_enum_set(uint32_t vmHandle, uint32_t property, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg valueUtf8(vm, value, length);
    dataEnumSetImpl(vm, property, valueUtf8.data(), valueUtf8.size());
}
uint32_t rive_web_data_enum_values(uint32_t vmHandle, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataEnumValuesImpl(vm, property, buffer, capacity);
}
void rive_web_data_prop_release(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataPropReleaseImpl(vm, property);
}
void rive_web_data_trigger_fire(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataTriggerFireImpl(vm, property);
}
uint32_t rive_web_data_list_length(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataListLengthImpl(vm, property);
}
void rive_web_data_list_push(uint32_t vmHandle, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListPushImpl(vm, property, vmi);
}
uint32_t rive_web_data_list_pop(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataListPopImpl(vm, property);
}
uint32_t rive_web_data_list_shift(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataListShiftImpl(vm, property);
}
void rive_web_data_list_clear(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListClearImpl(vm, property);
}
void rive_web_data_list_swap(uint32_t vmHandle, uint32_t property, uint32_t index1, uint32_t index2)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListSwapImpl(vm, property, index1, index2);
}
void rive_web_data_list_insert(uint32_t vmHandle, uint32_t property, uint32_t vmi, uint32_t index)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListInsertImpl(vm, property, vmi, index);
}
void rive_web_data_list_remove(uint32_t vmHandle, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListRemoveImpl(vm, property, vmi);
}
void rive_web_data_list_remove_at(uint32_t vmHandle, uint32_t property, uint32_t index)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListRemoveAtImpl(vm, property, index);
}
void rive_web_data_list_remove_all_of(uint32_t vmHandle, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataListRemoveAllOfImpl(vm, property, vmi);
}
uint32_t rive_web_data_list_get(uint32_t vmHandle, uint32_t property, uint32_t index)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataListGetImpl(vm, property, index);
}
void rive_web_data_view_model_set(uint32_t vmHandle, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataViewModelSetImpl(vm, property, vmi);
}
uint32_t rive_web_data_color_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataColorGetImpl(vm, property);
}
void rive_web_data_color_set(uint32_t vmHandle, uint32_t property, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataColorSetImpl(vm, property, value);
}
float rive_web_data_number_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataNumberGetImpl(vm, property);
}
void rive_web_data_number_set(uint32_t vmHandle, uint32_t property, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataNumberSetImpl(vm, property, value);
}
uint32_t rive_web_data_boolean_get(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataBooleanGetImpl(vm, property);
}
void rive_web_data_boolean_set(uint32_t vmHandle, uint32_t property, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataBooleanSetImpl(vm, property, value);
}
uint32_t rive_web_data_string_get(uint32_t vmHandle, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataStringGetImpl(vm, property, buffer, capacity);
}
uint32_t rive_web_data_string_changed(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return dataStringChangedImpl(vm, property);
}
void rive_web_data_string_set(uint32_t vmHandle, uint32_t property, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg valueUtf8(vm, value, length);
    dataStringSetImpl(vm, property, valueUtf8.data(), valueUtf8.size());
}
void rive_web_data_watch(uint32_t vmHandle, uint32_t property, uint32_t token)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataWatchImpl(vm, property, token);
}
void rive_web_data_unwatch(uint32_t vmHandle, uint32_t property)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    dataUnwatchImpl(vm, property);
}
void rive_web_data_convert_result(uint32_t vmHandle, uint32_t kind, float number, uint32_t booleanValue, uint32_t color, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg valueUtf8(vm, value, length);
    dataConvertResultImpl(vm, kind, number, booleanValue, color, valueUtf8.data(), valueUtf8.size());
}
void rive_web_artboard_release(uint32_t vmHandle, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardReleaseImpl(vm, artboard);
}
uint32_t rive_web_artboard_advance(uint32_t vmHandle, uint32_t artboard, float seconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardAdvanceImpl(vm, artboard, seconds);
}
void rive_web_artboard_draw(uint32_t vmHandle, uint32_t artboard, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardDrawImpl(vm, artboard, renderer);
}
uint32_t rive_web_artboard_instance(uint32_t vmHandle, uint32_t artboard, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardInstanceImpl(vm, artboard, vmi);
}
uint32_t rive_web_artboard_data(uint32_t vmHandle, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardDataImpl(vm, artboard);
}
float rive_web_artboard_width(uint32_t vmHandle, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardWidthImpl(vm, artboard);
}
float rive_web_artboard_height(uint32_t vmHandle, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardHeightImpl(vm, artboard);
}
void rive_web_artboard_set_width(uint32_t vmHandle, uint32_t artboard, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardSetWidthImpl(vm, artboard, value);
}
void rive_web_artboard_set_height(uint32_t vmHandle, uint32_t artboard, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardSetHeightImpl(vm, artboard, value);
}
uint32_t rive_web_artboard_frame_origin(uint32_t vmHandle, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardFrameOriginImpl(vm, artboard);
}
void rive_web_artboard_set_frame_origin(uint32_t vmHandle, uint32_t artboard, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardSetFrameOriginImpl(vm, artboard, value);
}
void rive_web_artboard_bounds(uint32_t vmHandle, uint32_t artboard, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardBoundsImpl(vm, artboard, out, outCount);
}
uint32_t rive_web_artboard_pointer_event(uint32_t vmHandle, uint32_t artboard, uint32_t kind, uint32_t pointerId, float x, float y)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardPointerEventImpl(vm, artboard, kind, pointerId, x, y);
}
uint32_t rive_web_artboard_scroll_event(uint32_t vmHandle, uint32_t artboard, uint32_t pointerId, float x, float y, float dx, float dy, uint32_t phase, uint32_t precise, float timeStamp)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardScrollEventImpl(vm, artboard, pointerId, x, y, dx, dy, phase, precise, timeStamp);
}
uint32_t rive_web_artboard_gamepad_event(uint32_t vmHandle, uint32_t artboard, const uint8_t* payload, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardGamepadEventImpl(vm, artboard, payload, byteCount);
}
uint32_t rive_web_artboard_animation(uint32_t vmHandle, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardAnimationImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void rive_web_artboard_animation_release(uint32_t vmHandle, uint32_t animation)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardAnimationReleaseImpl(vm, animation);
}
float rive_web_artboard_animation_duration(uint32_t vmHandle, uint32_t animation)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardAnimationDurationImpl(vm, animation);
}
uint32_t rive_web_artboard_animation_advance(uint32_t vmHandle, uint32_t animation, float seconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardAnimationAdvanceImpl(vm, animation, seconds);
}
void rive_web_artboard_animation_set_time(uint32_t vmHandle, uint32_t animation, float value, uint32_t mode)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardAnimationSetTimeImpl(vm, animation, value, mode);
}
void rive_web_artboard_add_to_path(uint32_t vmHandle, uint32_t artboard, uint32_t path, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardAddToPathImpl(vm, artboard, path, xx, xy, yx, yy, tx, ty);
}
uint32_t rive_web_artboard_node(uint32_t vmHandle, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardNodeImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void rive_web_artboard_node_release(uint32_t vmHandle, uint32_t node)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeReleaseImpl(vm, node);
}
void rive_web_artboard_node_transform(uint32_t vmHandle, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeTransformImpl(vm, node, out, outCount);
}
void rive_web_artboard_node_set(uint32_t vmHandle, uint32_t node, uint32_t field, float v0, float v1)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeSetImpl(vm, node, field, v0, v1);
}
void rive_web_artboard_node_world_transform(uint32_t vmHandle, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeWorldTransformImpl(vm, node, out, outCount);
}
void rive_web_artboard_node_set_world_transform(uint32_t vmHandle, uint32_t node, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeSetWorldTransformImpl(vm, node, values, floatCount);
}
void rive_web_artboard_node_decompose(uint32_t vmHandle, uint32_t node, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardNodeDecomposeImpl(vm, node, values, floatCount);
}
uint32_t rive_web_artboard_node_path_verbs(uint32_t vmHandle, uint32_t node, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardNodePathVerbsImpl(vm, node, out, outCount);
}
uint32_t rive_web_artboard_node_path_points(uint32_t vmHandle, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardNodePathPointsImpl(vm, node, out, outCount);
}
uint32_t rive_web_artboard_node_paint(uint32_t vmHandle, uint32_t node, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardNodePaintImpl(vm, node, out, outCount);
}
uint32_t rive_web_artboard_node_children(uint32_t vmHandle, uint32_t node, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardNodeChildrenImpl(vm, node, out, outCount);
}
uint32_t rive_web_artboard_node_parent(uint32_t vmHandle, uint32_t node)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardNodeParentImpl(vm, node);
}
uint32_t rive_web_artboard_property_key(uint32_t vmHandle, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardPropertyKeyImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void rive_web_artboard_draw_visit(uint32_t vmHandle, uint32_t artboard, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardDrawVisitImpl(vm, artboard, renderer);
}
void rive_web_artboard_draw_modulated(uint32_t vmHandle, uint32_t artboard, uint32_t renderer, uint32_t key)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardDrawModulatedImpl(vm, artboard, renderer, key);
}
void rive_web_artboard_drawable_draw(uint32_t vmHandle, uint32_t drawable, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    artboardDrawableDrawImpl(vm, drawable, renderer);
}
uint32_t rive_web_artboard_drawable_value(uint32_t vmHandle, uint32_t drawable, uint32_t key, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardDrawableValueImpl(vm, drawable, key, out, outCount);
}
uint32_t rive_web_artboard_drawable_string(uint32_t vmHandle, uint32_t drawable, uint32_t key, char* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardDrawableStringImpl(vm, drawable, key, out, outCount);
}
#ifdef WITH_RIVE_TOOLS
uint32_t rive_web_artboard_drawable_properties(uint32_t vmHandle, uint32_t drawable, char* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return artboardDrawablePropertiesImpl(vm, drawable, out, outCount);
}
#endif
uint32_t rive_web_audio_source(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return audioSourceImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
void rive_web_audio_source_release(uint32_t vmHandle, uint32_t source)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSourceReleaseImpl(vm, source);
}
float rive_web_audio_source_duration(uint32_t vmHandle, uint32_t source)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSourceDurationImpl(vm, source);
}
uint32_t rive_web_audio_source_sample_rate(uint32_t vmHandle, uint32_t source)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSourceSampleRateImpl(vm, source);
}
uint32_t rive_web_audio_source_channels(uint32_t vmHandle, uint32_t source)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSourceChannelsImpl(vm, source);
}
uint32_t rive_web_audio_source_to_blob(uint32_t vmHandle, uint32_t source, uint32_t sampleRate, uint32_t channels)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSourceToBlobImpl(vm, source, sampleRate, channels);
}
uint32_t rive_web_audio_stream(uint32_t vmHandle, uint32_t source, uint32_t sampleRate, uint32_t channels, uint32_t chunkFrames, uint32_t bufferFrames)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamImpl(vm, source, sampleRate, channels, chunkFrames, bufferFrames);
}
uint32_t rive_web_audio_stream_ring(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamRingImpl(vm, stream);
}
uint32_t rive_web_audio_stream_seeks(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamSeeksImpl(vm, stream);
}
uint32_t rive_web_audio_stream_channels(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamChannelsImpl(vm, stream);
}
uint32_t rive_web_audio_stream_sample_rate(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamSampleRateImpl(vm, stream);
}
uint32_t rive_web_audio_stream_seek_frame(uint32_t vmHandle, uint32_t stream, double frame)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamSeekFrameImpl(vm, stream, frame);
}
void rive_web_audio_stream_set_loop(uint32_t vmHandle, uint32_t stream, uint32_t loop)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioStreamSetLoopImpl(vm, stream, loop);
}
uint32_t rive_web_audio_stream_ended(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioStreamEndedImpl(vm, stream);
}
void rive_web_audio_stream_release(uint32_t vmHandle, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioStreamReleaseImpl(vm, stream);
}
uint32_t rive_web_audio_play(uint32_t vmHandle, uint32_t source)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioPlayImpl(vm, source);
}
uint32_t rive_web_audio_play_at_time(uint32_t vmHandle, uint32_t source, float seconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioPlayAtTimeImpl(vm, source, seconds);
}
uint32_t rive_web_audio_play_in_time(uint32_t vmHandle, uint32_t source, float seconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioPlayInTimeImpl(vm, source, seconds);
}
uint32_t rive_web_audio_play_at_frame(uint32_t vmHandle, uint32_t source, double frame)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioPlayAtFrameImpl(vm, source, frame);
}
uint32_t rive_web_audio_play_in_frame(uint32_t vmHandle, uint32_t source, double frame)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioPlayInFrameImpl(vm, source, frame);
}
float rive_web_audio_time(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioTimeImpl(vm);
}
double rive_web_audio_time_frame(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioTimeFrameImpl(vm);
}
uint32_t rive_web_audio_sample_rate(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSampleRateImpl(vm);
}
uint32_t rive_web_audio_processor_sample_rate(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioProcessorSampleRateImpl(vm);
}
uint32_t rive_web_audio_processor_channels(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioProcessorChannelsImpl(vm);
}
void rive_web_audio_sound_release(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundReleaseImpl(vm, sound);
}
void rive_web_audio_sound_play(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundPlayImpl(vm, sound);
}
void rive_web_audio_sound_pause(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundPauseImpl(vm, sound);
}
void rive_web_audio_sound_resume(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundResumeImpl(vm, sound);
}
void rive_web_audio_sound_stop(uint32_t vmHandle, uint32_t sound, uint32_t fadeFrames)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundStopImpl(vm, sound, fadeFrames);
}
uint32_t rive_web_audio_sound_seek(uint32_t vmHandle, uint32_t sound, float seconds)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundSeekImpl(vm, sound, seconds);
}
uint32_t rive_web_audio_sound_seek_frame(uint32_t vmHandle, uint32_t sound, double frame)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundSeekFrameImpl(vm, sound, frame);
}
uint32_t rive_web_audio_sound_completed(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundCompletedImpl(vm, sound);
}
float rive_web_audio_sound_time(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundTimeImpl(vm, sound);
}
double rive_web_audio_sound_time_frame(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundTimeFrameImpl(vm, sound);
}
float rive_web_audio_sound_volume(uint32_t vmHandle, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return audioSoundVolumeImpl(vm, sound);
}
void rive_web_audio_sound_set_volume(uint32_t vmHandle, uint32_t sound, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    audioSoundSetVolumeImpl(vm, sound, value);
}
uint32_t rive_web_path_new(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return pathNewImpl(vm);
}
void rive_web_path_update(uint32_t vmHandle, uint32_t path, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount, uint32_t fillRule)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    pathUpdateImpl(vm, path, verbs, verbCount, points, floatCount, fillRule);
}
void rive_web_path_release(uint32_t vmHandle, uint32_t path)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    pathReleaseImpl(vm, path);
}
void rive_web_path_add(uint32_t vmHandle, uint32_t path, uint32_t other, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    pathAddImpl(vm, path, other, xx, xy, yx, yy, tx, ty);
}
uint32_t rive_web_path_verbs(uint32_t vmHandle, uint32_t path, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return pathVerbsImpl(vm, path, out, outCount);
}
uint32_t rive_web_path_points(uint32_t vmHandle, uint32_t path, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return pathPointsImpl(vm, path, out, outCount);
}
void rive_web_path_effect_result(uint32_t vmHandle, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    pathEffectResultImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t rive_web_measure_path_new(uint32_t vmHandle, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measurePathNewImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t rive_web_measure_contours_new(uint32_t vmHandle, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureContoursNewImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t rive_web_measure_contour_next(uint32_t vmHandle, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureContourNextImpl(vm, measure);
}
float rive_web_measure_length(uint32_t vmHandle, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureLengthImpl(vm, measure);
}
uint32_t rive_web_measure_is_closed(uint32_t vmHandle, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureIsClosedImpl(vm, measure);
}
void rive_web_measure_pos_tan(uint32_t vmHandle, uint32_t measure, float distance, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    measurePosTanImpl(vm, measure, distance, out, outCount);
}
void rive_web_measure_warp(uint32_t vmHandle, uint32_t measure, float x, float y, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    measureWarpImpl(vm, measure, x, y, out, outCount);
}
uint32_t rive_web_measure_extract(uint32_t vmHandle, uint32_t measure, float startDistance, float endDistance, uint32_t startWithMove)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureExtractImpl(vm, measure, startDistance, endDistance, startWithMove);
}
uint32_t rive_web_measure_extract_read(uint32_t vmHandle, uint32_t measure, uint8_t* verbs, uint32_t verbCount, float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return measureExtractReadImpl(vm, measure, verbs, verbCount, points, floatCount);
}
void rive_web_measure_release(uint32_t vmHandle, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    measureReleaseImpl(vm, measure);
}
uint32_t rive_web_paint_new(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return paintNewImpl(vm);
}
void rive_web_paint_release(uint32_t vmHandle, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintReleaseImpl(vm, paint);
}
void rive_web_paint_style(uint32_t vmHandle, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintStyleImpl(vm, paint, value);
}
void rive_web_paint_color(uint32_t vmHandle, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintColorImpl(vm, paint, value);
}
void rive_web_paint_thickness(uint32_t vmHandle, uint32_t paint, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintThicknessImpl(vm, paint, value);
}
void rive_web_paint_join(uint32_t vmHandle, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintJoinImpl(vm, paint, value);
}
void rive_web_paint_cap(uint32_t vmHandle, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintCapImpl(vm, paint, value);
}
void rive_web_paint_blend_mode(uint32_t vmHandle, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintBlendModeImpl(vm, paint, value);
}
void rive_web_paint_feather(uint32_t vmHandle, uint32_t paint, float value)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintFeatherImpl(vm, paint, value);
}
void rive_web_paint_shader(uint32_t vmHandle, uint32_t paint, uint32_t shader)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintShaderImpl(vm, paint, shader);
}
void rive_web_paint_shader_transform(uint32_t vmHandle, uint32_t paint, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    paintShaderTransformImpl(vm, paint, values, floatCount);
}
uint32_t rive_web_canvas_new(uint32_t vmHandle, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasNewImpl(vm, width, height);
}
void rive_web_canvas_release(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    canvasReleaseImpl(vm, canvas);
}
uint32_t rive_web_canvas_width(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasWidthImpl(vm, canvas);
}
uint32_t rive_web_canvas_height(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasHeightImpl(vm, canvas);
}
uint32_t rive_web_canvas_resize(uint32_t vmHandle, uint32_t canvas, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasResizeImpl(vm, canvas, width, height);
}
uint32_t rive_web_canvas_image(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasImageImpl(vm, canvas);
}
uint32_t rive_web_canvas_begin_frame(uint32_t vmHandle, uint32_t canvas, uint32_t clearColor)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return canvasBeginFrameImpl(vm, canvas, clearColor);
}
void rive_web_canvas_end_frame(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    canvasEndFrameImpl(vm, canvas);
}
uint32_t rive_web_gpu_features(uint32_t vmHandle, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuFeaturesImpl(vm, out, outCount);
}
uint32_t rive_web_gpu_canvas_new(uint32_t vmHandle, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuCanvasNewImpl(vm, width, height);
}
void rive_web_gpu_canvas_release(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuCanvasReleaseImpl(vm, canvas);
}
uint32_t rive_web_gpu_canvas_color_view(uint32_t vmHandle, uint32_t canvas, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuCanvasColorViewImpl(vm, canvas, props, propCount);
}
uint32_t rive_web_gpu_canvas_image(uint32_t vmHandle, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuCanvasImageImpl(vm, canvas);
}
uint32_t rive_web_gpu_canvas_resize(uint32_t vmHandle, uint32_t canvas, uint32_t width, uint32_t height, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuCanvasResizeImpl(vm, canvas, width, height, props, propCount);
}
uint32_t rive_web_gpu_target_view(uint32_t vmHandle, uint32_t current, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuTargetViewImpl(vm, current, props, propCount);
}
uint32_t rive_web_gpu_pass_begin(uint32_t vmHandle, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuPassBeginImpl(vm, desc, descByteCount, blob, blobCount);
}
void rive_web_gpu_pass_set_pipeline(uint32_t vmHandle, uint32_t pass, uint32_t pipeline)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetPipelineImpl(vm, pass, pipeline);
}
void rive_web_gpu_pass_set_vertex_buffer(uint32_t vmHandle, uint32_t pass, uint32_t slot, uint32_t buffer, uint32_t offset)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetVertexBufferImpl(vm, pass, slot, buffer, offset);
}
void rive_web_gpu_pass_set_index_buffer(uint32_t vmHandle, uint32_t pass, uint32_t buffer, uint32_t indexFormat, uint32_t offset)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetIndexBufferImpl(vm, pass, buffer, indexFormat, offset);
}
void rive_web_gpu_pass_set_bind_group(uint32_t vmHandle, uint32_t pass, uint32_t groupIndex, uint32_t bindGroup, const uint32_t* dynamicOffsets, uint32_t dynamicOffsetByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetBindGroupImpl(vm, pass, groupIndex, bindGroup, dynamicOffsets, dynamicOffsetByteCount);
}
void rive_web_gpu_pass_set_viewport(uint32_t vmHandle, uint32_t pass, float x, float y, float width, float height, float minDepth, float maxDepth)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetViewportImpl(vm, pass, x, y, width, height, minDepth, maxDepth);
}
void rive_web_gpu_pass_set_scissor(uint32_t vmHandle, uint32_t pass, uint32_t x, uint32_t y, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetScissorImpl(vm, pass, x, y, width, height);
}
void rive_web_gpu_pass_set_stencil_reference(uint32_t vmHandle, uint32_t pass, uint32_t ref)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetStencilReferenceImpl(vm, pass, ref);
}
void rive_web_gpu_pass_set_blend_color(uint32_t vmHandle, uint32_t pass, float r, float g, float b, float a)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassSetBlendColorImpl(vm, pass, r, g, b, a);
}
void rive_web_gpu_pass_draw(uint32_t vmHandle, uint32_t pass, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassDrawImpl(vm, pass, vertexCount, instanceCount, firstVertex, firstInstance);
}
void rive_web_gpu_pass_draw_indexed(uint32_t vmHandle, uint32_t pass, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassDrawIndexedImpl(vm, pass, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
}
void rive_web_gpu_pass_finish(uint32_t vmHandle, uint32_t pass)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassFinishImpl(vm, pass);
}
void rive_web_gpu_pass_release(uint32_t vmHandle, uint32_t pass)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPassReleaseImpl(vm, pass);
}
uint32_t rive_web_gpu_image_view(uint32_t vmHandle, uint32_t image, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuImageViewImpl(vm, image, width, height);
}
uint32_t rive_web_gpu_buffer_new(uint32_t vmHandle, uint32_t usage, uint32_t sizeInBytes, uint32_t immutable, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBufferNewImpl(vm, usage, sizeInBytes, immutable, data, dataCount);
}
void rive_web_gpu_buffer_update(uint32_t vmHandle, uint32_t buffer, uint32_t dstOffset, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuBufferUpdateImpl(vm, buffer, dstOffset, data, dataCount);
}
void rive_web_gpu_buffer_update_blob(uint32_t vmHandle, uint32_t buffer, uint32_t dstOffset, uint32_t blob, uint32_t srcOffset, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuBufferUpdateBlobImpl(vm, buffer, dstOffset, blob, srcOffset, byteCount);
}
uint32_t rive_web_gpu_buffer_new_blob(uint32_t vmHandle, uint32_t usage, uint32_t immutable, uint32_t blob, uint32_t srcOffset, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBufferNewBlobImpl(vm, usage, immutable, blob, srcOffset, byteCount);
}
void rive_web_gpu_buffer_release(uint32_t vmHandle, uint32_t buffer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuBufferReleaseImpl(vm, buffer);
}
uint32_t rive_web_gpu_texture_new(uint32_t vmHandle, const rive_gpu_texture_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuTextureNewImpl(vm, desc, descByteCount);
}
void rive_web_gpu_texture_upload(uint32_t vmHandle, uint32_t texture, const rive_gpu_texture_upload_v1* region, uint32_t regionByteCount, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuTextureUploadImpl(vm, texture, region, regionByteCount, data, dataCount);
}
void rive_web_gpu_texture_release(uint32_t vmHandle, uint32_t texture)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuTextureReleaseImpl(vm, texture);
}
uint32_t rive_web_gpu_sampler_new(uint32_t vmHandle, const rive_gpu_sampler_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuSamplerNewImpl(vm, desc, descByteCount);
}
void rive_web_gpu_sampler_release(uint32_t vmHandle, uint32_t sampler)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuSamplerReleaseImpl(vm, sampler);
}
uint32_t rive_web_gpu_texture_view_new(uint32_t vmHandle, uint32_t texture, const rive_gpu_texture_view_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuTextureViewNewImpl(vm, texture, desc, descByteCount);
}
void rive_web_gpu_texture_view_release(uint32_t vmHandle, uint32_t view)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuTextureViewReleaseImpl(vm, view);
}
uint32_t rive_web_gpu_shader_target(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuShaderTargetImpl(vm);
}
uint32_t rive_web_gpu_shader_asset_bytes(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderAssetBytesImpl(vm, object, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
uint32_t rive_web_gpu_shader_asset_id(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderAssetIdImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_gpu_shader_module_from_asset(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength, uint32_t entry)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderModuleFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size(), entry);
}
#ifdef WITH_RIVE_TOOLS
uint32_t rive_web_gpu_shader_module_from_rstb(uint32_t vmHandle, const uint8_t* rstb, uint32_t rstbCount, uint32_t assetId, uint32_t entry)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuShaderModuleFromRstbImpl(vm, rstb, rstbCount, assetId, entry);
}
#endif
void rive_web_gpu_shader_module_release(uint32_t vmHandle, uint32_t shaderModule)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuShaderModuleReleaseImpl(vm, shaderModule);
}
uint32_t rive_web_gpu_bind_group_layout_new(uint32_t vmHandle, uint32_t groupIndex, const rive_gpu_bind_group_layout_entry_v1* entries, uint32_t entryByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBindGroupLayoutNewImpl(vm, groupIndex, entries, entryByteCount);
}
void rive_web_gpu_bind_group_layout_release(uint32_t vmHandle, uint32_t layout)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuBindGroupLayoutReleaseImpl(vm, layout);
}
uint32_t rive_web_gpu_bind_group_layout_from_shader(uint32_t vmHandle, uint32_t shaderModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBindGroupLayoutFromShaderImpl(vm, shaderModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
uint32_t rive_web_gpu_bind_group_layout_from_shaders(uint32_t vmHandle, uint32_t vertexModule, uint32_t fragmentModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBindGroupLayoutFromShadersImpl(vm, vertexModule, fragmentModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
uint32_t rive_web_gpu_bind_group_layout_from_entries(uint32_t vmHandle, uint32_t vertexModule, const char* vertexEntry, uint32_t vertexEntryLength, uint32_t fragmentModule, const char* fragmentEntry, uint32_t fragmentEntryLength, uint32_t groupIndex)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg vertexEntryUtf8(vm, vertexEntry, vertexEntryLength);
    WasmStringArg fragmentEntryUtf8(vm, fragmentEntry, fragmentEntryLength);
    return gpuBindGroupLayoutFromEntriesImpl(vm, vertexModule, vertexEntryUtf8.data(), vertexEntryUtf8.size(), fragmentModule, fragmentEntryUtf8.data(), fragmentEntryUtf8.size(), groupIndex);
}
uint32_t rive_web_gpu_bind_group_new(uint32_t vmHandle, uint32_t layout, const rive_gpu_bind_group_ubo_v1* ubos, uint32_t uboByteCount, const rive_gpu_bind_group_texture_v1* textures, uint32_t textureByteCount, const rive_gpu_bind_group_sampler_v1* samplers, uint32_t samplerByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuBindGroupNewImpl(vm, layout, ubos, uboByteCount, textures, textureByteCount, samplers, samplerByteCount);
}
void rive_web_gpu_bind_group_release(uint32_t vmHandle, uint32_t bindGroup)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuBindGroupReleaseImpl(vm, bindGroup);
}
uint32_t rive_web_gpu_pipeline_new(uint32_t vmHandle, const rive_gpu_pipeline_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return gpuPipelineNewImpl(vm, desc, descByteCount, blob, blobCount);
}
void rive_web_gpu_pipeline_release(uint32_t vmHandle, uint32_t pipeline)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    gpuPipelineReleaseImpl(vm, pipeline);
}
void rive_web_mat4_multiply(uint32_t vmHandle, uint8_t* out, uint32_t outBytes, const uint8_t* a, uint32_t aBytes, const uint8_t* b, uint32_t bBytes)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    mat4MultiplyImpl(vm, out, outBytes, a, aBytes, b, bBytes);
}
uint32_t rive_web_mat4_invert(uint32_t vmHandle, uint8_t* out, uint32_t outBytes, const uint8_t* src, uint32_t srcBytes)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return mat4InvertImpl(vm, out, outBytes, src, srcBytes);
}
uint32_t rive_web_buffer_new(uint32_t vmHandle, uint32_t bufferType, uint32_t flags, uint32_t sizeInBytes)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return bufferNewImpl(vm, bufferType, flags, sizeInBytes);
}
void rive_web_buffer_update(uint32_t vmHandle, uint32_t buffer, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    bufferUpdateImpl(vm, buffer, bytes, byteCount);
}
void rive_web_buffer_release(uint32_t vmHandle, uint32_t buffer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    bufferReleaseImpl(vm, buffer);
}
uint32_t rive_web_mesh_instances_new(uint32_t vmHandle, uint32_t count)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return meshInstancesNewImpl(vm, count);
}
void rive_web_mesh_instances_resize(uint32_t vmHandle, uint32_t instances, uint32_t count)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    meshInstancesResizeImpl(vm, instances, count);
}
void rive_web_mesh_instances_update(uint32_t vmHandle, uint32_t instances, uint32_t first, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    meshInstancesUpdateImpl(vm, instances, first, bytes, byteCount);
}
void rive_web_mesh_instances_release(uint32_t vmHandle, uint32_t instances)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    meshInstancesReleaseImpl(vm, instances);
}
uint32_t rive_web_blob_asset_bytes(uint32_t vmHandle, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return blobAssetBytesImpl(vm, object, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
uint32_t rive_web_image_from_asset(uint32_t vmHandle, uint32_t object, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return imageFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t rive_web_image_width(uint32_t vmHandle, uint32_t image)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return imageWidthImpl(vm, image);
}
uint32_t rive_web_image_height(uint32_t vmHandle, uint32_t image)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return imageHeightImpl(vm, image);
}
void rive_web_image_release(uint32_t vmHandle, uint32_t image)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    imageReleaseImpl(vm, image);
}
uint32_t rive_web_image_decode(uint32_t vmHandle, const uint8_t* bytes, uint32_t byteCount, uint32_t token)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return imageDecodeImpl(vm, bytes, byteCount, token);
}
void rive_web_image_decode_cancel(uint32_t vmHandle, uint32_t token)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    imageDecodeCancelImpl(vm, token);
}
uint32_t rive_web_font_from_asset(uint32_t vmHandle, uint32_t object, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, length);
    return fontFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_font_decode(uint32_t vmHandle, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontDecodeImpl(vm, bytes, byteCount);
}
#endif
void rive_web_font_release(uint32_t vmHandle, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    fontReleaseImpl(vm, font);
}
void rive_web_font_metrics(uint32_t vmHandle, uint32_t font, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    fontMetricsImpl(vm, font, out, outCount);
}
uint32_t rive_web_font_weight(uint32_t vmHandle, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontWeightImpl(vm, font);
}
uint32_t rive_web_font_is_italic(uint32_t vmHandle, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontIsItalicImpl(vm, font);
}
uint32_t rive_web_font_axis_count(uint32_t vmHandle, uint32_t font)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontAxisCountImpl(vm, font);
}
void rive_web_font_axis(uint32_t vmHandle, uint32_t font, uint32_t index, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    fontAxisImpl(vm, font, index, out, outCount);
}
float rive_web_font_axis_value(uint32_t vmHandle, uint32_t font, uint32_t tag)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontAxisValueImpl(vm, font, tag);
}
uint32_t rive_web_font_features(uint32_t vmHandle, uint32_t font, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontFeaturesImpl(vm, font, out, outCount);
}
uint32_t rive_web_font_has_glyph(uint32_t vmHandle, uint32_t font, uint32_t codepoint)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontHasGlyphImpl(vm, font, codepoint);
}
uint32_t rive_web_font_with_options(uint32_t vmHandle, uint32_t font, const uint32_t* coords, uint32_t coordCount, const uint32_t* features, uint32_t featureCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontWithOptionsImpl(vm, font, coords, coordCount, features, featureCount);
}
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_font_glyph_verbs(uint32_t vmHandle, uint32_t font, uint32_t glyph, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontGlyphVerbsImpl(vm, font, glyph, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_font_glyph_points(uint32_t vmHandle, uint32_t font, uint32_t glyph, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fontGlyphPointsImpl(vm, font, glyph, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_new(uint32_t vmHandle)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textNewImpl(vm);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_release(uint32_t vmHandle, uint32_t text)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    textReleaseImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_append(uint32_t vmHandle, uint32_t text, const char* chars, uint32_t length, uint32_t font, uint32_t paint, float size, float lineHeight, float letterSpacing, uint32_t foreground)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg charsUtf8(vm, chars, length);
    textAppendImpl(vm, text, charsUtf8.data(), charsUtf8.size(), font, paint, size, lineHeight, letterSpacing, foreground);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_clear(uint32_t vmHandle, uint32_t text)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    textClearImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_layout(uint32_t vmHandle, uint32_t text, const rive_text_layout_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    textLayoutImpl(vm, text, desc, descByteCount);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_draw(uint32_t vmHandle, uint32_t text, uint32_t renderer, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    textDrawImpl(vm, text, renderer, paint);
}
#endif
#ifdef WITH_RIVE_TEXT
void rive_web_text_bounds(uint32_t vmHandle, uint32_t text, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    textBoundsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_length(uint32_t vmHandle, uint32_t text)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textLengthImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_lines(uint32_t vmHandle, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textLinesImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_runs(uint32_t vmHandle, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textRunsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_glyphs(uint32_t vmHandle, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textGlyphsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_hit_test(uint32_t vmHandle, uint32_t text, float x, float y)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textHitTestImpl(vm, text, x, y);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_caret(uint32_t vmHandle, uint32_t text, uint32_t index, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textCaretImpl(vm, text, index, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t rive_web_text_selection_rects(uint32_t vmHandle, uint32_t text, uint32_t from, uint32_t to, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return textSelectionRectsImpl(vm, text, from, to, out, outCount);
}
#endif
uint32_t rive_web_shader_linear(uint32_t vmHandle, float sx, float sy, float ex, float ey, uint32_t colors, uint32_t stops, uint32_t count)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return shaderLinearImpl(vm, sx, sy, ex, ey, colors, stops, count);
}
uint32_t rive_web_shader_radial(uint32_t vmHandle, float cx, float cy, float radius, uint32_t colors, uint32_t stops, uint32_t count)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return shaderRadialImpl(vm, cx, cy, radius, colors, stops, count);
}
void rive_web_shader_release(uint32_t vmHandle, uint32_t shader)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    shaderReleaseImpl(vm, shader);
}
uint32_t rive_web_test_blob(uint32_t vmHandle, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return testBlobImpl(vm, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
void rive_web_transition_child_draw(uint32_t vmHandle, uint32_t child, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    transitionChildDrawImpl(vm, child, renderer);
}
float rive_web_transition_child_width(uint32_t vmHandle, uint32_t child)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return transitionChildWidthImpl(vm, child);
}
float rive_web_transition_child_height(uint32_t vmHandle, uint32_t child)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return transitionChildHeightImpl(vm, child);
}
void rive_web_renderer_save(uint32_t vmHandle, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererSaveImpl(vm, renderer);
}
void rive_web_renderer_restore(uint32_t vmHandle, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererRestoreImpl(vm, renderer);
}
void rive_web_renderer_transform(uint32_t vmHandle, uint32_t renderer, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererTransformImpl(vm, renderer, xx, xy, yx, yy, tx, ty);
}
void rive_web_renderer_draw_path(uint32_t vmHandle, uint32_t renderer, uint32_t path, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererDrawPathImpl(vm, renderer, path, paint);
}
void rive_web_renderer_clip_path(uint32_t vmHandle, uint32_t renderer, uint32_t path)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererClipPathImpl(vm, renderer, path);
}
void rive_web_renderer_modulate_opacity(uint32_t vmHandle, uint32_t renderer, float opacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererModulateOpacityImpl(vm, renderer, opacity);
}
void rive_web_renderer_modulate_color(uint32_t vmHandle, uint32_t renderer, uint32_t color, uint32_t replace)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererModulateColorImpl(vm, renderer, color, replace);
}
void rive_web_renderer_draw_image(uint32_t vmHandle, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t blend, float opacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererDrawImageImpl(vm, renderer, image, sampler, blend, opacity);
}
void rive_web_renderer_draw_image_mesh(uint32_t vmHandle, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t blend, float opacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererDrawImageMeshImpl(vm, renderer, image, sampler, vertexBuffer, uvBuffer, indexBuffer, blend, opacity);
}
void rive_web_renderer_draw_image_mesh_instanced(uint32_t vmHandle, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t instances)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    rendererDrawImageMeshInstancedImpl(vm, renderer, image, sampler, vertexBuffer, uvBuffer, indexBuffer, instances);
}
uint32_t rive_web_net_fetch(uint32_t vmHandle, const uint8_t* request, uint32_t requestCount, uint32_t token)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return netFetchImpl(vm, request, requestCount, token);
}
void rive_web_net_fetch_cancel(uint32_t vmHandle, uint32_t token)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    netFetchCancelImpl(vm, token);
}
uint32_t rive_web_file_decode(uint32_t vmHandle, const uint8_t* bytes, uint32_t byteCount, uint32_t* statusOut, uint32_t statusCount)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileDecodeImpl(vm, bytes, byteCount, statusOut, statusCount);
}
void rive_web_file_release(uint32_t vmHandle, uint32_t file)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    fileReleaseImpl(vm, file);
}
uint32_t rive_web_file_artboard_count(uint32_t vmHandle, uint32_t file)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileArtboardCountImpl(vm, file);
}
uint32_t rive_web_file_artboard_name(uint32_t vmHandle, uint32_t file, uint32_t index, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileArtboardNameImpl(vm, file, index, buffer, capacity);
}
uint32_t rive_web_file_bindable(uint32_t vmHandle, uint32_t file, const char* name, uint32_t nameLength, uint32_t useDefault)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return fileBindableImpl(vm, file, nameUtf8.data(), nameUtf8.size(), useDefault);
}
void rive_web_file_bindable_release(uint32_t vmHandle, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    fileBindableReleaseImpl(vm, bindable);
}
uint32_t rive_web_file_bindable_name(uint32_t vmHandle, uint32_t bindable, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileBindableNameImpl(vm, bindable, buffer, capacity);
}
uint32_t rive_web_file_bindable_data(uint32_t vmHandle, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileBindableDataImpl(vm, bindable);
}
uint32_t rive_web_file_bindable_equal(uint32_t vmHandle, uint32_t a, uint32_t b)
{
    WasmScriptingVM* vm = vmFromHandle(vmHandle);
    return fileBindableEqualImpl(vm, a, b);
}
uint32_t rive_web_lanes_start(uint32_t vmHandle, uint32_t kind, uint32_t entry, const uint8_t* input, uint32_t inputByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesStartImpl(vm, kind, entry, input, inputByteCount, holds, holdCount);
}
uint32_t rive_web_lanes_state(uint32_t vmHandle, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesStateImpl(vm, lane);
}
uint32_t rive_web_lanes_failed(uint32_t vmHandle, uint32_t lane, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesFailedImpl(vm, lane, buffer, capacity);
}
void rive_web_lanes_stop(uint32_t vmHandle, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    lanesStopImpl(vm, lane);
}
void rive_web_lanes_release(uint32_t vmHandle, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    lanesReleaseImpl(vm, lane);
}
uint32_t rive_web_lanes_result(uint32_t vmHandle, uint32_t lane, uint32_t out, uint32_t outCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesResultImpl(vm, lane, out, outCount);
}
uint32_t rive_web_lanes_watch(uint32_t vmHandle, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesWatchImpl(vm, lane);
}
uint32_t rive_web_lanes_wait(uint32_t vmHandle, uint32_t signal, double after, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesWaitImpl(vm, signal, after, timeoutSeconds);
}
void rive_web_lanes_cancel_wait(uint32_t vmHandle, uint32_t token)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    lanesCancelWaitImpl(vm, token);
}
double rive_web_lanes_wait_within(uint32_t vmHandle, uint32_t signal, double after, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return lanesWaitWithinImpl(vm, signal, after, timeoutSeconds);
}
uint32_t rive_web_jobs_threads(uint32_t vmHandle)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return jobsThreadsImpl(vm);
}
uint32_t rive_web_jobs_join(uint32_t vmHandle, uint32_t job, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return jobsJoinImpl(vm, job, timeoutSeconds);
}
uint32_t rive_web_jobs_join_any(uint32_t vmHandle, const uint32_t* jobs, uint32_t count, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return jobsJoinAnyImpl(vm, jobs, count, timeoutSeconds);
}
uint32_t rive_web_parallel_size(uint32_t vmHandle)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return parallelSizeImpl(vm);
}
#ifdef RIVE_WASM_PARALLEL
uint32_t rive_web_parallel_run(uint32_t vmHandle, uint32_t control)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return parallelRunImpl(vm, control);
}
#endif
uint32_t rive_web_shared_region_create(uint32_t vmHandle, uint32_t size)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionCreateImpl(vm, size);
}
uint32_t rive_web_shared_region_size(uint32_t vmHandle, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionSizeImpl(vm, region);
}
uint32_t rive_web_shared_region_lock(uint32_t vmHandle, uint32_t region, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionLockImpl(vm, region, timeoutSeconds);
}
void rive_web_shared_region_unlock(uint32_t vmHandle, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    sharedRegionUnlockImpl(vm, region);
}
uint32_t rive_web_shared_region_read(uint32_t vmHandle, uint32_t region, uint32_t offset, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionReadImpl(vm, region, offset, out, outByteCount);
}
uint32_t rive_web_shared_region_write(uint32_t vmHandle, uint32_t region, uint32_t offset, const uint8_t* data, uint32_t dataByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionWriteImpl(vm, region, offset, data, dataByteCount);
}
uint32_t rive_web_shared_region_poisoned(uint32_t vmHandle, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRegionPoisonedImpl(vm, region);
}
double rive_web_shared_atomic_load(uint32_t vmHandle, uint32_t region, uint32_t offset)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedAtomicLoadImpl(vm, region, offset);
}
double rive_web_shared_atomic_store(uint32_t vmHandle, uint32_t region, uint32_t offset, uint32_t value)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedAtomicStoreImpl(vm, region, offset, value);
}
double rive_web_shared_atomic_add(uint32_t vmHandle, uint32_t region, uint32_t offset, uint32_t value)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedAtomicAddImpl(vm, region, offset, value);
}
double rive_web_shared_atomic_cas(uint32_t vmHandle, uint32_t region, uint32_t offset, uint32_t expected, uint32_t desired)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedAtomicCasImpl(vm, region, offset, expected, desired);
}
uint32_t rive_web_shared_ring_create(uint32_t vmHandle, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingCreateImpl(vm, capacity);
}
uint32_t rive_web_shared_ring_write(uint32_t vmHandle, uint32_t ring, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingWriteImpl(vm, ring, data, dataByteCount, holds, holdCount);
}
uint32_t rive_web_shared_ring_read(uint32_t vmHandle, uint32_t ring, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingReadImpl(vm, ring, out, outByteCount);
}
uint32_t rive_web_shared_ring_drop(uint32_t vmHandle, uint32_t ring, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingDropImpl(vm, ring, capacity);
}
uint32_t rive_web_shared_ring_used(uint32_t vmHandle, uint32_t ring)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingUsedImpl(vm, ring);
}
uint32_t rive_web_shared_ring_signal(uint32_t vmHandle, uint32_t ring, uint32_t space)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRingSignalImpl(vm, ring, space);
}
uint32_t rive_web_shared_snapshot_create(uint32_t vmHandle, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSnapshotCreateImpl(vm, capacity);
}
uint32_t rive_web_shared_snapshot_publish(uint32_t vmHandle, uint32_t snapshot, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSnapshotPublishImpl(vm, snapshot, data, dataByteCount, holds, holdCount);
}
uint32_t rive_web_shared_snapshot_read(uint32_t vmHandle, uint32_t snapshot, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSnapshotReadImpl(vm, snapshot, out, outByteCount);
}
double rive_web_shared_snapshot_seq(uint32_t vmHandle, uint32_t snapshot)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSnapshotSeqImpl(vm, snapshot);
}
void rive_web_shared_read_done(uint32_t vmHandle)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    sharedReadDoneImpl(vm);
}
uint32_t rive_web_shared_signal_create(uint32_t vmHandle)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSignalCreateImpl(vm);
}
void rive_web_shared_signal_notify(uint32_t vmHandle, uint32_t signal)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    sharedSignalNotifyImpl(vm, signal);
}
double rive_web_shared_signal_seq(uint32_t vmHandle, uint32_t signal)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedSignalSeqImpl(vm, signal);
}
uint32_t rive_web_shared_blob_create(uint32_t vmHandle, const uint8_t* data, uint32_t dataByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedBlobCreateImpl(vm, data, dataByteCount);
}
uint32_t rive_web_shared_blob_size(uint32_t vmHandle, uint32_t blob)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedBlobSizeImpl(vm, blob);
}
uint32_t rive_web_shared_blob_read(uint32_t vmHandle, uint32_t blob, uint32_t offset, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedBlobReadImpl(vm, blob, offset, out, outByteCount);
}
uint32_t rive_web_shared_retain(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    return sharedRetainImpl(vm, object);
}
void rive_web_shared_release(uint32_t vmHandle, uint32_t object)
{
    WasmScriptingVM* vm = bootVmFromHandle(vmHandle);
    sharedReleaseImpl(vm, object);
}

static void* const kRiveWebCalls[] = {
    (void*)rive_web_rt_log,
    (void*)rive_web_rt_mark_needs_update,
    (void*)rive_web_rt_budget_exceeded,
    (void*)rive_web_rt_error,
    (void*)rive_web_rt_debug_enter,
    (void*)rive_web_rt_debug_line,
    (void*)rive_web_rt_debug_leave,
    (void*)rive_web_rt_utc_offset,
    (void*)rive_web_rt_is_dst,
    (void*)rive_web_rt_zone_name,
    (void*)rive_web_data_view_model,
    (void*)rive_web_data_root_view_model,
    (void*)rive_web_data_global_view_model,
    (void*)rive_web_data_global_view_model_names,
    (void*)rive_web_data_context,
    (void*)rive_web_data_context_parent,
    (void*)rive_web_data_context_view_model,
    (void*)rive_web_data_context_release,
    (void*)rive_web_data_has_view_model,
    (void*)rive_web_data_new_view_model,
    (void*)rive_web_data_vmi_release,
    (void*)rive_web_data_vmi_number,
    (void*)rive_web_data_vmi_boolean,
    (void*)rive_web_data_vmi_string,
    (void*)rive_web_data_vmi_trigger,
    (void*)rive_web_data_vmi_color,
    (void*)rive_web_data_vmi_view_model,
    (void*)rive_web_data_vmi_property,
    (void*)rive_web_data_vmi_instance,
    (void*)rive_web_data_vmi_symbol_index,
    (void*)rive_web_data_vmi_equal,
    (void*)rive_web_data_view_model_get,
    (void*)rive_web_data_vmi_list,
    (void*)rive_web_data_vmi_enum,
    (void*)rive_web_data_vmi_image,
    (void*)rive_web_data_vmi_font,
    (void*)rive_web_data_vmi_blob,
    (void*)rive_web_data_vmi_artboard,
    (void*)rive_web_data_image_get,
    (void*)rive_web_data_image_set,
    (void*)rive_web_data_font_get,
    (void*)rive_web_data_font_set,
    (void*)rive_web_data_font_release,
    (void*)rive_web_data_blob_present,
    (void*)rive_web_data_blob_get,
    (void*)rive_web_data_blob_name,
    (void*)rive_web_data_blob_set,
    (void*)rive_web_data_blob_clear,
    (void*)rive_web_data_artboard_get,
    (void*)rive_web_data_artboard_set,
    (void*)rive_web_data_enum_get,
    (void*)rive_web_data_enum_set,
    (void*)rive_web_data_enum_values,
    (void*)rive_web_data_prop_release,
    (void*)rive_web_data_trigger_fire,
    (void*)rive_web_data_list_length,
    (void*)rive_web_data_list_push,
    (void*)rive_web_data_list_pop,
    (void*)rive_web_data_list_shift,
    (void*)rive_web_data_list_clear,
    (void*)rive_web_data_list_swap,
    (void*)rive_web_data_list_insert,
    (void*)rive_web_data_list_remove,
    (void*)rive_web_data_list_remove_at,
    (void*)rive_web_data_list_remove_all_of,
    (void*)rive_web_data_list_get,
    (void*)rive_web_data_view_model_set,
    (void*)rive_web_data_color_get,
    (void*)rive_web_data_color_set,
    (void*)rive_web_data_number_get,
    (void*)rive_web_data_number_set,
    (void*)rive_web_data_boolean_get,
    (void*)rive_web_data_boolean_set,
    (void*)rive_web_data_string_get,
    (void*)rive_web_data_string_changed,
    (void*)rive_web_data_string_set,
    (void*)rive_web_data_watch,
    (void*)rive_web_data_unwatch,
    (void*)rive_web_data_convert_result,
    (void*)rive_web_artboard_release,
    (void*)rive_web_artboard_advance,
    (void*)rive_web_artboard_draw,
    (void*)rive_web_artboard_instance,
    (void*)rive_web_artboard_data,
    (void*)rive_web_artboard_width,
    (void*)rive_web_artboard_height,
    (void*)rive_web_artboard_set_width,
    (void*)rive_web_artboard_set_height,
    (void*)rive_web_artboard_frame_origin,
    (void*)rive_web_artboard_set_frame_origin,
    (void*)rive_web_artboard_bounds,
    (void*)rive_web_artboard_pointer_event,
    (void*)rive_web_artboard_scroll_event,
    (void*)rive_web_artboard_gamepad_event,
    (void*)rive_web_artboard_animation,
    (void*)rive_web_artboard_animation_release,
    (void*)rive_web_artboard_animation_duration,
    (void*)rive_web_artboard_animation_advance,
    (void*)rive_web_artboard_animation_set_time,
    (void*)rive_web_artboard_add_to_path,
    (void*)rive_web_artboard_node,
    (void*)rive_web_artboard_node_release,
    (void*)rive_web_artboard_node_transform,
    (void*)rive_web_artboard_node_set,
    (void*)rive_web_artboard_node_world_transform,
    (void*)rive_web_artboard_node_set_world_transform,
    (void*)rive_web_artboard_node_decompose,
    (void*)rive_web_artboard_node_path_verbs,
    (void*)rive_web_artboard_node_path_points,
    (void*)rive_web_artboard_node_paint,
    (void*)rive_web_artboard_node_children,
    (void*)rive_web_artboard_node_parent,
    (void*)rive_web_artboard_property_key,
    (void*)rive_web_artboard_draw_visit,
    (void*)rive_web_artboard_draw_modulated,
    (void*)rive_web_artboard_drawable_draw,
    (void*)rive_web_artboard_drawable_value,
    (void*)rive_web_artboard_drawable_string,
#ifdef WITH_RIVE_TOOLS
    (void*)rive_web_artboard_drawable_properties,
#else
    nullptr,
#endif
    (void*)rive_web_audio_source,
    (void*)rive_web_audio_source_release,
    (void*)rive_web_audio_source_duration,
    (void*)rive_web_audio_source_sample_rate,
    (void*)rive_web_audio_source_channels,
    (void*)rive_web_audio_source_to_blob,
    (void*)rive_web_audio_stream,
    (void*)rive_web_audio_stream_ring,
    (void*)rive_web_audio_stream_seeks,
    (void*)rive_web_audio_stream_channels,
    (void*)rive_web_audio_stream_sample_rate,
    (void*)rive_web_audio_stream_seek_frame,
    (void*)rive_web_audio_stream_set_loop,
    (void*)rive_web_audio_stream_ended,
    (void*)rive_web_audio_stream_release,
    (void*)rive_web_audio_play,
    (void*)rive_web_audio_play_at_time,
    (void*)rive_web_audio_play_in_time,
    (void*)rive_web_audio_play_at_frame,
    (void*)rive_web_audio_play_in_frame,
    (void*)rive_web_audio_time,
    (void*)rive_web_audio_time_frame,
    (void*)rive_web_audio_sample_rate,
    (void*)rive_web_audio_processor_sample_rate,
    (void*)rive_web_audio_processor_channels,
    (void*)rive_web_audio_sound_release,
    (void*)rive_web_audio_sound_play,
    (void*)rive_web_audio_sound_pause,
    (void*)rive_web_audio_sound_resume,
    (void*)rive_web_audio_sound_stop,
    (void*)rive_web_audio_sound_seek,
    (void*)rive_web_audio_sound_seek_frame,
    (void*)rive_web_audio_sound_completed,
    (void*)rive_web_audio_sound_time,
    (void*)rive_web_audio_sound_time_frame,
    (void*)rive_web_audio_sound_volume,
    (void*)rive_web_audio_sound_set_volume,
    (void*)rive_web_path_new,
    (void*)rive_web_path_update,
    (void*)rive_web_path_release,
    (void*)rive_web_path_add,
    (void*)rive_web_path_verbs,
    (void*)rive_web_path_points,
    (void*)rive_web_path_effect_result,
    (void*)rive_web_measure_path_new,
    (void*)rive_web_measure_contours_new,
    (void*)rive_web_measure_contour_next,
    (void*)rive_web_measure_length,
    (void*)rive_web_measure_is_closed,
    (void*)rive_web_measure_pos_tan,
    (void*)rive_web_measure_warp,
    (void*)rive_web_measure_extract,
    (void*)rive_web_measure_extract_read,
    (void*)rive_web_measure_release,
    (void*)rive_web_paint_new,
    (void*)rive_web_paint_release,
    (void*)rive_web_paint_style,
    (void*)rive_web_paint_color,
    (void*)rive_web_paint_thickness,
    (void*)rive_web_paint_join,
    (void*)rive_web_paint_cap,
    (void*)rive_web_paint_blend_mode,
    (void*)rive_web_paint_feather,
    (void*)rive_web_paint_shader,
    (void*)rive_web_paint_shader_transform,
    (void*)rive_web_canvas_new,
    (void*)rive_web_canvas_release,
    (void*)rive_web_canvas_width,
    (void*)rive_web_canvas_height,
    (void*)rive_web_canvas_resize,
    (void*)rive_web_canvas_image,
    (void*)rive_web_canvas_begin_frame,
    (void*)rive_web_canvas_end_frame,
    (void*)rive_web_gpu_features,
    (void*)rive_web_gpu_canvas_new,
    (void*)rive_web_gpu_canvas_release,
    (void*)rive_web_gpu_canvas_color_view,
    (void*)rive_web_gpu_canvas_image,
    (void*)rive_web_gpu_canvas_resize,
    (void*)rive_web_gpu_target_view,
    (void*)rive_web_gpu_pass_begin,
    (void*)rive_web_gpu_pass_set_pipeline,
    (void*)rive_web_gpu_pass_set_vertex_buffer,
    (void*)rive_web_gpu_pass_set_index_buffer,
    (void*)rive_web_gpu_pass_set_bind_group,
    (void*)rive_web_gpu_pass_set_viewport,
    (void*)rive_web_gpu_pass_set_scissor,
    (void*)rive_web_gpu_pass_set_stencil_reference,
    (void*)rive_web_gpu_pass_set_blend_color,
    (void*)rive_web_gpu_pass_draw,
    (void*)rive_web_gpu_pass_draw_indexed,
    (void*)rive_web_gpu_pass_finish,
    (void*)rive_web_gpu_pass_release,
    (void*)rive_web_gpu_image_view,
    (void*)rive_web_gpu_buffer_new,
    (void*)rive_web_gpu_buffer_update,
    (void*)rive_web_gpu_buffer_update_blob,
    (void*)rive_web_gpu_buffer_new_blob,
    (void*)rive_web_gpu_buffer_release,
    (void*)rive_web_gpu_texture_new,
    (void*)rive_web_gpu_texture_upload,
    (void*)rive_web_gpu_texture_release,
    (void*)rive_web_gpu_sampler_new,
    (void*)rive_web_gpu_sampler_release,
    (void*)rive_web_gpu_texture_view_new,
    (void*)rive_web_gpu_texture_view_release,
    (void*)rive_web_gpu_shader_target,
    (void*)rive_web_gpu_shader_asset_bytes,
    (void*)rive_web_gpu_shader_asset_id,
    (void*)rive_web_gpu_shader_module_from_asset,
#ifdef WITH_RIVE_TOOLS
    (void*)rive_web_gpu_shader_module_from_rstb,
#else
    nullptr,
#endif
    (void*)rive_web_gpu_shader_module_release,
    (void*)rive_web_gpu_bind_group_layout_new,
    (void*)rive_web_gpu_bind_group_layout_release,
    (void*)rive_web_gpu_bind_group_layout_from_shader,
    (void*)rive_web_gpu_bind_group_layout_from_shaders,
    (void*)rive_web_gpu_bind_group_layout_from_entries,
    (void*)rive_web_gpu_bind_group_new,
    (void*)rive_web_gpu_bind_group_release,
    (void*)rive_web_gpu_pipeline_new,
    (void*)rive_web_gpu_pipeline_release,
    (void*)rive_web_mat4_multiply,
    (void*)rive_web_mat4_invert,
    (void*)rive_web_buffer_new,
    (void*)rive_web_buffer_update,
    (void*)rive_web_buffer_release,
    (void*)rive_web_mesh_instances_new,
    (void*)rive_web_mesh_instances_resize,
    (void*)rive_web_mesh_instances_update,
    (void*)rive_web_mesh_instances_release,
    (void*)rive_web_blob_asset_bytes,
    (void*)rive_web_image_from_asset,
    (void*)rive_web_image_width,
    (void*)rive_web_image_height,
    (void*)rive_web_image_release,
    (void*)rive_web_image_decode,
    (void*)rive_web_image_decode_cancel,
    (void*)rive_web_font_from_asset,
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_font_decode,
#else
    nullptr,
#endif
    (void*)rive_web_font_release,
    (void*)rive_web_font_metrics,
    (void*)rive_web_font_weight,
    (void*)rive_web_font_is_italic,
    (void*)rive_web_font_axis_count,
    (void*)rive_web_font_axis,
    (void*)rive_web_font_axis_value,
    (void*)rive_web_font_features,
    (void*)rive_web_font_has_glyph,
    (void*)rive_web_font_with_options,
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_font_glyph_verbs,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_font_glyph_points,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_new,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_release,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_append,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_clear,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_layout,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_draw,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_bounds,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_length,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_lines,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_runs,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_glyphs,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_hit_test,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_caret,
#else
    nullptr,
#endif
#ifdef WITH_RIVE_TEXT
    (void*)rive_web_text_selection_rects,
#else
    nullptr,
#endif
    (void*)rive_web_shader_linear,
    (void*)rive_web_shader_radial,
    (void*)rive_web_shader_release,
    (void*)rive_web_test_blob,
    (void*)rive_web_transition_child_draw,
    (void*)rive_web_transition_child_width,
    (void*)rive_web_transition_child_height,
    (void*)rive_web_renderer_save,
    (void*)rive_web_renderer_restore,
    (void*)rive_web_renderer_transform,
    (void*)rive_web_renderer_draw_path,
    (void*)rive_web_renderer_clip_path,
    (void*)rive_web_renderer_modulate_opacity,
    (void*)rive_web_renderer_modulate_color,
    (void*)rive_web_renderer_draw_image,
    (void*)rive_web_renderer_draw_image_mesh,
    (void*)rive_web_renderer_draw_image_mesh_instanced,
    (void*)rive_web_net_fetch,
    (void*)rive_web_net_fetch_cancel,
    (void*)rive_web_file_decode,
    (void*)rive_web_file_release,
    (void*)rive_web_file_artboard_count,
    (void*)rive_web_file_artboard_name,
    (void*)rive_web_file_bindable,
    (void*)rive_web_file_bindable_release,
    (void*)rive_web_file_bindable_name,
    (void*)rive_web_file_bindable_data,
    (void*)rive_web_file_bindable_equal,
    (void*)rive_web_lanes_start,
    (void*)rive_web_lanes_state,
    (void*)rive_web_lanes_failed,
    (void*)rive_web_lanes_stop,
    (void*)rive_web_lanes_release,
    (void*)rive_web_lanes_result,
    (void*)rive_web_lanes_watch,
    (void*)rive_web_lanes_wait,
    (void*)rive_web_lanes_cancel_wait,
    (void*)rive_web_lanes_wait_within,
    (void*)rive_web_jobs_threads,
    (void*)rive_web_jobs_join,
    (void*)rive_web_jobs_join_any,
    (void*)rive_web_parallel_size,
#ifdef RIVE_WASM_PARALLEL
    (void*)rive_web_parallel_run,
#else
    nullptr,
#endif
    (void*)rive_web_shared_region_create,
    (void*)rive_web_shared_region_size,
    (void*)rive_web_shared_region_lock,
    (void*)rive_web_shared_region_unlock,
    (void*)rive_web_shared_region_read,
    (void*)rive_web_shared_region_write,
    (void*)rive_web_shared_region_poisoned,
    (void*)rive_web_shared_atomic_load,
    (void*)rive_web_shared_atomic_store,
    (void*)rive_web_shared_atomic_add,
    (void*)rive_web_shared_atomic_cas,
    (void*)rive_web_shared_ring_create,
    (void*)rive_web_shared_ring_write,
    (void*)rive_web_shared_ring_read,
    (void*)rive_web_shared_ring_drop,
    (void*)rive_web_shared_ring_used,
    (void*)rive_web_shared_ring_signal,
    (void*)rive_web_shared_snapshot_create,
    (void*)rive_web_shared_snapshot_publish,
    (void*)rive_web_shared_snapshot_read,
    (void*)rive_web_shared_snapshot_seq,
    (void*)rive_web_shared_read_done,
    (void*)rive_web_shared_signal_create,
    (void*)rive_web_shared_signal_notify,
    (void*)rive_web_shared_signal_seq,
    (void*)rive_web_shared_blob_create,
    (void*)rive_web_shared_blob_size,
    (void*)rive_web_shared_blob_read,
    (void*)rive_web_shared_retain,
    (void*)rive_web_shared_release,
    (void*)rive_web_console,
    (void*)rive_web_trace,
};

EMSCRIPTEN_KEEPALIVE
void* const* rive_web_calls() { return kRiveWebCalls; }

} // extern "C"

#endif // __EMSCRIPTEN__