src/wasm/wasm_natives_gen.hpp

// Generated by src/wasm/idl/generate.py from bindings.py. Do not edit.
//
// Included inside wasm_scripting_vm.cpp's anonymous namespace before
// the native implementations; the declarations pin each hand-written
// impl core to the contract signature (a mismatch makes the table
// cast ambiguous). The WAMR wrappers adapt exec_env to the VM the
// cores share with the browser lane's generated C shims.
// clang-format off

typedef struct rive_text_layout_desc_v1
{
    uint32_t sizing;
    uint32_t overflow;
    uint32_t align;
    uint32_t wrap;
    uint32_t wordBreak;
    uint32_t origin;
    uint32_t direction;
    float maxWidth;
    float maxHeight;
    float paragraphSpacing;
} rive_text_layout_desc_v1;

typedef struct rive_gpu_texture_desc_v1
{
    uint32_t width;
    uint32_t height;
    uint32_t depthOrArrayLayers;
    uint32_t format;
    uint32_t textureType;
    uint32_t renderTarget;
    uint32_t numMipmaps;
    uint32_t sampleCount;
} rive_gpu_texture_desc_v1;

typedef struct rive_gpu_texture_upload_v1
{
    uint32_t bytesPerRow;
    uint32_t rowsPerImage;
    uint32_t mipLevel;
    uint32_t layer;
    uint32_t x;
    uint32_t y;
    uint32_t z;
    uint32_t width;
    uint32_t height;
    uint32_t depth;
} rive_gpu_texture_upload_v1;

typedef struct rive_gpu_sampler_desc_v1
{
    uint32_t minFilter;
    uint32_t magFilter;
    uint32_t mipmapFilter;
    uint32_t wrapU;
    uint32_t wrapV;
    uint32_t wrapW;
    uint32_t compare;
    float minLod;
    float maxLod;
    uint32_t maxAnisotropy;
} rive_gpu_sampler_desc_v1;

typedef struct rive_gpu_texture_view_desc_v1
{
    uint32_t dimension;
    uint32_t aspect;
    uint32_t baseMipLevel;
    uint32_t mipCount;
    uint32_t baseLayer;
    uint32_t layerCount;
} rive_gpu_texture_view_desc_v1;

typedef struct rive_gpu_bind_group_layout_entry_v1
{
    uint32_t binding;
    uint32_t kind;
    uint32_t visibility;
    uint32_t hasDynamicOffset;
    uint32_t textureViewDim;
    uint32_t textureSampleType;
    uint32_t textureMultisampled;
    uint32_t minBindingSize;
    uint32_t nativeSlotVS;
    uint32_t nativeSlotFS;
    uint32_t nativeSlotCS;
    uint32_t samplerNonFiltering;
} rive_gpu_bind_group_layout_entry_v1;

typedef struct rive_gpu_bind_group_ubo_v1
{
    uint32_t slot;
    uint32_t buffer;
    uint32_t offset;
    uint32_t size;
} rive_gpu_bind_group_ubo_v1;

typedef struct rive_gpu_bind_group_texture_v1
{
    uint32_t slot;
    uint32_t view;
} rive_gpu_bind_group_texture_v1;

typedef struct rive_gpu_bind_group_sampler_v1
{
    uint32_t slot;
    uint32_t sampler;
} rive_gpu_bind_group_sampler_v1;

typedef struct rive_gpu_color_target_v1
{
    uint32_t format;
    uint32_t blendEnabled;
    uint32_t srcColor;
    uint32_t dstColor;
    uint32_t colorOp;
    uint32_t srcAlpha;
    uint32_t dstAlpha;
    uint32_t alphaOp;
    uint32_t writeMask;
} rive_gpu_color_target_v1;

typedef struct rive_gpu_vertex_buffer_layout_v1
{
    uint32_t stride;
    uint32_t stepMode;
    uint32_t attributeCount;
} rive_gpu_vertex_buffer_layout_v1;

typedef struct rive_gpu_vertex_attribute_v1
{
    uint32_t format;
    uint32_t offset;
    uint32_t shaderSlot;
} rive_gpu_vertex_attribute_v1;

typedef struct rive_gpu_pass_color_attachment_v1
{
    uint32_t view;
    uint32_t resolveTarget;
    uint32_t loadOp;
    uint32_t storeOp;
    float clearR;
    float clearG;
    float clearB;
    float clearA;
} rive_gpu_pass_color_attachment_v1;

typedef struct rive_gpu_pass_desc_v1
{
    uint32_t colorCount;
    uint32_t depthView;
    uint32_t depthLoadOp;
    uint32_t depthStoreOp;
    float depthClearValue;
    uint32_t stencilLoadOp;
    uint32_t stencilStoreOp;
    uint32_t stencilClearValue;
    uint32_t labelSize;
} rive_gpu_pass_desc_v1;

typedef struct rive_gpu_pipeline_desc_v1
{
    uint32_t vertexModule;
    uint32_t fragmentModule;
    uint32_t vertexEntrySize;
    uint32_t fragmentEntrySize;
    uint32_t colorCount;
    uint32_t vertexBufferCount;
    uint32_t attributeCount;
    uint32_t bindGroupLayoutCount;
    uint32_t topology;
    uint32_t indexFormat;
    uint32_t cullMode;
    uint32_t winding;
    uint32_t depthFormat;
    uint32_t depthCompare;
    uint32_t depthWriteEnabled;
    uint32_t depthBias;
    float depthBiasSlopeScale;
    float depthBiasClamp;
    uint32_t stencilFrontCompare;
    uint32_t stencilFrontFailOp;
    uint32_t stencilFrontDepthFailOp;
    uint32_t stencilFrontPassOp;
    uint32_t stencilBackCompare;
    uint32_t stencilBackFailOp;
    uint32_t stencilBackDepthFailOp;
    uint32_t stencilBackPassOp;
    uint32_t stencilReadMask;
    uint32_t stencilWriteMask;
    uint32_t sampleCount;
} rive_gpu_pipeline_desc_v1;

void rtLogImpl(WasmScriptingVM* vm, int32_t level, const char* message, uint32_t length);
void rtMarkNeedsUpdateImpl(WasmScriptingVM* vm, uint32_t object);
void rtBudgetExceededImpl(WasmScriptingVM* vm, uint32_t ms);
void rtErrorImpl(WasmScriptingVM* vm, const char* message, uint32_t length);
double rtNowImpl(WasmScriptingVM* vm);
double rtDateNowImpl(WasmScriptingVM* vm);
uint32_t rtFeaturesImpl(WasmScriptingVM* vm);
void rtDebugEnterImpl(WasmScriptingVM* vm, uint32_t func, uint32_t line);
uint32_t rtDebugLineImpl(WasmScriptingVM* vm, uint32_t line);
void rtDebugLeaveImpl(WasmScriptingVM* vm);
uint32_t rtUtcOffsetImpl(WasmScriptingVM* vm, double epochSeconds);
uint32_t rtIsDstImpl(WasmScriptingVM* vm, double epochSeconds);
uint32_t rtZoneNameImpl(WasmScriptingVM* vm, double epochSeconds, char* buffer, uint32_t capacity);
uint32_t dataViewModelImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataRootViewModelImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataGlobalViewModelImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength);
uint32_t dataGlobalViewModelNamesImpl(WasmScriptingVM* vm, uint32_t object, char* buffer, uint32_t capacity);
uint32_t dataContextImpl(WasmScriptingVM* vm, uint32_t object);
uint32_t dataContextParentImpl(WasmScriptingVM* vm, uint32_t dataContext);
uint32_t dataContextViewModelImpl(WasmScriptingVM* vm, uint32_t dataContext);
void dataContextReleaseImpl(WasmScriptingVM* vm, uint32_t dataContext);
uint32_t dataHasViewModelImpl(WasmScriptingVM* vm, const char* name, uint32_t nameLength);
uint32_t dataNewViewModelImpl(WasmScriptingVM* vm, const char* name, uint32_t nameLength, const char* templateName, uint32_t templateLength);
void dataVmiReleaseImpl(WasmScriptingVM* vm, uint32_t vmi);
uint32_t dataVmiNumberImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiBooleanImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiStringImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiTriggerImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiColorImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiViewModelImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiPropertyImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length, uint32_t* kindOut, uint32_t kindCount);
uint32_t dataVmiInstanceImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t nameLength);
uint32_t dataVmiSymbolIndexImpl(WasmScriptingVM* vm, uint32_t vmi);
uint32_t dataVmiEqualImpl(WasmScriptingVM* vm, uint32_t a, uint32_t b);
uint32_t dataViewModelGetImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataVmiListImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiEnumImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiImageImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiFontImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiBlobImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataVmiArtboardImpl(WasmScriptingVM* vm, uint32_t vmi, const char* name, uint32_t length);
uint32_t dataImageGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataImageSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t image);
uint32_t dataFontGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataFontSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t font);
void dataFontReleaseImpl(WasmScriptingVM* vm, uint32_t font);
uint32_t dataBlobPresentImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataBlobGetImpl(WasmScriptingVM* vm, uint32_t property, uint8_t* buffer, uint32_t capacity);
uint32_t dataBlobNameImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataBlobSetImpl(WasmScriptingVM* vm, uint32_t property, const uint8_t* bytes, uint32_t byteCount);
void dataBlobClearImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataArtboardGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataArtboardSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t bindable);
uint32_t dataEnumGetImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataEnumSetImpl(WasmScriptingVM* vm, uint32_t property, const char* value, uint32_t length);
uint32_t dataEnumValuesImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
void dataPropReleaseImpl(WasmScriptingVM* vm, uint32_t property);
void dataTriggerFireImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataListLengthImpl(WasmScriptingVM* vm, uint32_t property);
void dataListPushImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataListPopImpl(WasmScriptingVM* vm, uint32_t property);
uint32_t dataListShiftImpl(WasmScriptingVM* vm, uint32_t property);
void dataListClearImpl(WasmScriptingVM* vm, uint32_t property);
void dataListSwapImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index1, uint32_t index2);
void dataListInsertImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi, uint32_t index);
void dataListRemoveImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
void dataListRemoveAtImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index);
void dataListRemoveAllOfImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataListGetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t index);
void dataViewModelSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t vmi);
uint32_t dataColorGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataColorSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t value);
float dataNumberGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataNumberSetImpl(WasmScriptingVM* vm, uint32_t property, float value);
uint32_t dataBooleanGetImpl(WasmScriptingVM* vm, uint32_t property);
void dataBooleanSetImpl(WasmScriptingVM* vm, uint32_t property, uint32_t value);
uint32_t dataStringGetImpl(WasmScriptingVM* vm, uint32_t property, char* buffer, uint32_t capacity);
uint32_t dataStringChangedImpl(WasmScriptingVM* vm, uint32_t property);
void dataStringSetImpl(WasmScriptingVM* vm, uint32_t property, const char* value, uint32_t length);
void dataWatchImpl(WasmScriptingVM* vm, uint32_t property, uint32_t token);
void dataUnwatchImpl(WasmScriptingVM* vm, uint32_t property);
void dataConvertResultImpl(WasmScriptingVM* vm, uint32_t kind, float number, uint32_t booleanValue, uint32_t color, const char* value, uint32_t length);
void artboardReleaseImpl(WasmScriptingVM* vm, uint32_t artboard);
uint32_t artboardAdvanceImpl(WasmScriptingVM* vm, uint32_t artboard, float seconds);
void artboardDrawImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t renderer);
uint32_t artboardInstanceImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t vmi);
uint32_t artboardDataImpl(WasmScriptingVM* vm, uint32_t artboard);
float artboardWidthImpl(WasmScriptingVM* vm, uint32_t artboard);
float artboardHeightImpl(WasmScriptingVM* vm, uint32_t artboard);
void artboardSetWidthImpl(WasmScriptingVM* vm, uint32_t artboard, float value);
void artboardSetHeightImpl(WasmScriptingVM* vm, uint32_t artboard, float value);
uint32_t artboardFrameOriginImpl(WasmScriptingVM* vm, uint32_t artboard);
void artboardSetFrameOriginImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t value);
void artboardBoundsImpl(WasmScriptingVM* vm, uint32_t artboard, float* out, uint32_t outCount);
uint32_t artboardPointerEventImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t kind, uint32_t pointerId, float x, float y);
uint32_t artboardScrollEventImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t pointerId, float x, float y, float dx, float dy, uint32_t phase, uint32_t precise, float timeStamp);
uint32_t artboardGamepadEventImpl(WasmScriptingVM* vm, uint32_t artboard, const uint8_t* payload, uint32_t byteCount);
uint32_t artboardAnimationImpl(WasmScriptingVM* vm, uint32_t artboard, const char* name, uint32_t length);
void artboardAnimationReleaseImpl(WasmScriptingVM* vm, uint32_t animation);
float artboardAnimationDurationImpl(WasmScriptingVM* vm, uint32_t animation);
uint32_t artboardAnimationAdvanceImpl(WasmScriptingVM* vm, uint32_t animation, float seconds);
void artboardAnimationSetTimeImpl(WasmScriptingVM* vm, uint32_t animation, float value, uint32_t mode);
void artboardAddToPathImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t path, float xx, float xy, float yx, float yy, float tx, float ty);
uint32_t artboardNodeImpl(WasmScriptingVM* vm, uint32_t artboard, const char* name, uint32_t length);
void artboardNodeReleaseImpl(WasmScriptingVM* vm, uint32_t node);
void artboardNodeTransformImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
void artboardNodeSetImpl(WasmScriptingVM* vm, uint32_t node, uint32_t field, float v0, float v1);
void artboardNodeWorldTransformImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
void artboardNodeSetWorldTransformImpl(WasmScriptingVM* vm, uint32_t node, const float* values, uint32_t floatCount);
void artboardNodeDecomposeImpl(WasmScriptingVM* vm, uint32_t node, const float* values, uint32_t floatCount);
uint32_t artboardNodePathVerbsImpl(WasmScriptingVM* vm, uint32_t node, uint8_t* out, uint32_t outCount);
uint32_t artboardNodePathPointsImpl(WasmScriptingVM* vm, uint32_t node, float* out, uint32_t outCount);
uint32_t artboardNodePaintImpl(WasmScriptingVM* vm, uint32_t node, uint32_t* out, uint32_t outCount);
uint32_t artboardNodeChildrenImpl(WasmScriptingVM* vm, uint32_t node, uint32_t* out, uint32_t outCount);
uint32_t artboardNodeParentImpl(WasmScriptingVM* vm, uint32_t node);
uint32_t artboardPropertyKeyImpl(WasmScriptingVM* vm, uint32_t artboard, const char* name, uint32_t length);
void artboardDrawVisitImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t renderer);
void artboardDrawModulatedImpl(WasmScriptingVM* vm, uint32_t artboard, uint32_t renderer, uint32_t key);
void artboardDrawableDrawImpl(WasmScriptingVM* vm, uint32_t drawable, uint32_t renderer);
uint32_t artboardDrawableValueImpl(WasmScriptingVM* vm, uint32_t drawable, uint32_t key, uint32_t* out, uint32_t outCount);
uint32_t artboardDrawableStringImpl(WasmScriptingVM* vm, uint32_t drawable, uint32_t key, char* out, uint32_t outCount);
#ifdef WITH_RIVE_TOOLS
uint32_t artboardDrawablePropertiesImpl(WasmScriptingVM* vm, uint32_t drawable, char* out, uint32_t outCount);
#endif
uint32_t audioSourceImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength);
void audioSourceReleaseImpl(WasmScriptingVM* vm, uint32_t source);
float audioSourceDurationImpl(WasmScriptingVM* vm, uint32_t source);
uint32_t audioSourceSampleRateImpl(WasmScriptingVM* vm, uint32_t source);
uint32_t audioSourceChannelsImpl(WasmScriptingVM* vm, uint32_t source);
uint32_t audioSourceToBlobImpl(WasmScriptingVM* vm, uint32_t source, uint32_t sampleRate, uint32_t channels);
uint32_t audioStreamImpl(WasmScriptingVM* vm, uint32_t source, uint32_t sampleRate, uint32_t channels, uint32_t chunkFrames, uint32_t bufferFrames);
uint32_t audioStreamRingImpl(WasmScriptingVM* vm, uint32_t stream);
uint32_t audioStreamSeeksImpl(WasmScriptingVM* vm, uint32_t stream);
uint32_t audioStreamChannelsImpl(WasmScriptingVM* vm, uint32_t stream);
uint32_t audioStreamSampleRateImpl(WasmScriptingVM* vm, uint32_t stream);
uint32_t audioStreamSeekFrameImpl(WasmScriptingVM* vm, uint32_t stream, double frame);
void audioStreamSetLoopImpl(WasmScriptingVM* vm, uint32_t stream, uint32_t loop);
uint32_t audioStreamEndedImpl(WasmScriptingVM* vm, uint32_t stream);
void audioStreamReleaseImpl(WasmScriptingVM* vm, uint32_t stream);
uint32_t audioPlayImpl(WasmScriptingVM* vm, uint32_t source);
uint32_t audioPlayAtTimeImpl(WasmScriptingVM* vm, uint32_t source, float seconds);
uint32_t audioPlayInTimeImpl(WasmScriptingVM* vm, uint32_t source, float seconds);
uint32_t audioPlayAtFrameImpl(WasmScriptingVM* vm, uint32_t source, double frame);
uint32_t audioPlayInFrameImpl(WasmScriptingVM* vm, uint32_t source, double frame);
float audioTimeImpl(WasmScriptingVM* vm);
double audioTimeFrameImpl(WasmScriptingVM* vm);
uint32_t audioSampleRateImpl(WasmScriptingVM* vm);
uint32_t audioProcessorSampleRateImpl(WasmScriptingVM* vm);
uint32_t audioProcessorChannelsImpl(WasmScriptingVM* vm);
void audioSoundReleaseImpl(WasmScriptingVM* vm, uint32_t sound);
void audioSoundPlayImpl(WasmScriptingVM* vm, uint32_t sound);
void audioSoundPauseImpl(WasmScriptingVM* vm, uint32_t sound);
void audioSoundResumeImpl(WasmScriptingVM* vm, uint32_t sound);
void audioSoundStopImpl(WasmScriptingVM* vm, uint32_t sound, uint32_t fadeFrames);
uint32_t audioSoundSeekImpl(WasmScriptingVM* vm, uint32_t sound, float seconds);
uint32_t audioSoundSeekFrameImpl(WasmScriptingVM* vm, uint32_t sound, double frame);
uint32_t audioSoundCompletedImpl(WasmScriptingVM* vm, uint32_t sound);
float audioSoundTimeImpl(WasmScriptingVM* vm, uint32_t sound);
double audioSoundTimeFrameImpl(WasmScriptingVM* vm, uint32_t sound);
float audioSoundVolumeImpl(WasmScriptingVM* vm, uint32_t sound);
void audioSoundSetVolumeImpl(WasmScriptingVM* vm, uint32_t sound, float value);
uint32_t pathNewImpl(WasmScriptingVM* vm);
void pathUpdateImpl(WasmScriptingVM* vm, uint32_t path, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount, uint32_t fillRule);
void pathReleaseImpl(WasmScriptingVM* vm, uint32_t path);
void pathAddImpl(WasmScriptingVM* vm, uint32_t path, uint32_t other, float xx, float xy, float yx, float yy, float tx, float ty);
uint32_t pathVerbsImpl(WasmScriptingVM* vm, uint32_t path, uint8_t* out, uint32_t outCount);
uint32_t pathPointsImpl(WasmScriptingVM* vm, uint32_t path, float* out, uint32_t outCount);
void pathEffectResultImpl(WasmScriptingVM* vm, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount);
uint32_t measurePathNewImpl(WasmScriptingVM* vm, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount);
uint32_t measureContoursNewImpl(WasmScriptingVM* vm, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount);
uint32_t measureContourNextImpl(WasmScriptingVM* vm, uint32_t measure);
float measureLengthImpl(WasmScriptingVM* vm, uint32_t measure);
uint32_t measureIsClosedImpl(WasmScriptingVM* vm, uint32_t measure);
void measurePosTanImpl(WasmScriptingVM* vm, uint32_t measure, float distance, float* out, uint32_t outCount);
void measureWarpImpl(WasmScriptingVM* vm, uint32_t measure, float x, float y, float* out, uint32_t outCount);
uint32_t measureExtractImpl(WasmScriptingVM* vm, uint32_t measure, float startDistance, float endDistance, uint32_t startWithMove);
uint32_t measureExtractReadImpl(WasmScriptingVM* vm, uint32_t measure, uint8_t* verbs, uint32_t verbCount, float* points, uint32_t floatCount);
void measureReleaseImpl(WasmScriptingVM* vm, uint32_t measure);
uint32_t paintNewImpl(WasmScriptingVM* vm);
void paintReleaseImpl(WasmScriptingVM* vm, uint32_t paint);
void paintStyleImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintColorImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintThicknessImpl(WasmScriptingVM* vm, uint32_t paint, float value);
void paintJoinImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintCapImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintBlendModeImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t value);
void paintFeatherImpl(WasmScriptingVM* vm, uint32_t paint, float value);
void paintShaderImpl(WasmScriptingVM* vm, uint32_t paint, uint32_t shader);
void paintShaderTransformImpl(WasmScriptingVM* vm, uint32_t paint, const float* values, uint32_t floatCount);
uint32_t canvasNewImpl(WasmScriptingVM* vm, uint32_t width, uint32_t height);
void canvasReleaseImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t canvasWidthImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t canvasHeightImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t canvasResizeImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t width, uint32_t height);
uint32_t canvasImageImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t canvasBeginFrameImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t clearColor);
void canvasEndFrameImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t gpuFeaturesImpl(WasmScriptingVM* vm, uint32_t* out, uint32_t outCount);
uint32_t gpuCanvasNewImpl(WasmScriptingVM* vm, uint32_t width, uint32_t height);
void gpuCanvasReleaseImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t gpuCanvasColorViewImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t* props, uint32_t propCount);
uint32_t gpuCanvasImageImpl(WasmScriptingVM* vm, uint32_t canvas);
uint32_t gpuCanvasResizeImpl(WasmScriptingVM* vm, uint32_t canvas, uint32_t width, uint32_t height, uint32_t* props, uint32_t propCount);
uint32_t gpuTargetViewImpl(WasmScriptingVM* vm, uint32_t current, uint32_t* props, uint32_t propCount);
uint32_t gpuPassBeginImpl(WasmScriptingVM* vm, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount);
void gpuPassSetPipelineImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t pipeline);
void gpuPassSetVertexBufferImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t slot, uint32_t buffer, uint32_t offset);
void gpuPassSetIndexBufferImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t buffer, uint32_t indexFormat, uint32_t offset);
void gpuPassSetBindGroupImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t groupIndex, uint32_t bindGroup, const uint32_t* dynamicOffsets, uint32_t dynamicOffsetByteCount);
void gpuPassSetViewportImpl(WasmScriptingVM* vm, uint32_t pass, float x, float y, float width, float height, float minDepth, float maxDepth);
void gpuPassSetScissorImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t x, uint32_t y, uint32_t width, uint32_t height);
void gpuPassSetStencilReferenceImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t ref);
void gpuPassSetBlendColorImpl(WasmScriptingVM* vm, uint32_t pass, float r, float g, float b, float a);
void gpuPassDrawImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
void gpuPassDrawIndexedImpl(WasmScriptingVM* vm, uint32_t pass, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance);
void gpuPassFinishImpl(WasmScriptingVM* vm, uint32_t pass);
void gpuPassReleaseImpl(WasmScriptingVM* vm, uint32_t pass);
uint32_t gpuImageViewImpl(WasmScriptingVM* vm, uint32_t image, uint32_t width, uint32_t height);
uint32_t gpuBufferNewImpl(WasmScriptingVM* vm, uint32_t usage, uint32_t sizeInBytes, uint32_t immutable, const uint8_t* data, uint32_t dataCount);
void gpuBufferUpdateImpl(WasmScriptingVM* vm, uint32_t buffer, uint32_t dstOffset, const uint8_t* data, uint32_t dataCount);
void gpuBufferUpdateBlobImpl(WasmScriptingVM* vm, uint32_t buffer, uint32_t dstOffset, uint32_t blob, uint32_t srcOffset, uint32_t byteCount);
uint32_t gpuBufferNewBlobImpl(WasmScriptingVM* vm, uint32_t usage, uint32_t immutable, uint32_t blob, uint32_t srcOffset, uint32_t byteCount);
void gpuBufferReleaseImpl(WasmScriptingVM* vm, uint32_t buffer);
uint32_t gpuTextureNewImpl(WasmScriptingVM* vm, const rive_gpu_texture_desc_v1* desc, uint32_t descByteCount);
void gpuTextureUploadImpl(WasmScriptingVM* vm, uint32_t texture, const rive_gpu_texture_upload_v1* region, uint32_t regionByteCount, const uint8_t* data, uint32_t dataCount);
void gpuTextureReleaseImpl(WasmScriptingVM* vm, uint32_t texture);
uint32_t gpuSamplerNewImpl(WasmScriptingVM* vm, const rive_gpu_sampler_desc_v1* desc, uint32_t descByteCount);
void gpuSamplerReleaseImpl(WasmScriptingVM* vm, uint32_t sampler);
uint32_t gpuTextureViewNewImpl(WasmScriptingVM* vm, uint32_t texture, const rive_gpu_texture_view_desc_v1* desc, uint32_t descByteCount);
void gpuTextureViewReleaseImpl(WasmScriptingVM* vm, uint32_t view);
uint32_t gpuShaderTargetImpl(WasmScriptingVM* vm);
uint32_t gpuShaderAssetBytesImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount);
uint32_t gpuShaderAssetIdImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength);
uint32_t gpuShaderModuleFromAssetImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength, uint32_t entry);
#ifdef WITH_RIVE_TOOLS
uint32_t gpuShaderModuleFromRstbImpl(WasmScriptingVM* vm, const uint8_t* rstb, uint32_t rstbCount, uint32_t assetId, uint32_t entry);
#endif
void gpuShaderModuleReleaseImpl(WasmScriptingVM* vm, uint32_t shaderModule);
uint32_t gpuBindGroupLayoutNewImpl(WasmScriptingVM* vm, uint32_t groupIndex, const rive_gpu_bind_group_layout_entry_v1* entries, uint32_t entryByteCount);
void gpuBindGroupLayoutReleaseImpl(WasmScriptingVM* vm, uint32_t layout);
uint32_t gpuBindGroupLayoutFromShaderImpl(WasmScriptingVM* vm, uint32_t shaderModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount);
uint32_t gpuBindGroupLayoutFromShadersImpl(WasmScriptingVM* vm, uint32_t vertexModule, uint32_t fragmentModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount);
uint32_t gpuBindGroupLayoutFromEntriesImpl(WasmScriptingVM* vm, uint32_t vertexModule, const char* vertexEntry, uint32_t vertexEntryLength, uint32_t fragmentModule, const char* fragmentEntry, uint32_t fragmentEntryLength, uint32_t groupIndex);
uint32_t gpuBindGroupNewImpl(WasmScriptingVM* vm, 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);
void gpuBindGroupReleaseImpl(WasmScriptingVM* vm, uint32_t bindGroup);
uint32_t gpuPipelineNewImpl(WasmScriptingVM* vm, const rive_gpu_pipeline_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount);
void gpuPipelineReleaseImpl(WasmScriptingVM* vm, uint32_t pipeline);
void mat4MultiplyImpl(WasmScriptingVM* vm, uint8_t* out, uint32_t outBytes, const uint8_t* a, uint32_t aBytes, const uint8_t* b, uint32_t bBytes);
uint32_t mat4InvertImpl(WasmScriptingVM* vm, uint8_t* out, uint32_t outBytes, const uint8_t* src, uint32_t srcBytes);
uint32_t bufferNewImpl(WasmScriptingVM* vm, uint32_t bufferType, uint32_t flags, uint32_t sizeInBytes);
void bufferUpdateImpl(WasmScriptingVM* vm, uint32_t buffer, const uint8_t* bytes, uint32_t byteCount);
void bufferReleaseImpl(WasmScriptingVM* vm, uint32_t buffer);
uint32_t meshInstancesNewImpl(WasmScriptingVM* vm, uint32_t count);
void meshInstancesResizeImpl(WasmScriptingVM* vm, uint32_t instances, uint32_t count);
void meshInstancesUpdateImpl(WasmScriptingVM* vm, uint32_t instances, uint32_t first, const uint8_t* bytes, uint32_t byteCount);
void meshInstancesReleaseImpl(WasmScriptingVM* vm, uint32_t instances);
uint32_t blobAssetBytesImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount);
uint32_t imageFromAssetImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t length);
uint32_t imageWidthImpl(WasmScriptingVM* vm, uint32_t image);
uint32_t imageHeightImpl(WasmScriptingVM* vm, uint32_t image);
void imageReleaseImpl(WasmScriptingVM* vm, uint32_t image);
uint32_t imageDecodeImpl(WasmScriptingVM* vm, const uint8_t* bytes, uint32_t byteCount, uint32_t token);
void imageDecodeCancelImpl(WasmScriptingVM* vm, uint32_t token);
uint32_t fontFromAssetImpl(WasmScriptingVM* vm, uint32_t object, const char* name, uint32_t length);
#ifdef WITH_RIVE_TEXT
uint32_t fontDecodeImpl(WasmScriptingVM* vm, const uint8_t* bytes, uint32_t byteCount);
#endif
void fontReleaseImpl(WasmScriptingVM* vm, uint32_t font);
void fontMetricsImpl(WasmScriptingVM* vm, uint32_t font, float* out, uint32_t outCount);
uint32_t fontWeightImpl(WasmScriptingVM* vm, uint32_t font);
uint32_t fontIsItalicImpl(WasmScriptingVM* vm, uint32_t font);
uint32_t fontAxisCountImpl(WasmScriptingVM* vm, uint32_t font);
void fontAxisImpl(WasmScriptingVM* vm, uint32_t font, uint32_t index, float* out, uint32_t outCount);
float fontAxisValueImpl(WasmScriptingVM* vm, uint32_t font, uint32_t tag);
uint32_t fontFeaturesImpl(WasmScriptingVM* vm, uint32_t font, uint32_t* out, uint32_t outCount);
uint32_t fontHasGlyphImpl(WasmScriptingVM* vm, uint32_t font, uint32_t codepoint);
uint32_t fontWithOptionsImpl(WasmScriptingVM* vm, uint32_t font, const uint32_t* coords, uint32_t coordCount, const uint32_t* features, uint32_t featureCount);
#ifdef WITH_RIVE_TEXT
uint32_t fontGlyphVerbsImpl(WasmScriptingVM* vm, uint32_t font, uint32_t glyph, uint8_t* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t fontGlyphPointsImpl(WasmScriptingVM* vm, uint32_t font, uint32_t glyph, float* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textNewImpl(WasmScriptingVM* vm);
#endif
#ifdef WITH_RIVE_TEXT
void textReleaseImpl(WasmScriptingVM* vm, uint32_t text);
#endif
#ifdef WITH_RIVE_TEXT
void textAppendImpl(WasmScriptingVM* vm, uint32_t text, const char* chars, uint32_t length, uint32_t font, uint32_t paint, float size, float lineHeight, float letterSpacing, uint32_t foreground);
#endif
#ifdef WITH_RIVE_TEXT
void textClearImpl(WasmScriptingVM* vm, uint32_t text);
#endif
#ifdef WITH_RIVE_TEXT
void textLayoutImpl(WasmScriptingVM* vm, uint32_t text, const rive_text_layout_desc_v1* desc, uint32_t descByteCount);
#endif
#ifdef WITH_RIVE_TEXT
void textDrawImpl(WasmScriptingVM* vm, uint32_t text, uint32_t renderer, uint32_t paint);
#endif
#ifdef WITH_RIVE_TEXT
void textBoundsImpl(WasmScriptingVM* vm, uint32_t text, float* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textLengthImpl(WasmScriptingVM* vm, uint32_t text);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textLinesImpl(WasmScriptingVM* vm, uint32_t text, uint32_t* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textRunsImpl(WasmScriptingVM* vm, uint32_t text, uint32_t* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textGlyphsImpl(WasmScriptingVM* vm, uint32_t text, uint32_t* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textHitTestImpl(WasmScriptingVM* vm, uint32_t text, float x, float y);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textCaretImpl(WasmScriptingVM* vm, uint32_t text, uint32_t index, float* out, uint32_t outCount);
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textSelectionRectsImpl(WasmScriptingVM* vm, uint32_t text, uint32_t from, uint32_t to, float* out, uint32_t outCount);
#endif
uint32_t shaderLinearImpl(WasmScriptingVM* vm, float sx, float sy, float ex, float ey, uint32_t colors, uint32_t stops, uint32_t count);
uint32_t shaderRadialImpl(WasmScriptingVM* vm, float cx, float cy, float radius, uint32_t colors, uint32_t stops, uint32_t count);
void shaderReleaseImpl(WasmScriptingVM* vm, uint32_t shader);
uint32_t testBlobImpl(WasmScriptingVM* vm, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount);
void transitionChildDrawImpl(WasmScriptingVM* vm, uint32_t child, uint32_t renderer);
float transitionChildWidthImpl(WasmScriptingVM* vm, uint32_t child);
float transitionChildHeightImpl(WasmScriptingVM* vm, uint32_t child);
void rendererSaveImpl(WasmScriptingVM* vm, uint32_t renderer);
void rendererRestoreImpl(WasmScriptingVM* vm, uint32_t renderer);
void rendererTransformImpl(WasmScriptingVM* vm, uint32_t renderer, float xx, float xy, float yx, float yy, float tx, float ty);
void rendererDrawPathImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t path, uint32_t paint);
void rendererClipPathImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t path);
void rendererModulateOpacityImpl(WasmScriptingVM* vm, uint32_t renderer, float opacity);
void rendererModulateColorImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t color, uint32_t replace);
void rendererDrawImageImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t blend, float opacity);
void rendererDrawImageMeshImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t blend, float opacity);
void rendererDrawImageMeshInstancedImpl(WasmScriptingVM* vm, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t instances);
uint32_t netFetchImpl(WasmScriptingVM* vm, const uint8_t* request, uint32_t requestCount, uint32_t token);
void netFetchCancelImpl(WasmScriptingVM* vm, uint32_t token);
uint32_t fileDecodeImpl(WasmScriptingVM* vm, const uint8_t* bytes, uint32_t byteCount, uint32_t* statusOut, uint32_t statusCount);
void fileReleaseImpl(WasmScriptingVM* vm, uint32_t file);
uint32_t fileArtboardCountImpl(WasmScriptingVM* vm, uint32_t file);
uint32_t fileArtboardNameImpl(WasmScriptingVM* vm, uint32_t file, uint32_t index, char* buffer, uint32_t capacity);
uint32_t fileBindableImpl(WasmScriptingVM* vm, uint32_t file, const char* name, uint32_t nameLength, uint32_t useDefault);
void fileBindableReleaseImpl(WasmScriptingVM* vm, uint32_t bindable);
uint32_t fileBindableNameImpl(WasmScriptingVM* vm, uint32_t bindable, char* buffer, uint32_t capacity);
uint32_t fileBindableDataImpl(WasmScriptingVM* vm, uint32_t bindable);
uint32_t fileBindableEqualImpl(WasmScriptingVM* vm, uint32_t a, uint32_t b);
uint32_t lanesStartImpl(WasmScriptingVM* vm, uint32_t kind, uint32_t entry, const uint8_t* input, uint32_t inputByteCount, const uint32_t* holds, uint32_t holdCount);
uint32_t lanesStateImpl(WasmScriptingVM* vm, uint32_t lane);
uint32_t lanesFailedImpl(WasmScriptingVM* vm, uint32_t lane, char* buffer, uint32_t capacity);
void lanesStopImpl(WasmScriptingVM* vm, uint32_t lane);
void lanesReleaseImpl(WasmScriptingVM* vm, uint32_t lane);
uint32_t lanesResultImpl(WasmScriptingVM* vm, uint32_t lane, uint32_t out, uint32_t outCount);
uint32_t lanesWatchImpl(WasmScriptingVM* vm, uint32_t lane);
uint32_t lanesWaitImpl(WasmScriptingVM* vm, uint32_t signal, double after, double timeoutSeconds);
void lanesCancelWaitImpl(WasmScriptingVM* vm, uint32_t token);
double lanesWaitWithinImpl(WasmScriptingVM* vm, uint32_t signal, double after, double timeoutSeconds);
uint32_t jobsThreadsImpl(WasmScriptingVM* vm);
uint32_t jobsJoinImpl(WasmScriptingVM* vm, uint32_t job, double timeoutSeconds);
uint32_t jobsJoinAnyImpl(WasmScriptingVM* vm, const uint32_t* jobs, uint32_t count, double timeoutSeconds);
uint32_t parallelSizeImpl(WasmScriptingVM* vm);
#ifdef RIVE_WASM_PARALLEL
uint32_t parallelRunImpl(WasmScriptingVM* vm, uint32_t control);
#endif
void parallelWaitingImpl(WasmScriptingVM* vm, uint32_t control);
uint32_t sharedRegionCreateImpl(WasmScriptingVM* vm, uint32_t size);
uint32_t sharedRegionSizeImpl(WasmScriptingVM* vm, uint32_t region);
uint32_t sharedRegionLockImpl(WasmScriptingVM* vm, uint32_t region, double timeoutSeconds);
void sharedRegionUnlockImpl(WasmScriptingVM* vm, uint32_t region);
uint32_t sharedRegionReadImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset, uint8_t* out, uint32_t outByteCount);
uint32_t sharedRegionWriteImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset, const uint8_t* data, uint32_t dataByteCount);
uint32_t sharedRegionPoisonedImpl(WasmScriptingVM* vm, uint32_t region);
double sharedAtomicLoadImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset);
double sharedAtomicStoreImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset, uint32_t value);
double sharedAtomicAddImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset, uint32_t value);
double sharedAtomicCasImpl(WasmScriptingVM* vm, uint32_t region, uint32_t offset, uint32_t expected, uint32_t desired);
uint32_t sharedRingCreateImpl(WasmScriptingVM* vm, uint32_t capacity);
uint32_t sharedRingWriteImpl(WasmScriptingVM* vm, uint32_t ring, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount);
uint32_t sharedRingReadImpl(WasmScriptingVM* vm, uint32_t ring, uint8_t* out, uint32_t outByteCount);
uint32_t sharedRingDropImpl(WasmScriptingVM* vm, uint32_t ring, uint32_t capacity);
uint32_t sharedRingUsedImpl(WasmScriptingVM* vm, uint32_t ring);
uint32_t sharedRingSignalImpl(WasmScriptingVM* vm, uint32_t ring, uint32_t space);
uint32_t sharedSnapshotCreateImpl(WasmScriptingVM* vm, uint32_t capacity);
uint32_t sharedSnapshotPublishImpl(WasmScriptingVM* vm, uint32_t snapshot, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount);
uint32_t sharedSnapshotReadImpl(WasmScriptingVM* vm, uint32_t snapshot, uint8_t* out, uint32_t outByteCount);
double sharedSnapshotSeqImpl(WasmScriptingVM* vm, uint32_t snapshot);
void sharedReadDoneImpl(WasmScriptingVM* vm);
uint32_t sharedSignalCreateImpl(WasmScriptingVM* vm);
void sharedSignalNotifyImpl(WasmScriptingVM* vm, uint32_t signal);
double sharedSignalSeqImpl(WasmScriptingVM* vm, uint32_t signal);
uint32_t sharedBlobCreateImpl(WasmScriptingVM* vm, const uint8_t* data, uint32_t dataByteCount);
uint32_t sharedBlobSizeImpl(WasmScriptingVM* vm, uint32_t blob);
uint32_t sharedBlobReadImpl(WasmScriptingVM* vm, uint32_t blob, uint32_t offset, uint8_t* out, uint32_t outByteCount);
uint32_t sharedRetainImpl(WasmScriptingVM* vm, uint32_t object);
void sharedReleaseImpl(WasmScriptingVM* vm, uint32_t object);

#ifndef __EMSCRIPTEN__
// What rt.features answers.
constexpr uint32_t kHostFeatures = 0x1u;

void rtLog(wasm_exec_env_t env, int32_t level, const char* message, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg messageUtf8(vm, message, length);
    rtLogImpl(vm, level, messageUtf8.data(), messageUtf8.size());
}
void rtMarkNeedsUpdate(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rtMarkNeedsUpdateImpl(vm, object);
}
void rtBudgetExceeded(wasm_exec_env_t env, uint32_t ms)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (vm == nullptr)
    {
        vmlessTrap(env, "execution exceeded timeout");
        return;
    }
    rtBudgetExceededImpl(vm, ms);
}
void rtError(wasm_exec_env_t env, const char* message, uint32_t length)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (vm == nullptr)
    {
        vmlessTrap(env, "script threw", message, length);
        return;
    }
    WasmStringArg messageUtf8(vm, message, length);
    rtErrorImpl(vm, messageUtf8.data(), messageUtf8.size());
}
double rtNow(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return rtNowImpl(vm);
}
double rtDateNow(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return rtDateNowImpl(vm);
}
uint32_t rtFeatures(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return rtFeaturesImpl(vm);
}
void rtDebugEnter(wasm_exec_env_t env, uint32_t func, uint32_t line)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rtDebugEnterImpl(vm, func, line);
}
uint32_t rtDebugLine(wasm_exec_env_t env, uint32_t line)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return rtDebugLineImpl(vm, line);
}
void rtDebugLeave(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rtDebugLeaveImpl(vm);
}
uint32_t rtUtcOffset(wasm_exec_env_t env, double epochSeconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return rtUtcOffsetImpl(vm, epochSeconds);
}
uint32_t rtIsDst(wasm_exec_env_t env, double epochSeconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return rtIsDstImpl(vm, epochSeconds);
}
uint32_t rtZoneName(wasm_exec_env_t env, double epochSeconds, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return rtZoneNameImpl(vm, epochSeconds, buffer, capacity);
}
uint32_t dataViewModel(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataViewModelImpl(vm, object);
}
uint32_t dataRootViewModel(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataRootViewModelImpl(vm, object);
}
uint32_t dataGlobalViewModel(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataGlobalViewModelImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataGlobalViewModelNames(wasm_exec_env_t env, uint32_t object, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataGlobalViewModelNamesImpl(vm, object, buffer, capacity);
}
uint32_t dataContext(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataContextImpl(vm, object);
}
uint32_t dataContextParent(wasm_exec_env_t env, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataContextParentImpl(vm, dataContext);
}
uint32_t dataContextViewModel(wasm_exec_env_t env, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataContextViewModelImpl(vm, dataContext);
}
void dataContextRelease(wasm_exec_env_t env, uint32_t dataContext)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataContextReleaseImpl(vm, dataContext);
}
uint32_t dataHasViewModel(wasm_exec_env_t env, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataHasViewModelImpl(vm, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataNewViewModel(wasm_exec_env_t env, const char* name, uint32_t nameLength, const char* templateName, uint32_t templateLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    WasmStringArg templateNameUtf8(vm, templateName, templateLength);
    return dataNewViewModelImpl(vm, nameUtf8.data(), nameUtf8.size(), templateNameUtf8.data(), templateNameUtf8.size());
}
void dataVmiRelease(wasm_exec_env_t env, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataVmiReleaseImpl(vm, vmi);
}
uint32_t dataVmiNumber(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiNumberImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiBoolean(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiBooleanImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiString(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiStringImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiTrigger(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiTriggerImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiColor(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiColorImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiViewModel(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiViewModelImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiProperty(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length, uint32_t* kindOut, uint32_t kindCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (kindCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)kindOut, (uint64_t)kindCount * 4))
    {
        return {};
    }
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiPropertyImpl(vm, vmi, nameUtf8.data(), nameUtf8.size(), kindOut, kindCount);
}
uint32_t dataVmiInstance(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return dataVmiInstanceImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiSymbolIndex(wasm_exec_env_t env, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataVmiSymbolIndexImpl(vm, vmi);
}
uint32_t dataVmiEqual(wasm_exec_env_t env, uint32_t a, uint32_t b)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataVmiEqualImpl(vm, a, b);
}
uint32_t dataViewModelGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataViewModelGetImpl(vm, property);
}
uint32_t dataVmiList(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiListImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiEnum(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiEnumImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiImage(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiImageImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiFont(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiFontImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiBlob(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiBlobImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataVmiArtboard(wasm_exec_env_t env, uint32_t vmi, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return dataVmiArtboardImpl(vm, vmi, nameUtf8.data(), nameUtf8.size());
}
uint32_t dataImageGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataImageGetImpl(vm, property);
}
void dataImageSet(wasm_exec_env_t env, uint32_t property, uint32_t image)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataImageSetImpl(vm, property, image);
}
uint32_t dataFontGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataFontGetImpl(vm, property);
}
void dataFontSet(wasm_exec_env_t env, uint32_t property, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataFontSetImpl(vm, property, font);
}
void dataFontRelease(wasm_exec_env_t env, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataFontReleaseImpl(vm, font);
}
uint32_t dataBlobPresent(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataBlobPresentImpl(vm, property);
}
uint32_t dataBlobGet(wasm_exec_env_t env, uint32_t property, uint8_t* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataBlobGetImpl(vm, property, buffer, capacity);
}
uint32_t dataBlobName(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataBlobNameImpl(vm, property, buffer, capacity);
}
void dataBlobSet(wasm_exec_env_t env, uint32_t property, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataBlobSetImpl(vm, property, bytes, byteCount);
}
void dataBlobClear(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataBlobClearImpl(vm, property);
}
uint32_t dataArtboardGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataArtboardGetImpl(vm, property);
}
void dataArtboardSet(wasm_exec_env_t env, uint32_t property, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataArtboardSetImpl(vm, property, bindable);
}
uint32_t dataEnumGet(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataEnumGetImpl(vm, property, buffer, capacity);
}
void dataEnumSet(wasm_exec_env_t env, uint32_t property, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg valueUtf8(vm, value, length);
    dataEnumSetImpl(vm, property, valueUtf8.data(), valueUtf8.size());
}
uint32_t dataEnumValues(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataEnumValuesImpl(vm, property, buffer, capacity);
}
void dataPropRelease(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataPropReleaseImpl(vm, property);
}
void dataTriggerFire(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataTriggerFireImpl(vm, property);
}
uint32_t dataListLength(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataListLengthImpl(vm, property);
}
void dataListPush(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListPushImpl(vm, property, vmi);
}
uint32_t dataListPop(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataListPopImpl(vm, property);
}
uint32_t dataListShift(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataListShiftImpl(vm, property);
}
void dataListClear(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListClearImpl(vm, property);
}
void dataListSwap(wasm_exec_env_t env, uint32_t property, uint32_t index1, uint32_t index2)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListSwapImpl(vm, property, index1, index2);
}
void dataListInsert(wasm_exec_env_t env, uint32_t property, uint32_t vmi, uint32_t index)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListInsertImpl(vm, property, vmi, index);
}
void dataListRemove(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListRemoveImpl(vm, property, vmi);
}
void dataListRemoveAt(wasm_exec_env_t env, uint32_t property, uint32_t index)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListRemoveAtImpl(vm, property, index);
}
void dataListRemoveAllOf(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataListRemoveAllOfImpl(vm, property, vmi);
}
uint32_t dataListGet(wasm_exec_env_t env, uint32_t property, uint32_t index)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataListGetImpl(vm, property, index);
}
void dataViewModelSet(wasm_exec_env_t env, uint32_t property, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataViewModelSetImpl(vm, property, vmi);
}
uint32_t dataColorGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataColorGetImpl(vm, property);
}
void dataColorSet(wasm_exec_env_t env, uint32_t property, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataColorSetImpl(vm, property, value);
}
float dataNumberGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataNumberGetImpl(vm, property);
}
void dataNumberSet(wasm_exec_env_t env, uint32_t property, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataNumberSetImpl(vm, property, value);
}
uint32_t dataBooleanGet(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataBooleanGetImpl(vm, property);
}
void dataBooleanSet(wasm_exec_env_t env, uint32_t property, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataBooleanSetImpl(vm, property, value);
}
uint32_t dataStringGet(wasm_exec_env_t env, uint32_t property, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataStringGetImpl(vm, property, buffer, capacity);
}
uint32_t dataStringChanged(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return dataStringChangedImpl(vm, property);
}
void dataStringSet(wasm_exec_env_t env, uint32_t property, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg valueUtf8(vm, value, length);
    dataStringSetImpl(vm, property, valueUtf8.data(), valueUtf8.size());
}
void dataWatch(wasm_exec_env_t env, uint32_t property, uint32_t token)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataWatchImpl(vm, property, token);
}
void dataUnwatch(wasm_exec_env_t env, uint32_t property)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    dataUnwatchImpl(vm, property);
}
void dataConvertResult(wasm_exec_env_t env, uint32_t kind, float number, uint32_t booleanValue, uint32_t color, const char* value, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg valueUtf8(vm, value, length);
    dataConvertResultImpl(vm, kind, number, booleanValue, color, valueUtf8.data(), valueUtf8.size());
}
void artboardRelease(wasm_exec_env_t env, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardReleaseImpl(vm, artboard);
}
uint32_t artboardAdvance(wasm_exec_env_t env, uint32_t artboard, float seconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardAdvanceImpl(vm, artboard, seconds);
}
void artboardDraw(wasm_exec_env_t env, uint32_t artboard, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardDrawImpl(vm, artboard, renderer);
}
uint32_t artboardInstance(wasm_exec_env_t env, uint32_t artboard, uint32_t vmi)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardInstanceImpl(vm, artboard, vmi);
}
uint32_t artboardData(wasm_exec_env_t env, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardDataImpl(vm, artboard);
}
float artboardWidth(wasm_exec_env_t env, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardWidthImpl(vm, artboard);
}
float artboardHeight(wasm_exec_env_t env, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardHeightImpl(vm, artboard);
}
void artboardSetWidth(wasm_exec_env_t env, uint32_t artboard, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardSetWidthImpl(vm, artboard, value);
}
void artboardSetHeight(wasm_exec_env_t env, uint32_t artboard, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardSetHeightImpl(vm, artboard, value);
}
uint32_t artboardFrameOrigin(wasm_exec_env_t env, uint32_t artboard)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardFrameOriginImpl(vm, artboard);
}
void artboardSetFrameOrigin(wasm_exec_env_t env, uint32_t artboard, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardSetFrameOriginImpl(vm, artboard, value);
}
void artboardBounds(wasm_exec_env_t env, uint32_t artboard, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    artboardBoundsImpl(vm, artboard, out, outCount);
}
uint32_t artboardPointerEvent(wasm_exec_env_t env, uint32_t artboard, uint32_t kind, uint32_t pointerId, float x, float y)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardPointerEventImpl(vm, artboard, kind, pointerId, x, y);
}
uint32_t artboardScrollEvent(wasm_exec_env_t env, uint32_t artboard, uint32_t pointerId, float x, float y, float dx, float dy, uint32_t phase, uint32_t precise, float timeStamp)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardScrollEventImpl(vm, artboard, pointerId, x, y, dx, dy, phase, precise, timeStamp);
}
uint32_t artboardGamepadEvent(wasm_exec_env_t env, uint32_t artboard, const uint8_t* payload, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardGamepadEventImpl(vm, artboard, payload, byteCount);
}
uint32_t artboardAnimation(wasm_exec_env_t env, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardAnimationImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void artboardAnimationRelease(wasm_exec_env_t env, uint32_t animation)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardAnimationReleaseImpl(vm, animation);
}
float artboardAnimationDuration(wasm_exec_env_t env, uint32_t animation)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardAnimationDurationImpl(vm, animation);
}
uint32_t artboardAnimationAdvance(wasm_exec_env_t env, uint32_t animation, float seconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardAnimationAdvanceImpl(vm, animation, seconds);
}
void artboardAnimationSetTime(wasm_exec_env_t env, uint32_t animation, float value, uint32_t mode)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardAnimationSetTimeImpl(vm, animation, value, mode);
}
void artboardAddToPath(wasm_exec_env_t env, uint32_t artboard, uint32_t path, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardAddToPathImpl(vm, artboard, path, xx, xy, yx, yy, tx, ty);
}
uint32_t artboardNode(wasm_exec_env_t env, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardNodeImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void artboardNodeRelease(wasm_exec_env_t env, uint32_t node)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardNodeReleaseImpl(vm, node);
}
void artboardNodeTransform(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    artboardNodeTransformImpl(vm, node, out, outCount);
}
void artboardNodeSet(wasm_exec_env_t env, uint32_t node, uint32_t field, float v0, float v1)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardNodeSetImpl(vm, node, field, v0, v1);
}
void artboardNodeWorldTransform(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    artboardNodeWorldTransformImpl(vm, node, out, outCount);
}
void artboardNodeSetWorldTransform(wasm_exec_env_t env, uint32_t node, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)values, (uint64_t)floatCount * 4))
    {
        return;
    }
    artboardNodeSetWorldTransformImpl(vm, node, values, floatCount);
}
void artboardNodeDecompose(wasm_exec_env_t env, uint32_t node, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)values, (uint64_t)floatCount * 4))
    {
        return;
    }
    artboardNodeDecomposeImpl(vm, node, values, floatCount);
}
uint32_t artboardNodePathVerbs(wasm_exec_env_t env, uint32_t node, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardNodePathVerbsImpl(vm, node, out, outCount);
}
uint32_t artboardNodePathPoints(wasm_exec_env_t env, uint32_t node, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return artboardNodePathPointsImpl(vm, node, out, outCount);
}
uint32_t artboardNodePaint(wasm_exec_env_t env, uint32_t node, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return artboardNodePaintImpl(vm, node, out, outCount);
}
uint32_t artboardNodeChildren(wasm_exec_env_t env, uint32_t node, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return artboardNodeChildrenImpl(vm, node, out, outCount);
}
uint32_t artboardNodeParent(wasm_exec_env_t env, uint32_t node)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardNodeParentImpl(vm, node);
}
uint32_t artboardPropertyKey(wasm_exec_env_t env, uint32_t artboard, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return artboardPropertyKeyImpl(vm, artboard, nameUtf8.data(), nameUtf8.size());
}
void artboardDrawVisit(wasm_exec_env_t env, uint32_t artboard, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardDrawVisitImpl(vm, artboard, renderer);
}
void artboardDrawModulated(wasm_exec_env_t env, uint32_t artboard, uint32_t renderer, uint32_t key)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardDrawModulatedImpl(vm, artboard, renderer, key);
}
void artboardDrawableDraw(wasm_exec_env_t env, uint32_t drawable, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    artboardDrawableDrawImpl(vm, drawable, renderer);
}
uint32_t artboardDrawableValue(wasm_exec_env_t env, uint32_t drawable, uint32_t key, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return artboardDrawableValueImpl(vm, drawable, key, out, outCount);
}
uint32_t artboardDrawableString(wasm_exec_env_t env, uint32_t drawable, uint32_t key, char* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardDrawableStringImpl(vm, drawable, key, out, outCount);
}
#ifdef WITH_RIVE_TOOLS
uint32_t artboardDrawableProperties(wasm_exec_env_t env, uint32_t drawable, char* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return artboardDrawablePropertiesImpl(vm, drawable, out, outCount);
}
#endif
uint32_t audioSource(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return audioSourceImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
void audioSourceRelease(wasm_exec_env_t env, uint32_t source)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSourceReleaseImpl(vm, source);
}
float audioSourceDuration(wasm_exec_env_t env, uint32_t source)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSourceDurationImpl(vm, source);
}
uint32_t audioSourceSampleRate(wasm_exec_env_t env, uint32_t source)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSourceSampleRateImpl(vm, source);
}
uint32_t audioSourceChannels(wasm_exec_env_t env, uint32_t source)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSourceChannelsImpl(vm, source);
}
uint32_t audioSourceToBlob(wasm_exec_env_t env, uint32_t source, uint32_t sampleRate, uint32_t channels)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSourceToBlobImpl(vm, source, sampleRate, channels);
}
uint32_t audioStream(wasm_exec_env_t env, uint32_t source, uint32_t sampleRate, uint32_t channels, uint32_t chunkFrames, uint32_t bufferFrames)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamImpl(vm, source, sampleRate, channels, chunkFrames, bufferFrames);
}
uint32_t audioStreamRing(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamRingImpl(vm, stream);
}
uint32_t audioStreamSeeks(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamSeeksImpl(vm, stream);
}
uint32_t audioStreamChannels(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamChannelsImpl(vm, stream);
}
uint32_t audioStreamSampleRate(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamSampleRateImpl(vm, stream);
}
uint32_t audioStreamSeekFrame(wasm_exec_env_t env, uint32_t stream, double frame)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamSeekFrameImpl(vm, stream, frame);
}
void audioStreamSetLoop(wasm_exec_env_t env, uint32_t stream, uint32_t loop)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioStreamSetLoopImpl(vm, stream, loop);
}
uint32_t audioStreamEnded(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioStreamEndedImpl(vm, stream);
}
void audioStreamRelease(wasm_exec_env_t env, uint32_t stream)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioStreamReleaseImpl(vm, stream);
}
uint32_t audioPlay(wasm_exec_env_t env, uint32_t source)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioPlayImpl(vm, source);
}
uint32_t audioPlayAtTime(wasm_exec_env_t env, uint32_t source, float seconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioPlayAtTimeImpl(vm, source, seconds);
}
uint32_t audioPlayInTime(wasm_exec_env_t env, uint32_t source, float seconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioPlayInTimeImpl(vm, source, seconds);
}
uint32_t audioPlayAtFrame(wasm_exec_env_t env, uint32_t source, double frame)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioPlayAtFrameImpl(vm, source, frame);
}
uint32_t audioPlayInFrame(wasm_exec_env_t env, uint32_t source, double frame)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioPlayInFrameImpl(vm, source, frame);
}
float audioTime(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioTimeImpl(vm);
}
double audioTimeFrame(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioTimeFrameImpl(vm);
}
uint32_t audioSampleRate(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSampleRateImpl(vm);
}
uint32_t audioProcessorSampleRate(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioProcessorSampleRateImpl(vm);
}
uint32_t audioProcessorChannels(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioProcessorChannelsImpl(vm);
}
void audioSoundRelease(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundReleaseImpl(vm, sound);
}
void audioSoundPlay(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundPlayImpl(vm, sound);
}
void audioSoundPause(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundPauseImpl(vm, sound);
}
void audioSoundResume(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundResumeImpl(vm, sound);
}
void audioSoundStop(wasm_exec_env_t env, uint32_t sound, uint32_t fadeFrames)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundStopImpl(vm, sound, fadeFrames);
}
uint32_t audioSoundSeek(wasm_exec_env_t env, uint32_t sound, float seconds)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundSeekImpl(vm, sound, seconds);
}
uint32_t audioSoundSeekFrame(wasm_exec_env_t env, uint32_t sound, double frame)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundSeekFrameImpl(vm, sound, frame);
}
uint32_t audioSoundCompleted(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundCompletedImpl(vm, sound);
}
float audioSoundTime(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundTimeImpl(vm, sound);
}
double audioSoundTimeFrame(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundTimeFrameImpl(vm, sound);
}
float audioSoundVolume(wasm_exec_env_t env, uint32_t sound)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return audioSoundVolumeImpl(vm, sound);
}
void audioSoundSetVolume(wasm_exec_env_t env, uint32_t sound, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    audioSoundSetVolumeImpl(vm, sound, value);
}
uint32_t pathNew(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return pathNewImpl(vm);
}
void pathUpdate(wasm_exec_env_t env, uint32_t path, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount, uint32_t fillRule)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)points, (uint64_t)floatCount * 4))
    {
        return;
    }
    pathUpdateImpl(vm, path, verbs, verbCount, points, floatCount, fillRule);
}
void pathRelease(wasm_exec_env_t env, uint32_t path)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    pathReleaseImpl(vm, path);
}
void pathAdd(wasm_exec_env_t env, uint32_t path, uint32_t other, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    pathAddImpl(vm, path, other, xx, xy, yx, yy, tx, ty);
}
uint32_t pathVerbs(wasm_exec_env_t env, uint32_t path, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return pathVerbsImpl(vm, path, out, outCount);
}
uint32_t pathPoints(wasm_exec_env_t env, uint32_t path, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return pathPointsImpl(vm, path, out, outCount);
}
void pathEffectResult(wasm_exec_env_t env, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)points, (uint64_t)floatCount * 4))
    {
        return;
    }
    pathEffectResultImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t measurePathNew(wasm_exec_env_t env, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)points, (uint64_t)floatCount * 4))
    {
        return {};
    }
    return measurePathNewImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t measureContoursNew(wasm_exec_env_t env, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)points, (uint64_t)floatCount * 4))
    {
        return {};
    }
    return measureContoursNewImpl(vm, verbs, verbCount, points, floatCount);
}
uint32_t measureContourNext(wasm_exec_env_t env, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return measureContourNextImpl(vm, measure);
}
float measureLength(wasm_exec_env_t env, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return measureLengthImpl(vm, measure);
}
uint32_t measureIsClosed(wasm_exec_env_t env, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return measureIsClosedImpl(vm, measure);
}
void measurePosTan(wasm_exec_env_t env, uint32_t measure, float distance, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    measurePosTanImpl(vm, measure, distance, out, outCount);
}
void measureWarp(wasm_exec_env_t env, uint32_t measure, float x, float y, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    measureWarpImpl(vm, measure, x, y, out, outCount);
}
uint32_t measureExtract(wasm_exec_env_t env, uint32_t measure, float startDistance, float endDistance, uint32_t startWithMove)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return measureExtractImpl(vm, measure, startDistance, endDistance, startWithMove);
}
uint32_t measureExtractRead(wasm_exec_env_t env, uint32_t measure, uint8_t* verbs, uint32_t verbCount, float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)points, (uint64_t)floatCount * 4))
    {
        return {};
    }
    return measureExtractReadImpl(vm, measure, verbs, verbCount, points, floatCount);
}
void measureRelease(wasm_exec_env_t env, uint32_t measure)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    measureReleaseImpl(vm, measure);
}
uint32_t paintNew(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return paintNewImpl(vm);
}
void paintRelease(wasm_exec_env_t env, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintReleaseImpl(vm, paint);
}
void paintStyle(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintStyleImpl(vm, paint, value);
}
void paintColor(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintColorImpl(vm, paint, value);
}
void paintThickness(wasm_exec_env_t env, uint32_t paint, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintThicknessImpl(vm, paint, value);
}
void paintJoin(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintJoinImpl(vm, paint, value);
}
void paintCap(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintCapImpl(vm, paint, value);
}
void paintBlendMode(wasm_exec_env_t env, uint32_t paint, uint32_t value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintBlendModeImpl(vm, paint, value);
}
void paintFeather(wasm_exec_env_t env, uint32_t paint, float value)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintFeatherImpl(vm, paint, value);
}
void paintShader(wasm_exec_env_t env, uint32_t paint, uint32_t shader)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    paintShaderImpl(vm, paint, shader);
}
void paintShaderTransform(wasm_exec_env_t env, uint32_t paint, const float* values, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (floatCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)values, (uint64_t)floatCount * 4))
    {
        return;
    }
    paintShaderTransformImpl(vm, paint, values, floatCount);
}
uint32_t canvasNew(wasm_exec_env_t env, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasNewImpl(vm, width, height);
}
void canvasRelease(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    canvasReleaseImpl(vm, canvas);
}
uint32_t canvasWidth(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasWidthImpl(vm, canvas);
}
uint32_t canvasHeight(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasHeightImpl(vm, canvas);
}
uint32_t canvasResize(wasm_exec_env_t env, uint32_t canvas, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasResizeImpl(vm, canvas, width, height);
}
uint32_t canvasImage(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasImageImpl(vm, canvas);
}
uint32_t canvasBeginFrame(wasm_exec_env_t env, uint32_t canvas, uint32_t clearColor)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return canvasBeginFrameImpl(vm, canvas, clearColor);
}
void canvasEndFrame(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    canvasEndFrameImpl(vm, canvas);
}
uint32_t gpuFeatures(wasm_exec_env_t env, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return gpuFeaturesImpl(vm, out, outCount);
}
uint32_t gpuCanvasNew(wasm_exec_env_t env, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuCanvasNewImpl(vm, width, height);
}
void gpuCanvasRelease(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuCanvasReleaseImpl(vm, canvas);
}
uint32_t gpuCanvasColorView(wasm_exec_env_t env, uint32_t canvas, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (propCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)props, (uint64_t)propCount * 4))
    {
        return {};
    }
    return gpuCanvasColorViewImpl(vm, canvas, props, propCount);
}
uint32_t gpuCanvasImage(wasm_exec_env_t env, uint32_t canvas)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuCanvasImageImpl(vm, canvas);
}
uint32_t gpuCanvasResize(wasm_exec_env_t env, uint32_t canvas, uint32_t width, uint32_t height, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (propCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)props, (uint64_t)propCount * 4))
    {
        return {};
    }
    return gpuCanvasResizeImpl(vm, canvas, width, height, props, propCount);
}
uint32_t gpuTargetView(wasm_exec_env_t env, uint32_t current, uint32_t* props, uint32_t propCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (propCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)props, (uint64_t)propCount * 4))
    {
        return {};
    }
    return gpuTargetViewImpl(vm, current, props, propCount);
}
uint32_t gpuPassBegin(wasm_exec_env_t env, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuPassBeginImpl(vm, desc, descByteCount, blob, blobCount);
}
void gpuPassSetPipeline(wasm_exec_env_t env, uint32_t pass, uint32_t pipeline)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetPipelineImpl(vm, pass, pipeline);
}
void gpuPassSetVertexBuffer(wasm_exec_env_t env, uint32_t pass, uint32_t slot, uint32_t buffer, uint32_t offset)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetVertexBufferImpl(vm, pass, slot, buffer, offset);
}
void gpuPassSetIndexBuffer(wasm_exec_env_t env, uint32_t pass, uint32_t buffer, uint32_t indexFormat, uint32_t offset)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetIndexBufferImpl(vm, pass, buffer, indexFormat, offset);
}
void gpuPassSetBindGroup(wasm_exec_env_t env, uint32_t pass, uint32_t groupIndex, uint32_t bindGroup, const uint32_t* dynamicOffsets, uint32_t dynamicOffsetByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetBindGroupImpl(vm, pass, groupIndex, bindGroup, dynamicOffsets, dynamicOffsetByteCount);
}
void gpuPassSetViewport(wasm_exec_env_t env, uint32_t pass, float x, float y, float width, float height, float minDepth, float maxDepth)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetViewportImpl(vm, pass, x, y, width, height, minDepth, maxDepth);
}
void gpuPassSetScissor(wasm_exec_env_t env, uint32_t pass, uint32_t x, uint32_t y, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetScissorImpl(vm, pass, x, y, width, height);
}
void gpuPassSetStencilReference(wasm_exec_env_t env, uint32_t pass, uint32_t ref)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetStencilReferenceImpl(vm, pass, ref);
}
void gpuPassSetBlendColor(wasm_exec_env_t env, uint32_t pass, float r, float g, float b, float a)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassSetBlendColorImpl(vm, pass, r, g, b, a);
}
void gpuPassDraw(wasm_exec_env_t env, uint32_t pass, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassDrawImpl(vm, pass, vertexCount, instanceCount, firstVertex, firstInstance);
}
void gpuPassDrawIndexed(wasm_exec_env_t env, uint32_t pass, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassDrawIndexedImpl(vm, pass, indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
}
void gpuPassFinish(wasm_exec_env_t env, uint32_t pass)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassFinishImpl(vm, pass);
}
void gpuPassRelease(wasm_exec_env_t env, uint32_t pass)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPassReleaseImpl(vm, pass);
}
uint32_t gpuImageView(wasm_exec_env_t env, uint32_t image, uint32_t width, uint32_t height)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuImageViewImpl(vm, image, width, height);
}
uint32_t gpuBufferNew(wasm_exec_env_t env, uint32_t usage, uint32_t sizeInBytes, uint32_t immutable, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuBufferNewImpl(vm, usage, sizeInBytes, immutable, data, dataCount);
}
void gpuBufferUpdate(wasm_exec_env_t env, uint32_t buffer, uint32_t dstOffset, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuBufferUpdateImpl(vm, buffer, dstOffset, data, dataCount);
}
void gpuBufferUpdateBlob(wasm_exec_env_t env, uint32_t buffer, uint32_t dstOffset, uint32_t blob, uint32_t srcOffset, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuBufferUpdateBlobImpl(vm, buffer, dstOffset, blob, srcOffset, byteCount);
}
uint32_t gpuBufferNewBlob(wasm_exec_env_t env, uint32_t usage, uint32_t immutable, uint32_t blob, uint32_t srcOffset, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuBufferNewBlobImpl(vm, usage, immutable, blob, srcOffset, byteCount);
}
void gpuBufferRelease(wasm_exec_env_t env, uint32_t buffer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuBufferReleaseImpl(vm, buffer);
}
uint32_t gpuTextureNew(wasm_exec_env_t env, const rive_gpu_texture_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuTextureNewImpl(vm, desc, descByteCount);
}
void gpuTextureUpload(wasm_exec_env_t env, uint32_t texture, const rive_gpu_texture_upload_v1* region, uint32_t regionByteCount, const uint8_t* data, uint32_t dataCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuTextureUploadImpl(vm, texture, region, regionByteCount, data, dataCount);
}
void gpuTextureRelease(wasm_exec_env_t env, uint32_t texture)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuTextureReleaseImpl(vm, texture);
}
uint32_t gpuSamplerNew(wasm_exec_env_t env, const rive_gpu_sampler_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuSamplerNewImpl(vm, desc, descByteCount);
}
void gpuSamplerRelease(wasm_exec_env_t env, uint32_t sampler)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuSamplerReleaseImpl(vm, sampler);
}
uint32_t gpuTextureViewNew(wasm_exec_env_t env, uint32_t texture, const rive_gpu_texture_view_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuTextureViewNewImpl(vm, texture, desc, descByteCount);
}
void gpuTextureViewRelease(wasm_exec_env_t env, uint32_t view)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuTextureViewReleaseImpl(vm, view);
}
uint32_t gpuShaderTarget(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuShaderTargetImpl(vm);
}
uint32_t gpuShaderAssetBytes(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderAssetBytesImpl(vm, object, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
uint32_t gpuShaderAssetId(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderAssetIdImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t gpuShaderModuleFromAsset(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength, uint32_t entry)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return gpuShaderModuleFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size(), entry);
}
#ifdef WITH_RIVE_TOOLS
uint32_t gpuShaderModuleFromRstb(wasm_exec_env_t env, const uint8_t* rstb, uint32_t rstbCount, uint32_t assetId, uint32_t entry)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuShaderModuleFromRstbImpl(vm, rstb, rstbCount, assetId, entry);
}
#endif
void gpuShaderModuleRelease(wasm_exec_env_t env, uint32_t shaderModule)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuShaderModuleReleaseImpl(vm, shaderModule);
}
uint32_t gpuBindGroupLayoutNew(wasm_exec_env_t env, uint32_t groupIndex, const rive_gpu_bind_group_layout_entry_v1* entries, uint32_t entryByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuBindGroupLayoutNewImpl(vm, groupIndex, entries, entryByteCount);
}
void gpuBindGroupLayoutRelease(wasm_exec_env_t env, uint32_t layout)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuBindGroupLayoutReleaseImpl(vm, layout);
}
uint32_t gpuBindGroupLayoutFromShader(wasm_exec_env_t env, uint32_t shaderModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (dynamicUBOCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)dynamicUBOs, (uint64_t)dynamicUBOCount * 4))
    {
        return {};
    }
    return gpuBindGroupLayoutFromShaderImpl(vm, shaderModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
uint32_t gpuBindGroupLayoutFromShaders(wasm_exec_env_t env, uint32_t vertexModule, uint32_t fragmentModule, uint32_t groupIndex, const uint32_t* dynamicUBOs, uint32_t dynamicUBOCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (dynamicUBOCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)dynamicUBOs, (uint64_t)dynamicUBOCount * 4))
    {
        return {};
    }
    return gpuBindGroupLayoutFromShadersImpl(vm, vertexModule, fragmentModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
uint32_t gpuBindGroupLayoutFromEntries(wasm_exec_env_t env, uint32_t vertexModule, const char* vertexEntry, uint32_t vertexEntryLength, uint32_t fragmentModule, const char* fragmentEntry, uint32_t fragmentEntryLength, uint32_t groupIndex)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    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 gpuBindGroupNew(wasm_exec_env_t env, 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 = vmFromEnv(env);
    return gpuBindGroupNewImpl(vm, layout, ubos, uboByteCount, textures, textureByteCount, samplers, samplerByteCount);
}
void gpuBindGroupRelease(wasm_exec_env_t env, uint32_t bindGroup)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuBindGroupReleaseImpl(vm, bindGroup);
}
uint32_t gpuPipelineNew(wasm_exec_env_t env, const rive_gpu_pipeline_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuPipelineNewImpl(vm, desc, descByteCount, blob, blobCount);
}
void gpuPipelineRelease(wasm_exec_env_t env, uint32_t pipeline)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    gpuPipelineReleaseImpl(vm, pipeline);
}
void mat4Multiply(wasm_exec_env_t env, uint8_t* out, uint32_t outBytes, const uint8_t* a, uint32_t aBytes, const uint8_t* b, uint32_t bBytes)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    mat4MultiplyImpl(vm, out, outBytes, a, aBytes, b, bBytes);
}
uint32_t mat4Invert(wasm_exec_env_t env, uint8_t* out, uint32_t outBytes, const uint8_t* src, uint32_t srcBytes)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return mat4InvertImpl(vm, out, outBytes, src, srcBytes);
}
uint32_t bufferNew(wasm_exec_env_t env, uint32_t bufferType, uint32_t flags, uint32_t sizeInBytes)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return bufferNewImpl(vm, bufferType, flags, sizeInBytes);
}
void bufferUpdate(wasm_exec_env_t env, uint32_t buffer, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    bufferUpdateImpl(vm, buffer, bytes, byteCount);
}
void bufferRelease(wasm_exec_env_t env, uint32_t buffer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    bufferReleaseImpl(vm, buffer);
}
uint32_t meshInstancesNew(wasm_exec_env_t env, uint32_t count)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return meshInstancesNewImpl(vm, count);
}
void meshInstancesResize(wasm_exec_env_t env, uint32_t instances, uint32_t count)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    meshInstancesResizeImpl(vm, instances, count);
}
void meshInstancesUpdate(wasm_exec_env_t env, uint32_t instances, uint32_t first, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    meshInstancesUpdateImpl(vm, instances, first, bytes, byteCount);
}
void meshInstancesRelease(wasm_exec_env_t env, uint32_t instances)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    meshInstancesReleaseImpl(vm, instances);
}
uint32_t blobAssetBytes(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return blobAssetBytesImpl(vm, object, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
uint32_t imageFromAsset(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return imageFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
uint32_t imageWidth(wasm_exec_env_t env, uint32_t image)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return imageWidthImpl(vm, image);
}
uint32_t imageHeight(wasm_exec_env_t env, uint32_t image)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return imageHeightImpl(vm, image);
}
void imageRelease(wasm_exec_env_t env, uint32_t image)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    imageReleaseImpl(vm, image);
}
uint32_t imageDecode(wasm_exec_env_t env, const uint8_t* bytes, uint32_t byteCount, uint32_t token)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return imageDecodeImpl(vm, bytes, byteCount, token);
}
void imageDecodeCancel(wasm_exec_env_t env, uint32_t token)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    imageDecodeCancelImpl(vm, token);
}
uint32_t fontFromAsset(wasm_exec_env_t env, uint32_t object, const char* name, uint32_t length)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, length);
    return fontFromAssetImpl(vm, object, nameUtf8.data(), nameUtf8.size());
}
#ifdef WITH_RIVE_TEXT
uint32_t fontDecode(wasm_exec_env_t env, const uint8_t* bytes, uint32_t byteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontDecodeImpl(vm, bytes, byteCount);
}
#endif
void fontRelease(wasm_exec_env_t env, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    fontReleaseImpl(vm, font);
}
void fontMetrics(wasm_exec_env_t env, uint32_t font, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    fontMetricsImpl(vm, font, out, outCount);
}
uint32_t fontWeight(wasm_exec_env_t env, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontWeightImpl(vm, font);
}
uint32_t fontIsItalic(wasm_exec_env_t env, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontIsItalicImpl(vm, font);
}
uint32_t fontAxisCount(wasm_exec_env_t env, uint32_t font)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontAxisCountImpl(vm, font);
}
void fontAxis(wasm_exec_env_t env, uint32_t font, uint32_t index, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    fontAxisImpl(vm, font, index, out, outCount);
}
float fontAxisValue(wasm_exec_env_t env, uint32_t font, uint32_t tag)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontAxisValueImpl(vm, font, tag);
}
uint32_t fontFeatures(wasm_exec_env_t env, uint32_t font, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return fontFeaturesImpl(vm, font, out, outCount);
}
uint32_t fontHasGlyph(wasm_exec_env_t env, uint32_t font, uint32_t codepoint)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontHasGlyphImpl(vm, font, codepoint);
}
uint32_t fontWithOptions(wasm_exec_env_t env, uint32_t font, const uint32_t* coords, uint32_t coordCount, const uint32_t* features, uint32_t featureCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (coordCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)coords, (uint64_t)coordCount * 4))
    {
        return {};
    }
    if (featureCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)features, (uint64_t)featureCount * 4))
    {
        return {};
    }
    return fontWithOptionsImpl(vm, font, coords, coordCount, features, featureCount);
}
#ifdef WITH_RIVE_TEXT
uint32_t fontGlyphVerbs(wasm_exec_env_t env, uint32_t font, uint32_t glyph, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fontGlyphVerbsImpl(vm, font, glyph, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t fontGlyphPoints(wasm_exec_env_t env, uint32_t font, uint32_t glyph, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return fontGlyphPointsImpl(vm, font, glyph, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textNew(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return textNewImpl(vm);
}
#endif
#ifdef WITH_RIVE_TEXT
void textRelease(wasm_exec_env_t env, uint32_t text)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    textReleaseImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
void textAppend(wasm_exec_env_t env, 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 = vmFromEnv(env);
    WasmStringArg charsUtf8(vm, chars, length);
    textAppendImpl(vm, text, charsUtf8.data(), charsUtf8.size(), font, paint, size, lineHeight, letterSpacing, foreground);
}
#endif
#ifdef WITH_RIVE_TEXT
void textClear(wasm_exec_env_t env, uint32_t text)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    textClearImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
void textLayout(wasm_exec_env_t env, uint32_t text, const rive_text_layout_desc_v1* desc, uint32_t descByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    textLayoutImpl(vm, text, desc, descByteCount);
}
#endif
#ifdef WITH_RIVE_TEXT
void textDraw(wasm_exec_env_t env, uint32_t text, uint32_t renderer, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    textDrawImpl(vm, text, renderer, paint);
}
#endif
#ifdef WITH_RIVE_TEXT
void textBounds(wasm_exec_env_t env, uint32_t text, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return;
    }
    textBoundsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textLength(wasm_exec_env_t env, uint32_t text)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return textLengthImpl(vm, text);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textLines(wasm_exec_env_t env, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return textLinesImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textRuns(wasm_exec_env_t env, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return textRunsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textGlyphs(wasm_exec_env_t env, uint32_t text, uint32_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return textGlyphsImpl(vm, text, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textHitTest(wasm_exec_env_t env, uint32_t text, float x, float y)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return textHitTestImpl(vm, text, x, y);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textCaret(wasm_exec_env_t env, uint32_t text, uint32_t index, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return textCaretImpl(vm, text, index, out, outCount);
}
#endif
#ifdef WITH_RIVE_TEXT
uint32_t textSelectionRects(wasm_exec_env_t env, uint32_t text, uint32_t from, uint32_t to, float* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (outCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)out, (uint64_t)outCount * 4))
    {
        return {};
    }
    return textSelectionRectsImpl(vm, text, from, to, out, outCount);
}
#endif
uint32_t shaderLinear(wasm_exec_env_t env, float sx, float sy, float ex, float ey, uint32_t colors, uint32_t stops, uint32_t count)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return shaderLinearImpl(vm, sx, sy, ex, ey, colors, stops, count);
}
uint32_t shaderRadial(wasm_exec_env_t env, float cx, float cy, float radius, uint32_t colors, uint32_t stops, uint32_t count)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return shaderRadialImpl(vm, cx, cy, radius, colors, stops, count);
}
void shaderRelease(wasm_exec_env_t env, uint32_t shader)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    shaderReleaseImpl(vm, shader);
}
uint32_t testBlob(wasm_exec_env_t env, const char* name, uint32_t nameLength, uint8_t* out, uint32_t outCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return testBlobImpl(vm, nameUtf8.data(), nameUtf8.size(), out, outCount);
}
void transitionChildDraw(wasm_exec_env_t env, uint32_t child, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    transitionChildDrawImpl(vm, child, renderer);
}
float transitionChildWidth(wasm_exec_env_t env, uint32_t child)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return transitionChildWidthImpl(vm, child);
}
float transitionChildHeight(wasm_exec_env_t env, uint32_t child)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return transitionChildHeightImpl(vm, child);
}
void rendererSave(wasm_exec_env_t env, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererSaveImpl(vm, renderer);
}
void rendererRestore(wasm_exec_env_t env, uint32_t renderer)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererRestoreImpl(vm, renderer);
}
void rendererTransform(wasm_exec_env_t env, uint32_t renderer, float xx, float xy, float yx, float yy, float tx, float ty)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererTransformImpl(vm, renderer, xx, xy, yx, yy, tx, ty);
}
void rendererDrawPath(wasm_exec_env_t env, uint32_t renderer, uint32_t path, uint32_t paint)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererDrawPathImpl(vm, renderer, path, paint);
}
void rendererClipPath(wasm_exec_env_t env, uint32_t renderer, uint32_t path)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererClipPathImpl(vm, renderer, path);
}
void rendererModulateOpacity(wasm_exec_env_t env, uint32_t renderer, float opacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererModulateOpacityImpl(vm, renderer, opacity);
}
void rendererModulateColor(wasm_exec_env_t env, uint32_t renderer, uint32_t color, uint32_t replace)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererModulateColorImpl(vm, renderer, color, replace);
}
void rendererDrawImage(wasm_exec_env_t env, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t blend, float opacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererDrawImageImpl(vm, renderer, image, sampler, blend, opacity);
}
void rendererDrawImageMesh(wasm_exec_env_t env, 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 = vmFromEnv(env);
    rendererDrawImageMeshImpl(vm, renderer, image, sampler, vertexBuffer, uvBuffer, indexBuffer, blend, opacity);
}
void rendererDrawImageMeshInstanced(wasm_exec_env_t env, uint32_t renderer, uint32_t image, uint32_t sampler, uint32_t vertexBuffer, uint32_t uvBuffer, uint32_t indexBuffer, uint32_t instances)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    rendererDrawImageMeshInstancedImpl(vm, renderer, image, sampler, vertexBuffer, uvBuffer, indexBuffer, instances);
}
uint32_t netFetch(wasm_exec_env_t env, const uint8_t* request, uint32_t requestCount, uint32_t token)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return netFetchImpl(vm, request, requestCount, token);
}
void netFetchCancel(wasm_exec_env_t env, uint32_t token)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    netFetchCancelImpl(vm, token);
}
uint32_t fileDecode(wasm_exec_env_t env, const uint8_t* bytes, uint32_t byteCount, uint32_t* statusOut, uint32_t statusCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    if (statusCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)statusOut, (uint64_t)statusCount * 4))
    {
        return {};
    }
    return fileDecodeImpl(vm, bytes, byteCount, statusOut, statusCount);
}
void fileRelease(wasm_exec_env_t env, uint32_t file)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    fileReleaseImpl(vm, file);
}
uint32_t fileArtboardCount(wasm_exec_env_t env, uint32_t file)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fileArtboardCountImpl(vm, file);
}
uint32_t fileArtboardName(wasm_exec_env_t env, uint32_t file, uint32_t index, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fileArtboardNameImpl(vm, file, index, buffer, capacity);
}
uint32_t fileBindable(wasm_exec_env_t env, uint32_t file, const char* name, uint32_t nameLength, uint32_t useDefault)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    WasmStringArg nameUtf8(vm, name, nameLength);
    return fileBindableImpl(vm, file, nameUtf8.data(), nameUtf8.size(), useDefault);
}
void fileBindableRelease(wasm_exec_env_t env, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    fileBindableReleaseImpl(vm, bindable);
}
uint32_t fileBindableName(wasm_exec_env_t env, uint32_t bindable, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fileBindableNameImpl(vm, bindable, buffer, capacity);
}
uint32_t fileBindableData(wasm_exec_env_t env, uint32_t bindable)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fileBindableDataImpl(vm, bindable);
}
uint32_t fileBindableEqual(wasm_exec_env_t env, uint32_t a, uint32_t b)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return fileBindableEqualImpl(vm, a, b);
}
uint32_t lanesStart(wasm_exec_env_t env, uint32_t kind, uint32_t entry, const uint8_t* input, uint32_t inputByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (holdCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)holds, (uint64_t)holdCount * 4))
    {
        return {};
    }
    return lanesStartImpl(vm, kind, entry, input, inputByteCount, holds, holdCount);
}
uint32_t lanesState(wasm_exec_env_t env, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesStateImpl(vm, lane);
}
uint32_t lanesFailed(wasm_exec_env_t env, uint32_t lane, char* buffer, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesFailedImpl(vm, lane, buffer, capacity);
}
void lanesStop(wasm_exec_env_t env, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    lanesStopImpl(vm, lane);
}
void lanesRelease(wasm_exec_env_t env, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    lanesReleaseImpl(vm, lane);
}
uint32_t lanesResult(wasm_exec_env_t env, uint32_t lane, uint32_t out, uint32_t outCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesResultImpl(vm, lane, out, outCount);
}
uint32_t lanesWatch(wasm_exec_env_t env, uint32_t lane)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesWatchImpl(vm, lane);
}
uint32_t lanesWait(wasm_exec_env_t env, uint32_t signal, double after, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesWaitImpl(vm, signal, after, timeoutSeconds);
}
void lanesCancelWait(wasm_exec_env_t env, uint32_t token)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    lanesCancelWaitImpl(vm, token);
}
double lanesWaitWithin(wasm_exec_env_t env, uint32_t signal, double after, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return lanesWaitWithinImpl(vm, signal, after, timeoutSeconds);
}
uint32_t jobsThreads(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return jobsThreadsImpl(vm);
}
uint32_t jobsJoin(wasm_exec_env_t env, uint32_t job, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return jobsJoinImpl(vm, job, timeoutSeconds);
}
uint32_t jobsJoinAny(wasm_exec_env_t env, const uint32_t* jobs, uint32_t count, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (count != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)jobs, (uint64_t)count * 4))
    {
        return {};
    }
    return jobsJoinAnyImpl(vm, jobs, count, timeoutSeconds);
}
uint32_t parallelSize(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return parallelSizeImpl(vm);
}
#ifdef RIVE_WASM_PARALLEL
uint32_t parallelRun(wasm_exec_env_t env, uint32_t control)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return parallelRunImpl(vm, control);
}
#endif
void parallelWaiting(wasm_exec_env_t env, uint32_t control)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    parallelWaitingImpl(vm, control);
}
uint32_t sharedRegionCreate(wasm_exec_env_t env, uint32_t size)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionCreateImpl(vm, size);
}
uint32_t sharedRegionSize(wasm_exec_env_t env, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionSizeImpl(vm, region);
}
uint32_t sharedRegionLock(wasm_exec_env_t env, uint32_t region, double timeoutSeconds)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionLockImpl(vm, region, timeoutSeconds);
}
void sharedRegionUnlock(wasm_exec_env_t env, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    sharedRegionUnlockImpl(vm, region);
}
uint32_t sharedRegionRead(wasm_exec_env_t env, uint32_t region, uint32_t offset, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionReadImpl(vm, region, offset, out, outByteCount);
}
uint32_t sharedRegionWrite(wasm_exec_env_t env, uint32_t region, uint32_t offset, const uint8_t* data, uint32_t dataByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionWriteImpl(vm, region, offset, data, dataByteCount);
}
uint32_t sharedRegionPoisoned(wasm_exec_env_t env, uint32_t region)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRegionPoisonedImpl(vm, region);
}
double sharedAtomicLoad(wasm_exec_env_t env, uint32_t region, uint32_t offset)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedAtomicLoadImpl(vm, region, offset);
}
double sharedAtomicStore(wasm_exec_env_t env, uint32_t region, uint32_t offset, uint32_t value)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedAtomicStoreImpl(vm, region, offset, value);
}
double sharedAtomicAdd(wasm_exec_env_t env, uint32_t region, uint32_t offset, uint32_t value)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedAtomicAddImpl(vm, region, offset, value);
}
double sharedAtomicCas(wasm_exec_env_t env, uint32_t region, uint32_t offset, uint32_t expected, uint32_t desired)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedAtomicCasImpl(vm, region, offset, expected, desired);
}
uint32_t sharedRingCreate(wasm_exec_env_t env, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRingCreateImpl(vm, capacity);
}
uint32_t sharedRingWrite(wasm_exec_env_t env, uint32_t ring, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (holdCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)holds, (uint64_t)holdCount * 4))
    {
        return {};
    }
    return sharedRingWriteImpl(vm, ring, data, dataByteCount, holds, holdCount);
}
uint32_t sharedRingRead(wasm_exec_env_t env, uint32_t ring, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRingReadImpl(vm, ring, out, outByteCount);
}
uint32_t sharedRingDrop(wasm_exec_env_t env, uint32_t ring, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRingDropImpl(vm, ring, capacity);
}
uint32_t sharedRingUsed(wasm_exec_env_t env, uint32_t ring)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRingUsedImpl(vm, ring);
}
uint32_t sharedRingSignal(wasm_exec_env_t env, uint32_t ring, uint32_t space)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRingSignalImpl(vm, ring, space);
}
uint32_t sharedSnapshotCreate(wasm_exec_env_t env, uint32_t capacity)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedSnapshotCreateImpl(vm, capacity);
}
uint32_t sharedSnapshotPublish(wasm_exec_env_t env, uint32_t snapshot, const uint8_t* data, uint32_t dataByteCount, const uint32_t* holds, uint32_t holdCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    if (holdCount != 0 && !wasm_runtime_validate_native_addr(wasm_runtime_get_module_inst(env), (void*)holds, (uint64_t)holdCount * 4))
    {
        return {};
    }
    return sharedSnapshotPublishImpl(vm, snapshot, data, dataByteCount, holds, holdCount);
}
uint32_t sharedSnapshotRead(wasm_exec_env_t env, uint32_t snapshot, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedSnapshotReadImpl(vm, snapshot, out, outByteCount);
}
double sharedSnapshotSeq(wasm_exec_env_t env, uint32_t snapshot)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedSnapshotSeqImpl(vm, snapshot);
}
void sharedReadDone(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    sharedReadDoneImpl(vm);
}
uint32_t sharedSignalCreate(wasm_exec_env_t env)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedSignalCreateImpl(vm);
}
void sharedSignalNotify(wasm_exec_env_t env, uint32_t signal)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    sharedSignalNotifyImpl(vm, signal);
}
double sharedSignalSeq(wasm_exec_env_t env, uint32_t signal)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedSignalSeqImpl(vm, signal);
}
uint32_t sharedBlobCreate(wasm_exec_env_t env, const uint8_t* data, uint32_t dataByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedBlobCreateImpl(vm, data, dataByteCount);
}
uint32_t sharedBlobSize(wasm_exec_env_t env, uint32_t blob)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedBlobSizeImpl(vm, blob);
}
uint32_t sharedBlobRead(wasm_exec_env_t env, uint32_t blob, uint32_t offset, uint8_t* out, uint32_t outByteCount)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedBlobReadImpl(vm, blob, offset, out, outByteCount);
}
uint32_t sharedRetain(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    return sharedRetainImpl(vm, object);
}
void sharedRelease(wasm_exec_env_t env, uint32_t object)
{
    WasmScriptingVM* vm = bootVmFromEnv(env);
    sharedReleaseImpl(vm, object);
}

NativeSymbol kRtNatives[] = {
    {"log", (void*)rtLog, "(i*~)", nullptr},
    {"mark_needs_update", (void*)rtMarkNeedsUpdate, "(i)", nullptr},
    {"budget_exceeded", (void*)rtBudgetExceeded, "(i)", nullptr},
    {"error", (void*)rtError, "(*~)", nullptr},
    {"now", (void*)rtNow, "()F", nullptr},
    {"date_now", (void*)rtDateNow, "()F", nullptr},
    {"features", (void*)rtFeatures, "()i", nullptr},
    {"debug_enter", (void*)rtDebugEnter, "(ii)", nullptr},
    {"debug_line", (void*)rtDebugLine, "(i)i", nullptr},
    {"debug_leave", (void*)rtDebugLeave, "()", nullptr},
    {"utc_offset", (void*)rtUtcOffset, "(F)i", nullptr},
    {"is_dst", (void*)rtIsDst, "(F)i", nullptr},
    {"zone_name", (void*)rtZoneName, "(F*~)i", nullptr},
};

NativeSymbol kDataNatives[] = {
    {"view_model", (void*)dataViewModel, "(i)i", nullptr},
    {"root_view_model", (void*)dataRootViewModel, "(i)i", nullptr},
    {"global_view_model", (void*)dataGlobalViewModel, "(i*~)i", nullptr},
    {"global_view_model_names", (void*)dataGlobalViewModelNames, "(i*~)i", nullptr},
    {"context", (void*)dataContext, "(i)i", nullptr},
    {"context_parent", (void*)dataContextParent, "(i)i", nullptr},
    {"context_view_model", (void*)dataContextViewModel, "(i)i", nullptr},
    {"context_release", (void*)dataContextRelease, "(i)", nullptr},
    {"has_view_model", (void*)dataHasViewModel, "(*~)i", nullptr},
    {"new_view_model", (void*)dataNewViewModel, "(*~*~)i", nullptr},
    {"vmi_release", (void*)dataVmiRelease, "(i)", nullptr},
    {"vmi_number", (void*)dataVmiNumber, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_boolean", (void*)dataVmiBoolean, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_string", (void*)dataVmiString, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_trigger", (void*)dataVmiTrigger, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_color", (void*)dataVmiColor, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_view_model", (void*)dataVmiViewModel, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_property", (void*)dataVmiProperty, "(i*~*~)i", nullptr},
    {"vmi_instance", (void*)dataVmiInstance, "(i*~)i", nullptr},
    {"vmi_symbol_index", (void*)dataVmiSymbolIndex, "(i)i", nullptr},
    {"vmi_equal", (void*)dataVmiEqual, "(ii)i", nullptr},
    {"view_model_get", (void*)dataViewModelGet, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_list", (void*)dataVmiList, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_enum", (void*)dataVmiEnum, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_image", (void*)dataVmiImage, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_font", (void*)dataVmiFont, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_blob", (void*)dataVmiBlob, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"vmi_artboard", (void*)dataVmiArtboard, "(i*~)i", nullptr},
    {"image_get", (void*)dataImageGet, "(i)i", nullptr},
    {"image_set", (void*)dataImageSet, "(ii)", nullptr},
    {"font_get", (void*)dataFontGet, "(i)i", nullptr},
    {"font_set", (void*)dataFontSet, "(ii)", nullptr},
    {"font_release", (void*)dataFontRelease, "(i)", nullptr},
    {"blob_present", (void*)dataBlobPresent, "(i)i", nullptr},
    {"blob_get", (void*)dataBlobGet, "(i*~)i", nullptr},
    {"blob_name", (void*)dataBlobName, "(i*~)i", nullptr},
    {"blob_set", (void*)dataBlobSet, "(i*~)", nullptr},
    {"blob_clear", (void*)dataBlobClear, "(i)", nullptr},
    {"artboard_get", (void*)dataArtboardGet, "(i)i", nullptr},
    {"artboard_set", (void*)dataArtboardSet, "(ii)", nullptr},
    {"enum_get", (void*)dataEnumGet, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"enum_set", (void*)dataEnumSet, "(i*~)", nullptr},
    {"enum_values", (void*)dataEnumValues, "(i*~)i", nullptr},
    {"prop_release", (void*)dataPropRelease, "(i)", nullptr},
    {"trigger_fire", (void*)dataTriggerFire, "(i)", nullptr},
    {"list_length", (void*)dataListLength, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"list_push", (void*)dataListPush, "(ii)", nullptr},
    {"list_pop", (void*)dataListPop, "(i)i", nullptr},
    {"list_shift", (void*)dataListShift, "(i)i", nullptr},
    {"list_clear", (void*)dataListClear, "(i)", nullptr},
    {"list_swap", (void*)dataListSwap, "(iii)", nullptr},
    {"list_insert", (void*)dataListInsert, "(iii)", nullptr},
    {"list_remove", (void*)dataListRemove, "(ii)", nullptr},
    {"list_remove_at", (void*)dataListRemoveAt, "(ii)", nullptr},
    {"list_remove_all_of", (void*)dataListRemoveAllOf, "(ii)", nullptr},
    {"list_get", (void*)dataListGet, "(ii)i", (void*)&wasm_runtime_rive_leaf_native},
    {"view_model_set", (void*)dataViewModelSet, "(ii)", nullptr},
    {"color_get", (void*)dataColorGet, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"color_set", (void*)dataColorSet, "(ii)", nullptr},
    {"number_get", (void*)dataNumberGet, "(i)f", (void*)&wasm_runtime_rive_leaf_native},
    {"number_set", (void*)dataNumberSet, "(if)", nullptr},
    {"boolean_get", (void*)dataBooleanGet, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"boolean_set", (void*)dataBooleanSet, "(ii)", nullptr},
    {"string_get", (void*)dataStringGet, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"string_changed", (void*)dataStringChanged, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"string_set", (void*)dataStringSet, "(i*~)", nullptr},
    {"watch", (void*)dataWatch, "(ii)", nullptr},
    {"unwatch", (void*)dataUnwatch, "(i)", nullptr},
    {"convert_result", (void*)dataConvertResult, "(ifii*~)", nullptr},
};

NativeSymbol kArtboardNatives[] = {
    {"release", (void*)artboardRelease, "(i)", nullptr},
    {"advance", (void*)artboardAdvance, "(if)i", nullptr},
    {"draw", (void*)artboardDraw, "(ii)", nullptr},
    {"instance", (void*)artboardInstance, "(ii)i", nullptr},
    {"data", (void*)artboardData, "(i)i", nullptr},
    {"width", (void*)artboardWidth, "(i)f", (void*)&wasm_runtime_rive_leaf_native},
    {"height", (void*)artboardHeight, "(i)f", (void*)&wasm_runtime_rive_leaf_native},
    {"set_width", (void*)artboardSetWidth, "(if)", nullptr},
    {"set_height", (void*)artboardSetHeight, "(if)", nullptr},
    {"frame_origin", (void*)artboardFrameOrigin, "(i)i", nullptr},
    {"set_frame_origin", (void*)artboardSetFrameOrigin, "(ii)", nullptr},
    {"bounds", (void*)artboardBounds, "(i*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"pointer_event", (void*)artboardPointerEvent, "(iiiff)i", nullptr},
    {"scroll_event", (void*)artboardScrollEvent, "(iiffffiif)i", nullptr},
    {"gamepad_event", (void*)artboardGamepadEvent, "(i*~)i", nullptr},
    {"animation", (void*)artboardAnimation, "(i*~)i", nullptr},
    {"animation_release", (void*)artboardAnimationRelease, "(i)", nullptr},
    {"animation_duration", (void*)artboardAnimationDuration, "(i)f", nullptr},
    {"animation_advance", (void*)artboardAnimationAdvance, "(if)i", nullptr},
    {"animation_set_time", (void*)artboardAnimationSetTime, "(ifi)", nullptr},
    {"add_to_path", (void*)artboardAddToPath, "(iiffffff)", nullptr},
    {"node", (void*)artboardNode, "(i*~)i", nullptr},
    {"node_release", (void*)artboardNodeRelease, "(i)", nullptr},
    {"node_transform", (void*)artboardNodeTransform, "(i*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"node_set", (void*)artboardNodeSet, "(iiff)", nullptr},
    {"node_world_transform", (void*)artboardNodeWorldTransform, "(i*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"node_set_world_transform", (void*)artboardNodeSetWorldTransform, "(i*~)", nullptr},
    {"node_decompose", (void*)artboardNodeDecompose, "(i*~)", nullptr},
    {"node_path_verbs", (void*)artboardNodePathVerbs, "(i*~)i", nullptr},
    {"node_path_points", (void*)artboardNodePathPoints, "(i*~)i", nullptr},
    {"node_paint", (void*)artboardNodePaint, "(i*~)i", nullptr},
    {"node_children", (void*)artboardNodeChildren, "(i*~)i", nullptr},
    {"node_parent", (void*)artboardNodeParent, "(i)i", nullptr},
    {"property_key", (void*)artboardPropertyKey, "(i*~)i", nullptr},
    {"draw_visit", (void*)artboardDrawVisit, "(ii)", nullptr},
    {"draw_modulated", (void*)artboardDrawModulated, "(iii)", nullptr},
    {"drawable_draw", (void*)artboardDrawableDraw, "(ii)", nullptr},
    {"drawable_value", (void*)artboardDrawableValue, "(ii*~)i", nullptr},
    {"drawable_string", (void*)artboardDrawableString, "(ii*~)i", nullptr},
#ifdef WITH_RIVE_TOOLS
    {"drawable_properties", (void*)artboardDrawableProperties, "(i*~)i", nullptr},
#endif
};

NativeSymbol kAudioNatives[] = {
    {"source", (void*)audioSource, "(i*~)i", nullptr},
    {"source_release", (void*)audioSourceRelease, "(i)", nullptr},
    {"source_duration", (void*)audioSourceDuration, "(i)f", nullptr},
    {"source_sample_rate", (void*)audioSourceSampleRate, "(i)i", nullptr},
    {"source_channels", (void*)audioSourceChannels, "(i)i", nullptr},
    {"source_to_blob", (void*)audioSourceToBlob, "(iii)i", nullptr},
    {"stream", (void*)audioStream, "(iiiii)i", nullptr},
    {"stream_ring", (void*)audioStreamRing, "(i)i", nullptr},
    {"stream_seeks", (void*)audioStreamSeeks, "(i)i", nullptr},
    {"stream_channels", (void*)audioStreamChannels, "(i)i", nullptr},
    {"stream_sample_rate", (void*)audioStreamSampleRate, "(i)i", nullptr},
    {"stream_seek_frame", (void*)audioStreamSeekFrame, "(iF)i", nullptr},
    {"stream_set_loop", (void*)audioStreamSetLoop, "(ii)", nullptr},
    {"stream_ended", (void*)audioStreamEnded, "(i)i", nullptr},
    {"stream_release", (void*)audioStreamRelease, "(i)", nullptr},
    {"play", (void*)audioPlay, "(i)i", nullptr},
    {"play_at_time", (void*)audioPlayAtTime, "(if)i", nullptr},
    {"play_in_time", (void*)audioPlayInTime, "(if)i", nullptr},
    {"play_at_frame", (void*)audioPlayAtFrame, "(iF)i", nullptr},
    {"play_in_frame", (void*)audioPlayInFrame, "(iF)i", nullptr},
    {"time", (void*)audioTime, "()f", nullptr},
    {"time_frame", (void*)audioTimeFrame, "()F", nullptr},
    {"sample_rate", (void*)audioSampleRate, "()i", nullptr},
    {"processor_sample_rate", (void*)audioProcessorSampleRate, "()i", nullptr},
    {"processor_channels", (void*)audioProcessorChannels, "()i", nullptr},
    {"sound_release", (void*)audioSoundRelease, "(i)", nullptr},
    {"sound_play", (void*)audioSoundPlay, "(i)", nullptr},
    {"sound_pause", (void*)audioSoundPause, "(i)", nullptr},
    {"sound_resume", (void*)audioSoundResume, "(i)", nullptr},
    {"sound_stop", (void*)audioSoundStop, "(ii)", nullptr},
    {"sound_seek", (void*)audioSoundSeek, "(if)i", nullptr},
    {"sound_seek_frame", (void*)audioSoundSeekFrame, "(iF)i", nullptr},
    {"sound_completed", (void*)audioSoundCompleted, "(i)i", nullptr},
    {"sound_time", (void*)audioSoundTime, "(i)f", nullptr},
    {"sound_time_frame", (void*)audioSoundTimeFrame, "(i)F", nullptr},
    {"sound_volume", (void*)audioSoundVolume, "(i)f", nullptr},
    {"sound_set_volume", (void*)audioSoundSetVolume, "(if)", nullptr},
};

NativeSymbol kPathNatives[] = {
    {"new", (void*)pathNew, "()i", (void*)&wasm_runtime_rive_leaf_native},
    {"update", (void*)pathUpdate, "(i*~*~i)", (void*)&wasm_runtime_rive_leaf_native},
    {"release", (void*)pathRelease, "(i)", (void*)&wasm_runtime_rive_leaf_native},
    {"add", (void*)pathAdd, "(iiffffff)", (void*)&wasm_runtime_rive_leaf_native},
    {"verbs", (void*)pathVerbs, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"points", (void*)pathPoints, "(i*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"effect_result", (void*)pathEffectResult, "(*~*~)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kMeasureNatives[] = {
    {"path_new", (void*)measurePathNew, "(*~*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"contours_new", (void*)measureContoursNew, "(*~*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"contour_next", (void*)measureContourNext, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"length", (void*)measureLength, "(i)f", (void*)&wasm_runtime_rive_leaf_native},
    {"is_closed", (void*)measureIsClosed, "(i)i", (void*)&wasm_runtime_rive_leaf_native},
    {"pos_tan", (void*)measurePosTan, "(if*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"warp", (void*)measureWarp, "(iff*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"extract", (void*)measureExtract, "(iffi)i", (void*)&wasm_runtime_rive_leaf_native},
    {"extract_read", (void*)measureExtractRead, "(i*~*~)i", (void*)&wasm_runtime_rive_leaf_native},
    {"release", (void*)measureRelease, "(i)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kPaintNatives[] = {
    {"new", (void*)paintNew, "()i", (void*)&wasm_runtime_rive_leaf_native},
    {"release", (void*)paintRelease, "(i)", (void*)&wasm_runtime_rive_leaf_native},
    {"style", (void*)paintStyle, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"color", (void*)paintColor, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"thickness", (void*)paintThickness, "(if)", (void*)&wasm_runtime_rive_leaf_native},
    {"join", (void*)paintJoin, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"cap", (void*)paintCap, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"blend_mode", (void*)paintBlendMode, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"feather", (void*)paintFeather, "(if)", (void*)&wasm_runtime_rive_leaf_native},
    {"shader", (void*)paintShader, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"shader_transform", (void*)paintShaderTransform, "(i*~)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kCanvasNatives[] = {
    {"new", (void*)canvasNew, "(ii)i", nullptr},
    {"release", (void*)canvasRelease, "(i)", nullptr},
    {"width", (void*)canvasWidth, "(i)i", nullptr},
    {"height", (void*)canvasHeight, "(i)i", nullptr},
    {"resize", (void*)canvasResize, "(iii)i", nullptr},
    {"image", (void*)canvasImage, "(i)i", nullptr},
    {"begin_frame", (void*)canvasBeginFrame, "(ii)i", nullptr},
    {"end_frame", (void*)canvasEndFrame, "(i)", nullptr},
};

NativeSymbol kGpuNatives[] = {
    {"features", (void*)gpuFeatures, "(*~)i", nullptr},
    {"canvas_new", (void*)gpuCanvasNew, "(ii)i", nullptr},
    {"canvas_release", (void*)gpuCanvasRelease, "(i)", nullptr},
    {"canvas_color_view", (void*)gpuCanvasColorView, "(i*~)i", nullptr},
    {"canvas_image", (void*)gpuCanvasImage, "(i)i", nullptr},
    {"canvas_resize", (void*)gpuCanvasResize, "(iii*~)i", nullptr},
    {"target_view", (void*)gpuTargetView, "(i*~)i", nullptr},
    {"pass_begin", (void*)gpuPassBegin, "(*~*~)i", nullptr},
    {"pass_set_pipeline", (void*)gpuPassSetPipeline, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_vertex_buffer", (void*)gpuPassSetVertexBuffer, "(iiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_index_buffer", (void*)gpuPassSetIndexBuffer, "(iiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_bind_group", (void*)gpuPassSetBindGroup, "(iii*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_viewport", (void*)gpuPassSetViewport, "(iffffff)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_scissor", (void*)gpuPassSetScissor, "(iiiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_stencil_reference", (void*)gpuPassSetStencilReference, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_set_blend_color", (void*)gpuPassSetBlendColor, "(iffff)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_draw", (void*)gpuPassDraw, "(iiiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_draw_indexed", (void*)gpuPassDrawIndexed, "(iiiiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"pass_finish", (void*)gpuPassFinish, "(i)", nullptr},
    {"pass_release", (void*)gpuPassRelease, "(i)", nullptr},
    {"image_view", (void*)gpuImageView, "(iii)i", nullptr},
    {"buffer_new", (void*)gpuBufferNew, "(iii*~)i", nullptr},
    {"buffer_update", (void*)gpuBufferUpdate, "(ii*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"buffer_update_blob", (void*)gpuBufferUpdateBlob, "(iiiii)", (void*)&wasm_runtime_rive_leaf_native},
    {"buffer_new_blob", (void*)gpuBufferNewBlob, "(iiiii)i", nullptr},
    {"buffer_release", (void*)gpuBufferRelease, "(i)", nullptr},
    {"texture_new", (void*)gpuTextureNew, "(*~)i", nullptr},
    {"texture_upload", (void*)gpuTextureUpload, "(i*~*~)", nullptr},
    {"texture_release", (void*)gpuTextureRelease, "(i)", nullptr},
    {"sampler_new", (void*)gpuSamplerNew, "(*~)i", nullptr},
    {"sampler_release", (void*)gpuSamplerRelease, "(i)", nullptr},
    {"texture_view_new", (void*)gpuTextureViewNew, "(i*~)i", nullptr},
    {"texture_view_release", (void*)gpuTextureViewRelease, "(i)", nullptr},
    {"shader_target", (void*)gpuShaderTarget, "()i", nullptr},
    {"shader_asset_bytes", (void*)gpuShaderAssetBytes, "(i*~*~)i", nullptr},
    {"shader_asset_id", (void*)gpuShaderAssetId, "(i*~)i", nullptr},
    {"shader_module_from_asset", (void*)gpuShaderModuleFromAsset, "(i*~i)i", nullptr},
#ifdef WITH_RIVE_TOOLS
    {"shader_module_from_rstb", (void*)gpuShaderModuleFromRstb, "(*~ii)i", nullptr},
#endif
    {"shader_module_release", (void*)gpuShaderModuleRelease, "(i)", nullptr},
    {"bind_group_layout_new", (void*)gpuBindGroupLayoutNew, "(i*~)i", nullptr},
    {"bind_group_layout_release", (void*)gpuBindGroupLayoutRelease, "(i)", nullptr},
    {"bind_group_layout_from_shader", (void*)gpuBindGroupLayoutFromShader, "(ii*~)i", nullptr},
    {"bind_group_layout_from_shaders", (void*)gpuBindGroupLayoutFromShaders, "(iii*~)i", nullptr},
    {"bind_group_layout_from_entries", (void*)gpuBindGroupLayoutFromEntries, "(i*~i*~i)i", nullptr},
    {"bind_group_new", (void*)gpuBindGroupNew, "(i*~*~*~)i", nullptr},
    {"bind_group_release", (void*)gpuBindGroupRelease, "(i)", nullptr},
    {"pipeline_new", (void*)gpuPipelineNew, "(*~*~)i", nullptr},
    {"pipeline_release", (void*)gpuPipelineRelease, "(i)", nullptr},
};

NativeSymbol kMat4Natives[] = {
    {"multiply", (void*)mat4Multiply, "(*~*~*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"invert", (void*)mat4Invert, "(*~*~)i", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kBufferNatives[] = {
    {"new", (void*)bufferNew, "(iii)i", (void*)&wasm_runtime_rive_leaf_native},
    {"update", (void*)bufferUpdate, "(i*~)", (void*)&wasm_runtime_rive_leaf_native},
    {"release", (void*)bufferRelease, "(i)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kMeshInstancesNatives[] = {
    {"new", (void*)meshInstancesNew, "(i)i", nullptr},
    {"resize", (void*)meshInstancesResize, "(ii)", nullptr},
    {"update", (void*)meshInstancesUpdate, "(ii*~)", nullptr},
    {"release", (void*)meshInstancesRelease, "(i)", nullptr},
};

NativeSymbol kBlobNatives[] = {
    {"asset_bytes", (void*)blobAssetBytes, "(i*~*~)i", nullptr},
};

NativeSymbol kImageNatives[] = {
    {"from_asset", (void*)imageFromAsset, "(i*~)i", nullptr},
    {"width", (void*)imageWidth, "(i)i", nullptr},
    {"height", (void*)imageHeight, "(i)i", nullptr},
    {"release", (void*)imageRelease, "(i)", nullptr},
    {"decode", (void*)imageDecode, "(*~i)i", nullptr},
    {"decode_cancel", (void*)imageDecodeCancel, "(i)", nullptr},
};

NativeSymbol kFontNatives[] = {
    {"from_asset", (void*)fontFromAsset, "(i*~)i", nullptr},
#ifdef WITH_RIVE_TEXT
    {"decode", (void*)fontDecode, "(*~)i", nullptr},
#endif
    {"release", (void*)fontRelease, "(i)", nullptr},
    {"metrics", (void*)fontMetrics, "(i*~)", nullptr},
    {"weight", (void*)fontWeight, "(i)i", nullptr},
    {"is_italic", (void*)fontIsItalic, "(i)i", nullptr},
    {"axis_count", (void*)fontAxisCount, "(i)i", nullptr},
    {"axis", (void*)fontAxis, "(ii*~)", nullptr},
    {"axis_value", (void*)fontAxisValue, "(ii)f", nullptr},
    {"features", (void*)fontFeatures, "(i*~)i", nullptr},
    {"has_glyph", (void*)fontHasGlyph, "(ii)i", nullptr},
    {"with_options", (void*)fontWithOptions, "(i*~*~)i", nullptr},
#ifdef WITH_RIVE_TEXT
    {"glyph_verbs", (void*)fontGlyphVerbs, "(ii*~)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"glyph_points", (void*)fontGlyphPoints, "(ii*~)i", nullptr},
#endif
};

NativeSymbol kTextNatives[] = {
#ifdef WITH_RIVE_TEXT
    {"new", (void*)textNew, "()i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"release", (void*)textRelease, "(i)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"append", (void*)textAppend, "(i*~iifffi)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"clear", (void*)textClear, "(i)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"layout", (void*)textLayout, "(i*~)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"draw", (void*)textDraw, "(iii)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"bounds", (void*)textBounds, "(i*~)", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"length", (void*)textLength, "(i)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"lines", (void*)textLines, "(i*~)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"runs", (void*)textRuns, "(i*~)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"glyphs", (void*)textGlyphs, "(i*~)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"hit_test", (void*)textHitTest, "(iff)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"caret", (void*)textCaret, "(ii*~)i", nullptr},
#endif
#ifdef WITH_RIVE_TEXT
    {"selection_rects", (void*)textSelectionRects, "(iii*~)i", nullptr},
#endif
};

NativeSymbol kShaderNatives[] = {
    {"linear", (void*)shaderLinear, "(ffffiii)i", (void*)&wasm_runtime_rive_leaf_native},
    {"radial", (void*)shaderRadial, "(fffiii)i", (void*)&wasm_runtime_rive_leaf_native},
    {"release", (void*)shaderRelease, "(i)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kTestNatives[] = {
    {"blob", (void*)testBlob, "(*~*~)i", nullptr},
};

NativeSymbol kTransitionNatives[] = {
    {"child_draw", (void*)transitionChildDraw, "(ii)", nullptr},
    {"child_width", (void*)transitionChildWidth, "(i)f", nullptr},
    {"child_height", (void*)transitionChildHeight, "(i)f", nullptr},
};

NativeSymbol kRendererNatives[] = {
    {"save", (void*)rendererSave, "(i)", (void*)&wasm_runtime_rive_leaf_native},
    {"restore", (void*)rendererRestore, "(i)", (void*)&wasm_runtime_rive_leaf_native},
    {"transform", (void*)rendererTransform, "(iffffff)", (void*)&wasm_runtime_rive_leaf_native},
    {"draw_path", (void*)rendererDrawPath, "(iii)", (void*)&wasm_runtime_rive_leaf_native},
    {"clip_path", (void*)rendererClipPath, "(ii)", (void*)&wasm_runtime_rive_leaf_native},
    {"modulate_opacity", (void*)rendererModulateOpacity, "(if)", (void*)&wasm_runtime_rive_leaf_native},
    {"modulate_color", (void*)rendererModulateColor, "(iii)", (void*)&wasm_runtime_rive_leaf_native},
    {"draw_image", (void*)rendererDrawImage, "(iiiif)", (void*)&wasm_runtime_rive_leaf_native},
    {"draw_image_mesh", (void*)rendererDrawImageMesh, "(iiiiiiif)", (void*)&wasm_runtime_rive_leaf_native},
    {"draw_image_mesh_instanced", (void*)rendererDrawImageMeshInstanced, "(iiiiiii)", (void*)&wasm_runtime_rive_leaf_native},
};

NativeSymbol kNetNatives[] = {
    {"fetch", (void*)netFetch, "(*~i)i", nullptr},
    {"fetch_cancel", (void*)netFetchCancel, "(i)", nullptr},
};

NativeSymbol kFileNatives[] = {
    {"decode", (void*)fileDecode, "(*~*~)i", nullptr},
    {"release", (void*)fileRelease, "(i)", nullptr},
    {"artboard_count", (void*)fileArtboardCount, "(i)i", nullptr},
    {"artboard_name", (void*)fileArtboardName, "(ii*~)i", nullptr},
    {"bindable", (void*)fileBindable, "(i*~i)i", nullptr},
    {"bindable_release", (void*)fileBindableRelease, "(i)", nullptr},
    {"bindable_name", (void*)fileBindableName, "(i*~)i", nullptr},
    {"bindable_data", (void*)fileBindableData, "(i)i", nullptr},
    {"bindable_equal", (void*)fileBindableEqual, "(ii)i", nullptr},
};

NativeSymbol kLanesNatives[] = {
    {"start", (void*)lanesStart, "(ii*~*~)i", nullptr},
    {"state", (void*)lanesState, "(i)i", nullptr},
    {"failed", (void*)lanesFailed, "(i*~)i", nullptr},
    {"stop", (void*)lanesStop, "(i)", nullptr},
    {"release", (void*)lanesRelease, "(i)", nullptr},
    {"result", (void*)lanesResult, "(iii)i", nullptr},
    {"watch", (void*)lanesWatch, "(i)i", nullptr},
    {"wait", (void*)lanesWait, "(iFF)i", nullptr},
    {"cancel_wait", (void*)lanesCancelWait, "(i)", nullptr},
    {"wait_within", (void*)lanesWaitWithin, "(iFF)F", nullptr},
};

NativeSymbol kJobsNatives[] = {
    {"threads", (void*)jobsThreads, "()i", nullptr},
    {"join", (void*)jobsJoin, "(iF)i", nullptr},
    {"join_any", (void*)jobsJoinAny, "(*~F)i", nullptr},
};

NativeSymbol kParallelNatives[] = {
    {"size", (void*)parallelSize, "()i", nullptr},
#ifdef RIVE_WASM_PARALLEL
    {"run", (void*)parallelRun, "(i)i", nullptr},
#endif
    {"waiting", (void*)parallelWaiting, "(i)", nullptr},
};

NativeSymbol kSharedNatives[] = {
    {"region_create", (void*)sharedRegionCreate, "(i)i", nullptr},
    {"region_size", (void*)sharedRegionSize, "(i)i", nullptr},
    {"region_lock", (void*)sharedRegionLock, "(iF)i", nullptr},
    {"region_unlock", (void*)sharedRegionUnlock, "(i)", nullptr},
    {"region_read", (void*)sharedRegionRead, "(ii*~)i", nullptr},
    {"region_write", (void*)sharedRegionWrite, "(ii*~)i", nullptr},
    {"region_poisoned", (void*)sharedRegionPoisoned, "(i)i", nullptr},
    {"atomic_load", (void*)sharedAtomicLoad, "(ii)F", nullptr},
    {"atomic_store", (void*)sharedAtomicStore, "(iii)F", nullptr},
    {"atomic_add", (void*)sharedAtomicAdd, "(iii)F", nullptr},
    {"atomic_cas", (void*)sharedAtomicCas, "(iiii)F", nullptr},
    {"ring_create", (void*)sharedRingCreate, "(i)i", nullptr},
    {"ring_write", (void*)sharedRingWrite, "(i*~*~)i", nullptr},
    {"ring_read", (void*)sharedRingRead, "(i*~)i", nullptr},
    {"ring_drop", (void*)sharedRingDrop, "(ii)i", nullptr},
    {"ring_used", (void*)sharedRingUsed, "(i)i", nullptr},
    {"ring_signal", (void*)sharedRingSignal, "(ii)i", nullptr},
    {"snapshot_create", (void*)sharedSnapshotCreate, "(i)i", nullptr},
    {"snapshot_publish", (void*)sharedSnapshotPublish, "(i*~*~)i", nullptr},
    {"snapshot_read", (void*)sharedSnapshotRead, "(i*~)i", nullptr},
    {"snapshot_seq", (void*)sharedSnapshotSeq, "(i)F", nullptr},
    {"read_done", (void*)sharedReadDone, "()", nullptr},
    {"signal_create", (void*)sharedSignalCreate, "()i", nullptr},
    {"signal_notify", (void*)sharedSignalNotify, "(i)", nullptr},
    {"signal_seq", (void*)sharedSignalSeq, "(i)F", nullptr},
    {"blob_create", (void*)sharedBlobCreate, "(*~)i", nullptr},
    {"blob_size", (void*)sharedBlobSize, "(i)i", nullptr},
    {"blob_read", (void*)sharedBlobRead, "(ii*~)i", nullptr},
    {"retain", (void*)sharedRetain, "(i)i", nullptr},
    {"release", (void*)sharedRelease, "(i)", nullptr},
};

inline bool registerRiveBindingNatives()
{
    return wasm_runtime_register_natives(
               "rive_rt_v1",
               kRtNatives,
               sizeof(kRtNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_data_v1",
               kDataNatives,
               sizeof(kDataNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_artboard_v1",
               kArtboardNatives,
               sizeof(kArtboardNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_audio_v1",
               kAudioNatives,
               sizeof(kAudioNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_path_v1",
               kPathNatives,
               sizeof(kPathNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_measure_v1",
               kMeasureNatives,
               sizeof(kMeasureNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_paint_v1",
               kPaintNatives,
               sizeof(kPaintNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_canvas_v1",
               kCanvasNatives,
               sizeof(kCanvasNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_gpu_v1",
               kGpuNatives,
               sizeof(kGpuNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_mat4_v1",
               kMat4Natives,
               sizeof(kMat4Natives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_buffer_v1",
               kBufferNatives,
               sizeof(kBufferNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_mesh_instances_v1",
               kMeshInstancesNatives,
               sizeof(kMeshInstancesNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_blob_v1",
               kBlobNatives,
               sizeof(kBlobNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_image_v1",
               kImageNatives,
               sizeof(kImageNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_font_v1",
               kFontNatives,
               sizeof(kFontNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_text_v1",
               kTextNatives,
               sizeof(kTextNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_shader_v1",
               kShaderNatives,
               sizeof(kShaderNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_test_v1",
               kTestNatives,
               sizeof(kTestNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_transition_v1",
               kTransitionNatives,
               sizeof(kTransitionNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_renderer_v1",
               kRendererNatives,
               sizeof(kRendererNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_net_v1",
               kNetNatives,
               sizeof(kNetNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_file_v1",
               kFileNatives,
               sizeof(kFileNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_lanes_v1",
               kLanesNatives,
               sizeof(kLanesNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_jobs_v1",
               kJobsNatives,
               sizeof(kJobsNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_parallel_v1",
               kParallelNatives,
               sizeof(kParallelNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_shared_v1",
               kSharedNatives,
               sizeof(kSharedNatives) / sizeof(NativeSymbol));
}
#endif