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_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_shader_module_desc_v1
{
    uint32_t language;
    uint32_t stage;
    uint32_t codeSize;
    uint32_t hlslSourceSize;
    uint32_t hlslEntryPointSize;
    uint32_t bindingMapSize;
    uint32_t glFixupSize;
    uint32_t shaderAssetId;
} rive_gpu_shader_module_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;
} 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 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 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 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);
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 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);
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 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);
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 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);
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 gpuPassBeginImpl(WasmScriptingVM* vm, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const rive_gpu_pass_color_attachment_v1* colors, uint32_t colorByteCount);
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 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 gpuShaderModuleNewImpl(WasmScriptingVM* vm, const rive_gpu_shader_module_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount);
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 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);
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 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 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);
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 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 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 = vmFromEnv(env);
    rtBudgetExceededImpl(vm, ms);
}
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);
    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 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 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);
}
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);
    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 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);
}
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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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 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);
}
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);
    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 pathEffectResult(wasm_exec_env_t env, const uint8_t* verbs, uint32_t verbCount, const float* points, uint32_t floatCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    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);
    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);
    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);
    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);
    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);
    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);
}
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);
    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);
    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);
    return gpuCanvasResizeImpl(vm, canvas, width, height, props, propCount);
}
uint32_t gpuPassBegin(wasm_exec_env_t env, const rive_gpu_pass_desc_v1* desc, uint32_t descByteCount, const rive_gpu_pass_color_attachment_v1* colors, uint32_t colorByteCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuPassBeginImpl(vm, desc, descByteCount, colors, colorByteCount);
}
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 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 gpuShaderModuleNew(wasm_exec_env_t env, const rive_gpu_shader_module_desc_v1* desc, uint32_t descByteCount, const uint8_t* blob, uint32_t blobCount)
{
    WasmScriptingVM* vm = vmFromEnv(env);
    return gpuShaderModuleNewImpl(vm, desc, descByteCount, blob, blobCount);
}
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);
    return gpuBindGroupLayoutFromShaderImpl(vm, shaderModule, groupIndex, dynamicUBOs, dynamicUBOCount);
}
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);
}
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 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 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);
}
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 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);
}

NativeSymbol kRtNatives[] = {
    {"log", (void*)rtLog, "(i*~)", nullptr},
    {"mark_needs_update", (void*)rtMarkNeedsUpdate, "(i)", nullptr},
    {"budget_exceeded", (void*)rtBudgetExceeded, "(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", nullptr},
    {"vmi_boolean", (void*)dataVmiBoolean, "(i*~)i", nullptr},
    {"vmi_string", (void*)dataVmiString, "(i*~)i", nullptr},
    {"vmi_trigger", (void*)dataVmiTrigger, "(i*~)i", nullptr},
    {"vmi_color", (void*)dataVmiColor, "(i*~)i", nullptr},
    {"vmi_view_model", (void*)dataVmiViewModel, "(i*~)i", nullptr},
    {"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", nullptr},
    {"vmi_list", (void*)dataVmiList, "(i*~)i", nullptr},
    {"vmi_enum", (void*)dataVmiEnum, "(i*~)i", nullptr},
    {"vmi_image", (void*)dataVmiImage, "(i*~)i", nullptr},
    {"vmi_font", (void*)dataVmiFont, "(i*~)i", nullptr},
    {"vmi_blob", (void*)dataVmiBlob, "(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},
    {"enum_get", (void*)dataEnumGet, "(i*~)i", nullptr},
    {"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", nullptr},
    {"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", nullptr},
    {"view_model_set", (void*)dataViewModelSet, "(ii)", nullptr},
    {"color_get", (void*)dataColorGet, "(i)i", nullptr},
    {"color_set", (void*)dataColorSet, "(ii)", nullptr},
    {"number_get", (void*)dataNumberGet, "(i)f", nullptr},
    {"number_set", (void*)dataNumberSet, "(if)", nullptr},
    {"boolean_get", (void*)dataBooleanGet, "(i)i", nullptr},
    {"boolean_set", (void*)dataBooleanSet, "(ii)", nullptr},
    {"string_get", (void*)dataStringGet, "(i*~)i", nullptr},
    {"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", nullptr},
    {"height", (void*)artboardHeight, "(i)f", nullptr},
    {"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*~)", nullptr},
    {"pointer_event", (void*)artboardPointerEvent, "(iiiff)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},
    {"node", (void*)artboardNode, "(i*~)i", nullptr},
    {"node_release", (void*)artboardNodeRelease, "(i)", nullptr},
    {"node_transform", (void*)artboardNodeTransform, "(i*~)", nullptr},
    {"node_set", (void*)artboardNodeSet, "(iiff)", nullptr},
    {"node_world_transform", (void*)artboardNodeWorldTransform, "(i*~)", nullptr},
    {"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},
    {"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},
    {"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", nullptr},
    {"update", (void*)pathUpdate, "(i*~*~i)", nullptr},
    {"release", (void*)pathRelease, "(i)", nullptr},
    {"effect_result", (void*)pathEffectResult, "(*~*~)", nullptr},
};

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

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

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},
    {"pass_begin", (void*)gpuPassBegin, "(*~*~)i", nullptr},
    {"pass_set_pipeline", (void*)gpuPassSetPipeline, "(ii)", nullptr},
    {"pass_set_vertex_buffer", (void*)gpuPassSetVertexBuffer, "(iiii)", nullptr},
    {"pass_set_index_buffer", (void*)gpuPassSetIndexBuffer, "(iiii)", nullptr},
    {"pass_set_bind_group", (void*)gpuPassSetBindGroup, "(iii*~)", nullptr},
    {"pass_set_viewport", (void*)gpuPassSetViewport, "(iffffff)", nullptr},
    {"pass_set_scissor", (void*)gpuPassSetScissor, "(iiiii)", nullptr},
    {"pass_set_stencil_reference", (void*)gpuPassSetStencilReference, "(ii)", nullptr},
    {"pass_set_blend_color", (void*)gpuPassSetBlendColor, "(iffff)", nullptr},
    {"pass_draw", (void*)gpuPassDraw, "(iiiii)", nullptr},
    {"pass_draw_indexed", (void*)gpuPassDrawIndexed, "(iiiiii)", nullptr},
    {"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*~)", 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_new", (void*)gpuShaderModuleNew, "(*~*~)i", nullptr},
    {"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_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 kBufferNatives[] = {
    {"new", (void*)bufferNew, "(iii)i", nullptr},
    {"update", (void*)bufferUpdate, "(i*~)", nullptr},
    {"release", (void*)bufferRelease, "(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 kShaderNatives[] = {
    {"linear", (void*)shaderLinear, "(ffffiii)i", nullptr},
    {"radial", (void*)shaderRadial, "(fffiii)i", nullptr},
    {"release", (void*)shaderRelease, "(i)", nullptr},
};

NativeSymbol kRendererNatives[] = {
    {"save", (void*)rendererSave, "(i)", nullptr},
    {"restore", (void*)rendererRestore, "(i)", nullptr},
    {"transform", (void*)rendererTransform, "(iffffff)", nullptr},
    {"draw_path", (void*)rendererDrawPath, "(iii)", nullptr},
    {"clip_path", (void*)rendererClipPath, "(ii)", nullptr},
    {"modulate_color", (void*)rendererModulateColor, "(iii)", nullptr},
    {"draw_image", (void*)rendererDrawImage, "(iiiif)", nullptr},
    {"draw_image_mesh", (void*)rendererDrawImageMesh, "(iiiiiiif)", 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_buffer_v1",
               kBufferNatives,
               sizeof(kBufferNatives) / 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_shader_v1",
               kShaderNatives,
               sizeof(kShaderNatives) / sizeof(NativeSymbol)) &&
           wasm_runtime_register_natives(
               "rive_renderer_v1",
               kRendererNatives,
               sizeof(kRendererNatives) / sizeof(NativeSymbol));
}