src/wasm/web/rive_module_imports.mjs

// Generated by src/wasm/idl/generate.py from bindings.py. Do not edit.

import { managedLength } from './rive_shared_lane.mjs';

// The runtime import object for script modules executing on the
// browser engine. Scalars forward straight into the host call
// table; str/buf/pod params stage through the host heap because
// the host cannot dereference module memory. `addr` params pass
// through as module addresses, which the host reads through its
// own memory seam.
//
// host contract:
//   calls      per-op host entry points (native-pointer convention)
//   heapU8()   Uint8Array over the host heap (refresh per call)
//   stackSave() -> mark
//   stackAlloc(size) -> host heap ptr valid until its mark is restored
//   stackRestore(mark)
//   malloc(size) -> host heap ptr, free(ptr)
//   counters   optional bridge tallies, counted while counters.on
// Staging nests: a host op may call back into the module, whose
// imports stage again above the outer call. Buffers too big for the
// host stack stage on its heap instead.
// moduleMemory: late-bound accessor for the script module memory,
// set after instantiation.
// only: the one namespace to build, as a lane needs, or null for all.
//
// Names that cross to wasm are quoted so a closure compiled host
// cannot rename them.
export function createRiveModuleImports(host, moduleMemory, only = null) {
    const want = (module) => only === null || only === module;
    const calls = host.calls;
    const stackSave = host.stackSave;
    const stackRestore = host.stackRestore;
    const kStackStageLimit = 4096;
    const counters = host.counters ?? { on: false };
    // Rebuilt only when the module memory grows.
    let moduleBytes = null;
    const moduleU8 = () => {
        const buffer = moduleMemory().buffer;
        if (moduleBytes === null || moduleBytes.buffer !== buffer) {
            moduleBytes = new Uint8Array(buffer);
        }
        return moduleBytes;
    };
    // Checked first: a range the module lacks throws before the alloc.
    // Module addresses and lengths arrive as signed i32s.
    const stageOut = (ptr, len) => {
        if (len < 0 || (ptr >>> 0) + len > moduleU8().length) {
            throw new RangeError('module range out of bounds');
        }
        const dst =
            len > kStackStageLimit ? host.malloc(len) : host.stackAlloc(len);
        if (dst === 0) {
            throw new Error(`could not stage ${len} bytes for the host`);
        }
        return dst;
    };
    const stageIn = (ptr, len) => {
        const dst = stageOut(ptr, len);
        ptr >>>= 0;
        host.heapU8().set(moduleBytes.subarray(ptr, ptr + len), dst);
        if (counters.on) counters.bytesStaged += len;
        return dst;
    };
    const unstage = (dst, len) => {
        if (dst !== 0 && len > kStackStageLimit) {
            host.free(dst);
        }
    };
    const copyOut = (src, ptr, len) => {
        if (len === 0) {
            return;
        }
        moduleU8().set(host.heapU8().subarray(src, src + len), ptr >>> 0);
        if (counters.on) counters.bytesCopiedOut += len;
    };
    // The elements a size answer wrote: all of them when they fit.
    const fitted = (size, capacity) =>
        size >>> 0 <= capacity ? size >>> 0 : 0;
    // Stages the managed string at text for fn(staged, byteLength). Null
    // reads as empty and the rest outside module memory traps, as on WAMR.
    const stageManaged = (text, fn) => {
        const length = managedLength(moduleMemory().buffer, text);
        const mark = stackSave();
        let text_p = 0;
        try {
            text_p = stageIn(text, length);
            fn(text_p, length);
        } finally {
            unstage(text_p, length);
            stackRestore(mark);
        }
    };
    // The std console, under the method codes rive_web_console takes.
    const consoleCall = (method) => (text) =>
        stageManaged(text, (text_p, length) =>
            calls.rive_console(method, text_p, length)
        );
    return {
        // Imported only by scripts that call Math.random, trace or console.
        'env': {
            'seed': () => Date.now() * Math.random(),
            // Where modules baked before rive_rt_v1.now read the clocks.
            'emscripten_get_now': () => performance.now(),
            'emscripten_date_now': () => Date.now(),
            'trace': (message, n, a0, a1, a2, a3, a4) =>
                stageManaged(message, (text_p, length) =>
                    calls.rive_trace(text_p, length, n, a0, a1, a2, a3, a4)
                ),
            'console.log': consoleCall(0),
            'console.debug': consoleCall(0),
            'console.info': consoleCall(0),
            'console.warn': consoleCall(0),
            'console.error': consoleCall(0),
            'console.time': consoleCall(1),
            'console.timeLog': consoleCall(2),
            'console.timeEnd': consoleCall(3),
        },
        'rive_rt_v1': want('rive_rt_v1') && {
            'log': (level, message, length) => {
                const mark = stackSave();
                let message_p = 0;
                try {
                    message_p = stageIn(message, length);
                    calls.rive_rt_log(level, message_p, length);
                } finally {
                    unstage(message_p, length);
                    stackRestore(mark);
                }
            },
            'mark_needs_update': calls.rive_rt_mark_needs_update,
            'budget_exceeded': calls.rive_rt_budget_exceeded,
            'error': (message, length) => {
                const mark = stackSave();
                let message_p = 0;
                try {
                    message_p = stageIn(message, length);
                    calls.rive_rt_error(message_p, length);
                } finally {
                    unstage(message_p, length);
                    stackRestore(mark);
                }
            },
            'now': () => performance.now(),
            'date_now': () => Date.now(),
            'debug_enter': calls.rive_rt_debug_enter,
            'debug_line': calls.rive_rt_debug_line,
            'debug_leave': calls.rive_rt_debug_leave,
            'utc_offset': calls.rive_rt_utc_offset,
            'is_dst': calls.rive_rt_is_dst,
            'zone_name': (epochSeconds, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_rt_zone_name(epochSeconds, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
        },
        'rive_data_v1': want('rive_data_v1') && {
            'view_model': calls.rive_data_view_model,
            'root_view_model': calls.rive_data_root_view_model,
            'global_view_model': (object, name, nameLength) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_data_global_view_model(object, name_p, nameLength);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'global_view_model_names': (object, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_global_view_model_names(object, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'context': calls.rive_data_context,
            'context_parent': calls.rive_data_context_parent,
            'context_view_model': calls.rive_data_context_view_model,
            'context_release': calls.rive_data_context_release,
            'has_view_model': (name, nameLength) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_data_has_view_model(name_p, nameLength);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'new_view_model': (name, nameLength, templateName, templateLength) => {
                const mark = stackSave();
                let name_p = 0;
                let templateName_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    templateName_p = stageIn(templateName, templateLength);
                    return calls.rive_data_new_view_model(name_p, nameLength, templateName_p, templateLength);
                } finally {
                    unstage(templateName_p, templateLength);
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'vmi_release': calls.rive_data_vmi_release,
            'vmi_number': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_number(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_boolean': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_boolean(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_string': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_string(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_trigger': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_trigger(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_color': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_color(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_view_model': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_view_model(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_property': (vmi, name, length, kindOut, kindCount) => {
                const mark = stackSave();
                let name_p = 0;
                let kindOut_p = 0;
                try {
                    name_p = stageIn(name, length);
                    kindOut_p = stageIn(kindOut, kindCount * 4);
                    const ret = calls.rive_data_vmi_property(vmi, name_p, length, kindOut_p, kindCount);
                    copyOut(kindOut_p, kindOut, kindCount * 4);
                    return ret;
                } finally {
                    unstage(kindOut_p, kindCount * 4);
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_instance': (vmi, name, nameLength) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_data_vmi_instance(vmi, name_p, nameLength);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'vmi_symbol_index': calls.rive_data_vmi_symbol_index,
            'vmi_equal': calls.rive_data_vmi_equal,
            'view_model_get': calls.rive_data_view_model_get,
            'vmi_list': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_list(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_enum': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_enum(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_image': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_image(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_font': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_font(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_blob': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_blob(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'vmi_artboard': (vmi, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_data_vmi_artboard(vmi, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'image_get': calls.rive_data_image_get,
            'image_set': calls.rive_data_image_set,
            'font_get': calls.rive_data_font_get,
            'font_set': calls.rive_data_font_set,
            'font_release': calls.rive_data_font_release,
            'blob_present': calls.rive_data_blob_present,
            'blob_get': (property, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_blob_get(property, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'blob_name': (property, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_blob_name(property, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'blob_set': (property, bytes, byteCount) => {
                const mark = stackSave();
                let bytes_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    calls.rive_data_blob_set(property, bytes_p, byteCount);
                } finally {
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'blob_clear': calls.rive_data_blob_clear,
            'artboard_get': calls.rive_data_artboard_get,
            'artboard_set': calls.rive_data_artboard_set,
            'enum_get': (property, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_enum_get(property, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'enum_set': (property, value, length) => {
                const mark = stackSave();
                let value_p = 0;
                try {
                    value_p = stageIn(value, length);
                    calls.rive_data_enum_set(property, value_p, length);
                } finally {
                    unstage(value_p, length);
                    stackRestore(mark);
                }
            },
            'enum_values': (property, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_enum_values(property, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'prop_release': calls.rive_data_prop_release,
            'trigger_fire': calls.rive_data_trigger_fire,
            'list_length': calls.rive_data_list_length,
            'list_push': calls.rive_data_list_push,
            'list_pop': calls.rive_data_list_pop,
            'list_shift': calls.rive_data_list_shift,
            'list_clear': calls.rive_data_list_clear,
            'list_swap': calls.rive_data_list_swap,
            'list_insert': calls.rive_data_list_insert,
            'list_remove': calls.rive_data_list_remove,
            'list_remove_at': calls.rive_data_list_remove_at,
            'list_remove_all_of': calls.rive_data_list_remove_all_of,
            'list_get': calls.rive_data_list_get,
            'view_model_set': calls.rive_data_view_model_set,
            'color_get': calls.rive_data_color_get,
            'color_set': calls.rive_data_color_set,
            'number_get': calls.rive_data_number_get,
            'number_set': calls.rive_data_number_set,
            'boolean_get': calls.rive_data_boolean_get,
            'boolean_set': calls.rive_data_boolean_set,
            'string_get': (property, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_data_string_get(property, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'string_changed': calls.rive_data_string_changed,
            'string_set': (property, value, length) => {
                const mark = stackSave();
                let value_p = 0;
                try {
                    value_p = stageIn(value, length);
                    calls.rive_data_string_set(property, value_p, length);
                } finally {
                    unstage(value_p, length);
                    stackRestore(mark);
                }
            },
            'watch': calls.rive_data_watch,
            'unwatch': calls.rive_data_unwatch,
            'convert_result': (kind, number, booleanValue, color, value, length) => {
                const mark = stackSave();
                let value_p = 0;
                try {
                    value_p = stageIn(value, length);
                    calls.rive_data_convert_result(kind, number, booleanValue, color, value_p, length);
                } finally {
                    unstage(value_p, length);
                    stackRestore(mark);
                }
            },
        },
        'rive_artboard_v1': want('rive_artboard_v1') && {
            'release': calls.rive_artboard_release,
            'advance': calls.rive_artboard_advance,
            'draw': calls.rive_artboard_draw,
            'instance': calls.rive_artboard_instance,
            'data': calls.rive_artboard_data,
            'width': calls.rive_artboard_width,
            'height': calls.rive_artboard_height,
            'set_width': calls.rive_artboard_set_width,
            'set_height': calls.rive_artboard_set_height,
            'frame_origin': calls.rive_artboard_frame_origin,
            'set_frame_origin': calls.rive_artboard_set_frame_origin,
            'bounds': (artboard, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_artboard_bounds(artboard, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'pointer_event': calls.rive_artboard_pointer_event,
            'scroll_event': calls.rive_artboard_scroll_event,
            'gamepad_event': (artboard, payload, byteCount) => {
                const mark = stackSave();
                let payload_p = 0;
                try {
                    payload_p = stageIn(payload, byteCount);
                    return calls.rive_artboard_gamepad_event(artboard, payload_p, byteCount);
                } finally {
                    unstage(payload_p, byteCount);
                    stackRestore(mark);
                }
            },
            'animation': (artboard, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_artboard_animation(artboard, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'animation_release': calls.rive_artboard_animation_release,
            'animation_duration': calls.rive_artboard_animation_duration,
            'animation_advance': calls.rive_artboard_animation_advance,
            'animation_set_time': calls.rive_artboard_animation_set_time,
            'add_to_path': calls.rive_artboard_add_to_path,
            'node': (artboard, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_artboard_node(artboard, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'node_release': calls.rive_artboard_node_release,
            'node_transform': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_artboard_node_transform(node, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'node_set': calls.rive_artboard_node_set,
            'node_world_transform': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_artboard_node_world_transform(node, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'node_set_world_transform': (node, values, floatCount) => {
                const mark = stackSave();
                let values_p = 0;
                try {
                    values_p = stageIn(values, floatCount * 4);
                    calls.rive_artboard_node_set_world_transform(node, values_p, floatCount);
                } finally {
                    unstage(values_p, floatCount * 4);
                    stackRestore(mark);
                }
            },
            'node_decompose': (node, values, floatCount) => {
                const mark = stackSave();
                let values_p = 0;
                try {
                    values_p = stageIn(values, floatCount * 4);
                    calls.rive_artboard_node_decompose(node, values_p, floatCount);
                } finally {
                    unstage(values_p, floatCount * 4);
                    stackRestore(mark);
                }
            },
            'node_path_verbs': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_artboard_node_path_verbs(node, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    stackRestore(mark);
                }
            },
            'node_path_points': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_artboard_node_path_points(node, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'node_paint': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_artboard_node_paint(node, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'node_children': (node, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_artboard_node_children(node, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'node_parent': calls.rive_artboard_node_parent,
            'property_key': (artboard, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_artboard_property_key(artboard, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'draw_visit': calls.rive_artboard_draw_visit,
            'draw_modulated': calls.rive_artboard_draw_modulated,
            'drawable_draw': calls.rive_artboard_drawable_draw,
            'drawable_value': (drawable, key, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_artboard_drawable_value(drawable, key, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'drawable_string': (drawable, key, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_artboard_drawable_string(drawable, key, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    stackRestore(mark);
                }
            },
            'drawable_properties': (drawable, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_artboard_drawable_properties(drawable, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    stackRestore(mark);
                }
            },
        },
        'rive_audio_v1': want('rive_audio_v1') && {
            'source': (object, name, nameLength) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_audio_source(object, name_p, nameLength);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'source_release': calls.rive_audio_source_release,
            'source_duration': calls.rive_audio_source_duration,
            'source_sample_rate': calls.rive_audio_source_sample_rate,
            'source_channels': calls.rive_audio_source_channels,
            'source_to_blob': calls.rive_audio_source_to_blob,
            'stream': calls.rive_audio_stream,
            'stream_ring': calls.rive_audio_stream_ring,
            'stream_seeks': calls.rive_audio_stream_seeks,
            'stream_channels': calls.rive_audio_stream_channels,
            'stream_sample_rate': calls.rive_audio_stream_sample_rate,
            'stream_seek_frame': calls.rive_audio_stream_seek_frame,
            'stream_set_loop': calls.rive_audio_stream_set_loop,
            'stream_ended': calls.rive_audio_stream_ended,
            'stream_release': calls.rive_audio_stream_release,
            'play': calls.rive_audio_play,
            'play_at_time': calls.rive_audio_play_at_time,
            'play_in_time': calls.rive_audio_play_in_time,
            'play_at_frame': calls.rive_audio_play_at_frame,
            'play_in_frame': calls.rive_audio_play_in_frame,
            'time': calls.rive_audio_time,
            'time_frame': calls.rive_audio_time_frame,
            'sample_rate': calls.rive_audio_sample_rate,
            'processor_sample_rate': calls.rive_audio_processor_sample_rate,
            'processor_channels': calls.rive_audio_processor_channels,
            'sound_release': calls.rive_audio_sound_release,
            'sound_play': calls.rive_audio_sound_play,
            'sound_pause': calls.rive_audio_sound_pause,
            'sound_resume': calls.rive_audio_sound_resume,
            'sound_stop': calls.rive_audio_sound_stop,
            'sound_seek': calls.rive_audio_sound_seek,
            'sound_seek_frame': calls.rive_audio_sound_seek_frame,
            'sound_completed': calls.rive_audio_sound_completed,
            'sound_time': calls.rive_audio_sound_time,
            'sound_time_frame': calls.rive_audio_sound_time_frame,
            'sound_volume': calls.rive_audio_sound_volume,
            'sound_set_volume': calls.rive_audio_sound_set_volume,
        },
        'rive_path_v1': want('rive_path_v1') && {
            'new': calls.rive_path_new,
            'update': (path, verbs, verbCount, points, floatCount, fillRule) => {
                const mark = stackSave();
                let verbs_p = 0;
                let points_p = 0;
                try {
                    verbs_p = stageIn(verbs, verbCount);
                    points_p = stageIn(points, floatCount * 4);
                    calls.rive_path_update(path, verbs_p, verbCount, points_p, floatCount, fillRule);
                } finally {
                    unstage(points_p, floatCount * 4);
                    unstage(verbs_p, verbCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_path_release,
            'add': calls.rive_path_add,
            'verbs': (path, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_path_verbs(path, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    stackRestore(mark);
                }
            },
            'points': (path, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_path_points(path, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'effect_result': (verbs, verbCount, points, floatCount) => {
                const mark = stackSave();
                let verbs_p = 0;
                let points_p = 0;
                try {
                    verbs_p = stageIn(verbs, verbCount);
                    points_p = stageIn(points, floatCount * 4);
                    calls.rive_path_effect_result(verbs_p, verbCount, points_p, floatCount);
                } finally {
                    unstage(points_p, floatCount * 4);
                    unstage(verbs_p, verbCount);
                    stackRestore(mark);
                }
            },
        },
        'rive_measure_v1': want('rive_measure_v1') && {
            'path_new': (verbs, verbCount, points, floatCount) => {
                const mark = stackSave();
                let verbs_p = 0;
                let points_p = 0;
                try {
                    verbs_p = stageIn(verbs, verbCount);
                    points_p = stageIn(points, floatCount * 4);
                    return calls.rive_measure_path_new(verbs_p, verbCount, points_p, floatCount);
                } finally {
                    unstage(points_p, floatCount * 4);
                    unstage(verbs_p, verbCount);
                    stackRestore(mark);
                }
            },
            'contours_new': (verbs, verbCount, points, floatCount) => {
                const mark = stackSave();
                let verbs_p = 0;
                let points_p = 0;
                try {
                    verbs_p = stageIn(verbs, verbCount);
                    points_p = stageIn(points, floatCount * 4);
                    return calls.rive_measure_contours_new(verbs_p, verbCount, points_p, floatCount);
                } finally {
                    unstage(points_p, floatCount * 4);
                    unstage(verbs_p, verbCount);
                    stackRestore(mark);
                }
            },
            'contour_next': calls.rive_measure_contour_next,
            'length': calls.rive_measure_length,
            'is_closed': calls.rive_measure_is_closed,
            'pos_tan': (measure, distance, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_measure_pos_tan(measure, distance, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'warp': (measure, x, y, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_measure_warp(measure, x, y, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'extract': calls.rive_measure_extract,
            'extract_read': (measure, verbs, verbCount, points, floatCount) => {
                const mark = stackSave();
                let verbs_p = 0;
                let points_p = 0;
                try {
                    verbs_p = stageIn(verbs, verbCount);
                    points_p = stageIn(points, floatCount * 4);
                    const ret = calls.rive_measure_extract_read(measure, verbs_p, verbCount, points_p, floatCount);
                    copyOut(verbs_p, verbs, verbCount);
                    copyOut(points_p, points, floatCount * 4);
                    return ret;
                } finally {
                    unstage(points_p, floatCount * 4);
                    unstage(verbs_p, verbCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_measure_release,
        },
        'rive_paint_v1': want('rive_paint_v1') && {
            'new': calls.rive_paint_new,
            'release': calls.rive_paint_release,
            'style': calls.rive_paint_style,
            'color': calls.rive_paint_color,
            'thickness': calls.rive_paint_thickness,
            'join': calls.rive_paint_join,
            'cap': calls.rive_paint_cap,
            'blend_mode': calls.rive_paint_blend_mode,
            'feather': calls.rive_paint_feather,
            'shader': calls.rive_paint_shader,
            'shader_transform': (paint, values, floatCount) => {
                const mark = stackSave();
                let values_p = 0;
                try {
                    values_p = stageIn(values, floatCount * 4);
                    calls.rive_paint_shader_transform(paint, values_p, floatCount);
                } finally {
                    unstage(values_p, floatCount * 4);
                    stackRestore(mark);
                }
            },
        },
        'rive_canvas_v1': want('rive_canvas_v1') && {
            'new': calls.rive_canvas_new,
            'release': calls.rive_canvas_release,
            'width': calls.rive_canvas_width,
            'height': calls.rive_canvas_height,
            'resize': calls.rive_canvas_resize,
            'image': calls.rive_canvas_image,
            'begin_frame': calls.rive_canvas_begin_frame,
            'end_frame': calls.rive_canvas_end_frame,
        },
        'rive_gpu_v1': want('rive_gpu_v1') && {
            'features': (out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_gpu_features(out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'canvas_new': calls.rive_gpu_canvas_new,
            'canvas_release': calls.rive_gpu_canvas_release,
            'canvas_color_view': (canvas, props, propCount) => {
                const mark = stackSave();
                let props_p = 0;
                try {
                    props_p = stageIn(props, propCount * 4);
                    const ret = calls.rive_gpu_canvas_color_view(canvas, props_p, propCount);
                    copyOut(props_p, props, propCount * 4);
                    return ret;
                } finally {
                    unstage(props_p, propCount * 4);
                    stackRestore(mark);
                }
            },
            'canvas_image': calls.rive_gpu_canvas_image,
            'canvas_resize': (canvas, width, height, props, propCount) => {
                const mark = stackSave();
                let props_p = 0;
                try {
                    props_p = stageIn(props, propCount * 4);
                    const ret = calls.rive_gpu_canvas_resize(canvas, width, height, props_p, propCount);
                    copyOut(props_p, props, propCount * 4);
                    return ret;
                } finally {
                    unstage(props_p, propCount * 4);
                    stackRestore(mark);
                }
            },
            'target_view': (current, props, propCount) => {
                const mark = stackSave();
                let props_p = 0;
                try {
                    props_p = stageIn(props, propCount * 4);
                    const ret = calls.rive_gpu_target_view(current, props_p, propCount);
                    copyOut(props_p, props, propCount * 4);
                    return ret;
                } finally {
                    unstage(props_p, propCount * 4);
                    stackRestore(mark);
                }
            },
            'pass_begin': (desc, descByteCount, blob, blobCount) => {
                const mark = stackSave();
                let desc_p = 0;
                let blob_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    blob_p = stageIn(blob, blobCount);
                    return calls.rive_gpu_pass_begin(desc_p, descByteCount, blob_p, blobCount);
                } finally {
                    unstage(blob_p, blobCount);
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'pass_set_pipeline': calls.rive_gpu_pass_set_pipeline,
            'pass_set_vertex_buffer': calls.rive_gpu_pass_set_vertex_buffer,
            'pass_set_index_buffer': calls.rive_gpu_pass_set_index_buffer,
            'pass_set_bind_group': (pass, groupIndex, bindGroup, dynamicOffsets, dynamicOffsetByteCount) => {
                const mark = stackSave();
                let dynamicOffsets_p = 0;
                try {
                    dynamicOffsets_p = stageIn(dynamicOffsets, dynamicOffsetByteCount);
                    calls.rive_gpu_pass_set_bind_group(pass, groupIndex, bindGroup, dynamicOffsets_p, dynamicOffsetByteCount);
                } finally {
                    unstage(dynamicOffsets_p, dynamicOffsetByteCount);
                    stackRestore(mark);
                }
            },
            'pass_set_viewport': calls.rive_gpu_pass_set_viewport,
            'pass_set_scissor': calls.rive_gpu_pass_set_scissor,
            'pass_set_stencil_reference': calls.rive_gpu_pass_set_stencil_reference,
            'pass_set_blend_color': calls.rive_gpu_pass_set_blend_color,
            'pass_draw': calls.rive_gpu_pass_draw,
            'pass_draw_indexed': calls.rive_gpu_pass_draw_indexed,
            'pass_finish': calls.rive_gpu_pass_finish,
            'pass_release': calls.rive_gpu_pass_release,
            'image_view': calls.rive_gpu_image_view,
            'buffer_new': (usage, sizeInBytes, immutable, data, dataCount) => {
                const mark = stackSave();
                let data_p = 0;
                try {
                    data_p = stageIn(data, dataCount);
                    return calls.rive_gpu_buffer_new(usage, sizeInBytes, immutable, data_p, dataCount);
                } finally {
                    unstage(data_p, dataCount);
                    stackRestore(mark);
                }
            },
            'buffer_update': (buffer, dstOffset, data, dataCount) => {
                const mark = stackSave();
                let data_p = 0;
                try {
                    data_p = stageIn(data, dataCount);
                    calls.rive_gpu_buffer_update(buffer, dstOffset, data_p, dataCount);
                } finally {
                    unstage(data_p, dataCount);
                    stackRestore(mark);
                }
            },
            'buffer_update_blob': calls.rive_gpu_buffer_update_blob,
            'buffer_new_blob': calls.rive_gpu_buffer_new_blob,
            'buffer_release': calls.rive_gpu_buffer_release,
            'texture_new': (desc, descByteCount) => {
                const mark = stackSave();
                let desc_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    return calls.rive_gpu_texture_new(desc_p, descByteCount);
                } finally {
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'texture_upload': (texture, region, regionByteCount, data, dataCount) => {
                const mark = stackSave();
                let region_p = 0;
                let data_p = 0;
                try {
                    region_p = stageIn(region, regionByteCount);
                    data_p = stageIn(data, dataCount);
                    calls.rive_gpu_texture_upload(texture, region_p, regionByteCount, data_p, dataCount);
                } finally {
                    unstage(data_p, dataCount);
                    unstage(region_p, regionByteCount);
                    stackRestore(mark);
                }
            },
            'texture_release': calls.rive_gpu_texture_release,
            'sampler_new': (desc, descByteCount) => {
                const mark = stackSave();
                let desc_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    return calls.rive_gpu_sampler_new(desc_p, descByteCount);
                } finally {
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'sampler_release': calls.rive_gpu_sampler_release,
            'texture_view_new': (texture, desc, descByteCount) => {
                const mark = stackSave();
                let desc_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    return calls.rive_gpu_texture_view_new(texture, desc_p, descByteCount);
                } finally {
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'texture_view_release': calls.rive_gpu_texture_view_release,
            'shader_target': calls.rive_gpu_shader_target,
            'shader_asset_bytes': (object, name, nameLength, out, outCount) => {
                const mark = stackSave();
                let name_p = 0;
                let out_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_gpu_shader_asset_bytes(object, name_p, nameLength, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'shader_asset_id': (object, name, nameLength) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_gpu_shader_asset_id(object, name_p, nameLength);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'shader_module_from_asset': (object, name, nameLength, entry) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_gpu_shader_module_from_asset(object, name_p, nameLength, entry);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'shader_module_from_rstb': (rstb, rstbCount, assetId, entry) => {
                const mark = stackSave();
                let rstb_p = 0;
                try {
                    rstb_p = stageIn(rstb, rstbCount);
                    return calls.rive_gpu_shader_module_from_rstb(rstb_p, rstbCount, assetId, entry);
                } finally {
                    unstage(rstb_p, rstbCount);
                    stackRestore(mark);
                }
            },
            'shader_module_release': calls.rive_gpu_shader_module_release,
            'bind_group_layout_new': (groupIndex, entries, entryByteCount) => {
                const mark = stackSave();
                let entries_p = 0;
                try {
                    entries_p = stageIn(entries, entryByteCount);
                    return calls.rive_gpu_bind_group_layout_new(groupIndex, entries_p, entryByteCount);
                } finally {
                    unstage(entries_p, entryByteCount);
                    stackRestore(mark);
                }
            },
            'bind_group_layout_release': calls.rive_gpu_bind_group_layout_release,
            'bind_group_layout_from_shader': (shaderModule, groupIndex, dynamicUBOs, dynamicUBOCount) => {
                const mark = stackSave();
                let dynamicUBOs_p = 0;
                try {
                    dynamicUBOs_p = stageIn(dynamicUBOs, dynamicUBOCount * 4);
                    return calls.rive_gpu_bind_group_layout_from_shader(shaderModule, groupIndex, dynamicUBOs_p, dynamicUBOCount);
                } finally {
                    unstage(dynamicUBOs_p, dynamicUBOCount * 4);
                    stackRestore(mark);
                }
            },
            'bind_group_layout_from_shaders': (vertexModule, fragmentModule, groupIndex, dynamicUBOs, dynamicUBOCount) => {
                const mark = stackSave();
                let dynamicUBOs_p = 0;
                try {
                    dynamicUBOs_p = stageIn(dynamicUBOs, dynamicUBOCount * 4);
                    return calls.rive_gpu_bind_group_layout_from_shaders(vertexModule, fragmentModule, groupIndex, dynamicUBOs_p, dynamicUBOCount);
                } finally {
                    unstage(dynamicUBOs_p, dynamicUBOCount * 4);
                    stackRestore(mark);
                }
            },
            'bind_group_layout_from_entries': (vertexModule, vertexEntry, vertexEntryLength, fragmentModule, fragmentEntry, fragmentEntryLength, groupIndex) => {
                const mark = stackSave();
                let vertexEntry_p = 0;
                let fragmentEntry_p = 0;
                try {
                    vertexEntry_p = stageIn(vertexEntry, vertexEntryLength);
                    fragmentEntry_p = stageIn(fragmentEntry, fragmentEntryLength);
                    return calls.rive_gpu_bind_group_layout_from_entries(vertexModule, vertexEntry_p, vertexEntryLength, fragmentModule, fragmentEntry_p, fragmentEntryLength, groupIndex);
                } finally {
                    unstage(fragmentEntry_p, fragmentEntryLength);
                    unstage(vertexEntry_p, vertexEntryLength);
                    stackRestore(mark);
                }
            },
            'bind_group_new': (layout, ubos, uboByteCount, textures, textureByteCount, samplers, samplerByteCount) => {
                const mark = stackSave();
                let ubos_p = 0;
                let textures_p = 0;
                let samplers_p = 0;
                try {
                    ubos_p = stageIn(ubos, uboByteCount);
                    textures_p = stageIn(textures, textureByteCount);
                    samplers_p = stageIn(samplers, samplerByteCount);
                    return calls.rive_gpu_bind_group_new(layout, ubos_p, uboByteCount, textures_p, textureByteCount, samplers_p, samplerByteCount);
                } finally {
                    unstage(samplers_p, samplerByteCount);
                    unstage(textures_p, textureByteCount);
                    unstage(ubos_p, uboByteCount);
                    stackRestore(mark);
                }
            },
            'bind_group_release': calls.rive_gpu_bind_group_release,
            'pipeline_new': (desc, descByteCount, blob, blobCount) => {
                const mark = stackSave();
                let desc_p = 0;
                let blob_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    blob_p = stageIn(blob, blobCount);
                    return calls.rive_gpu_pipeline_new(desc_p, descByteCount, blob_p, blobCount);
                } finally {
                    unstage(blob_p, blobCount);
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'pipeline_release': calls.rive_gpu_pipeline_release,
        },
        'rive_mat4_v1': want('rive_mat4_v1') && {
            'multiply': (out, outBytes, a, aBytes, b, bBytes) => {
                const mark = stackSave();
                let out_p = 0;
                let a_p = 0;
                let b_p = 0;
                try {
                    out_p = stageIn(out, outBytes);
                    a_p = stageIn(a, aBytes);
                    b_p = stageIn(b, bBytes);
                    calls.rive_mat4_multiply(out_p, outBytes, a_p, aBytes, b_p, bBytes);
                    copyOut(out_p, out, outBytes);
                } finally {
                    unstage(b_p, bBytes);
                    unstage(a_p, aBytes);
                    unstage(out_p, outBytes);
                    stackRestore(mark);
                }
            },
            'invert': (out, outBytes, src, srcBytes) => {
                const mark = stackSave();
                let out_p = 0;
                let src_p = 0;
                try {
                    out_p = stageIn(out, outBytes);
                    src_p = stageIn(src, srcBytes);
                    const ret = calls.rive_mat4_invert(out_p, outBytes, src_p, srcBytes);
                    copyOut(out_p, out, outBytes);
                    return ret;
                } finally {
                    unstage(src_p, srcBytes);
                    unstage(out_p, outBytes);
                    stackRestore(mark);
                }
            },
        },
        'rive_buffer_v1': want('rive_buffer_v1') && {
            'new': calls.rive_buffer_new,
            'update': (buffer, bytes, byteCount) => {
                const mark = stackSave();
                let bytes_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    calls.rive_buffer_update(buffer, bytes_p, byteCount);
                } finally {
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_buffer_release,
        },
        'rive_mesh_instances_v1': want('rive_mesh_instances_v1') && {
            'new': calls.rive_mesh_instances_new,
            'resize': calls.rive_mesh_instances_resize,
            'update': (instances, first, bytes, byteCount) => {
                const mark = stackSave();
                let bytes_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    calls.rive_mesh_instances_update(instances, first, bytes_p, byteCount);
                } finally {
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_mesh_instances_release,
        },
        'rive_blob_v1': want('rive_blob_v1') && {
            'asset_bytes': (object, name, nameLength, out, outCount) => {
                const mark = stackSave();
                let name_p = 0;
                let out_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_blob_asset_bytes(object, name_p, nameLength, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
        },
        'rive_image_v1': want('rive_image_v1') && {
            'from_asset': (object, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_image_from_asset(object, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'width': calls.rive_image_width,
            'height': calls.rive_image_height,
            'release': calls.rive_image_release,
            'decode': (bytes, byteCount, token) => {
                const mark = stackSave();
                let bytes_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    return calls.rive_image_decode(bytes_p, byteCount, token);
                } finally {
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'decode_cancel': calls.rive_image_decode_cancel,
        },
        'rive_font_v1': want('rive_font_v1') && {
            'from_asset': (object, name, length) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, length);
                    return calls.rive_font_from_asset(object, name_p, length);
                } finally {
                    unstage(name_p, length);
                    stackRestore(mark);
                }
            },
            'decode': (bytes, byteCount) => {
                const mark = stackSave();
                let bytes_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    return calls.rive_font_decode(bytes_p, byteCount);
                } finally {
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_font_release,
            'metrics': (font, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_font_metrics(font, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'weight': calls.rive_font_weight,
            'is_italic': calls.rive_font_is_italic,
            'axis_count': calls.rive_font_axis_count,
            'axis': (font, index, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_font_axis(font, index, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'axis_value': calls.rive_font_axis_value,
            'features': (font, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_font_features(font, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'has_glyph': calls.rive_font_has_glyph,
            'with_options': (font, coords, coordCount, features, featureCount) => {
                const mark = stackSave();
                let coords_p = 0;
                let features_p = 0;
                try {
                    coords_p = stageIn(coords, coordCount * 4);
                    features_p = stageIn(features, featureCount * 4);
                    return calls.rive_font_with_options(font, coords_p, coordCount, features_p, featureCount);
                } finally {
                    unstage(features_p, featureCount * 4);
                    unstage(coords_p, coordCount * 4);
                    stackRestore(mark);
                }
            },
            'glyph_verbs': (font, glyph, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_font_glyph_verbs(font, glyph, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    stackRestore(mark);
                }
            },
            'glyph_points': (font, glyph, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_font_glyph_points(font, glyph, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
        },
        'rive_text_v1': want('rive_text_v1') && {
            'new': calls.rive_text_new,
            'release': calls.rive_text_release,
            'append': (text, chars, length, font, paint, size, lineHeight, letterSpacing, foreground) => {
                const mark = stackSave();
                let chars_p = 0;
                try {
                    chars_p = stageIn(chars, length);
                    calls.rive_text_append(text, chars_p, length, font, paint, size, lineHeight, letterSpacing, foreground);
                } finally {
                    unstage(chars_p, length);
                    stackRestore(mark);
                }
            },
            'clear': calls.rive_text_clear,
            'layout': (text, desc, descByteCount) => {
                const mark = stackSave();
                let desc_p = 0;
                try {
                    desc_p = stageIn(desc, descByteCount);
                    calls.rive_text_layout(text, desc_p, descByteCount);
                } finally {
                    unstage(desc_p, descByteCount);
                    stackRestore(mark);
                }
            },
            'draw': calls.rive_text_draw,
            'bounds': (text, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    calls.rive_text_bounds(text, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'length': calls.rive_text_length,
            'lines': (text, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_text_lines(text, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'runs': (text, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_text_runs(text, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'glyphs': (text, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_text_glyphs(text, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'hit_test': calls.rive_text_hit_test,
            'caret': (text, index, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_text_caret(text, index, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
            'selection_rects': (text, from, to, out, outCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageIn(out, outCount * 4);
                    const ret = calls.rive_text_selection_rects(text, from, to, out_p, outCount);
                    copyOut(out_p, out, outCount * 4);
                    return ret;
                } finally {
                    unstage(out_p, outCount * 4);
                    stackRestore(mark);
                }
            },
        },
        'rive_shader_v1': want('rive_shader_v1') && {
            'linear': calls.rive_shader_linear,
            'radial': calls.rive_shader_radial,
            'release': calls.rive_shader_release,
        },
        'rive_test_v1': want('rive_test_v1') && {
            'blob': (name, nameLength, out, outCount) => {
                const mark = stackSave();
                let name_p = 0;
                let out_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    out_p = stageIn(out, outCount);
                    const ret = calls.rive_test_blob(name_p, nameLength, out_p, outCount);
                    copyOut(out_p, out, outCount);
                    return ret;
                } finally {
                    unstage(out_p, outCount);
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
        },
        'rive_transition_v1': want('rive_transition_v1') && {
            'child_draw': calls.rive_transition_child_draw,
            'child_width': calls.rive_transition_child_width,
            'child_height': calls.rive_transition_child_height,
        },
        'rive_renderer_v1': want('rive_renderer_v1') && {
            'save': calls.rive_renderer_save,
            'restore': calls.rive_renderer_restore,
            'transform': calls.rive_renderer_transform,
            'draw_path': calls.rive_renderer_draw_path,
            'clip_path': calls.rive_renderer_clip_path,
            'modulate_opacity': calls.rive_renderer_modulate_opacity,
            'modulate_color': calls.rive_renderer_modulate_color,
            'draw_image': calls.rive_renderer_draw_image,
            'draw_image_mesh': calls.rive_renderer_draw_image_mesh,
            'draw_image_mesh_instanced': calls.rive_renderer_draw_image_mesh_instanced,
        },
        'rive_net_v1': want('rive_net_v1') && {
            'fetch': (request, requestCount, token) => {
                const mark = stackSave();
                let request_p = 0;
                try {
                    request_p = stageIn(request, requestCount);
                    return calls.rive_net_fetch(request_p, requestCount, token);
                } finally {
                    unstage(request_p, requestCount);
                    stackRestore(mark);
                }
            },
            'fetch_cancel': calls.rive_net_fetch_cancel,
        },
        'rive_file_v1': want('rive_file_v1') && {
            'decode': (bytes, byteCount, statusOut, statusCount) => {
                const mark = stackSave();
                let bytes_p = 0;
                let statusOut_p = 0;
                try {
                    bytes_p = stageIn(bytes, byteCount);
                    statusOut_p = stageIn(statusOut, statusCount * 4);
                    const ret = calls.rive_file_decode(bytes_p, byteCount, statusOut_p, statusCount);
                    copyOut(statusOut_p, statusOut, statusCount * 4);
                    return ret;
                } finally {
                    unstage(statusOut_p, statusCount * 4);
                    unstage(bytes_p, byteCount);
                    stackRestore(mark);
                }
            },
            'release': calls.rive_file_release,
            'artboard_count': calls.rive_file_artboard_count,
            'artboard_name': (file, index, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_file_artboard_name(file, index, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'bindable': (file, name, nameLength, useDefault) => {
                const mark = stackSave();
                let name_p = 0;
                try {
                    name_p = stageIn(name, nameLength);
                    return calls.rive_file_bindable(file, name_p, nameLength, useDefault);
                } finally {
                    unstage(name_p, nameLength);
                    stackRestore(mark);
                }
            },
            'bindable_release': calls.rive_file_bindable_release,
            'bindable_name': (bindable, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageIn(buffer, capacity);
                    const ret = calls.rive_file_bindable_name(bindable, buffer_p, capacity);
                    copyOut(buffer_p, buffer, capacity);
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'bindable_data': calls.rive_file_bindable_data,
            'bindable_equal': calls.rive_file_bindable_equal,
        },
        'rive_lanes_v1': want('rive_lanes_v1') && {
            'start': (kind, entry, input, inputByteCount, holds, holdCount) => {
                const mark = stackSave();
                let input_p = 0;
                let holds_p = 0;
                try {
                    input_p = stageIn(input, inputByteCount);
                    holds_p = stageIn(holds, holdCount * 4);
                    return calls.rive_lanes_start(kind, entry, input_p, inputByteCount, holds_p, holdCount);
                } finally {
                    unstage(holds_p, holdCount * 4);
                    unstage(input_p, inputByteCount);
                    stackRestore(mark);
                }
            },
            'state': calls.rive_lanes_state,
            'failed': (lane, buffer, capacity) => {
                const mark = stackSave();
                let buffer_p = 0;
                try {
                    buffer_p = stageOut(buffer, capacity);
                    const ret = calls.rive_lanes_failed(lane, buffer_p, capacity);
                    copyOut(buffer_p, buffer, fitted(ret, capacity));
                    return ret;
                } finally {
                    unstage(buffer_p, capacity);
                    stackRestore(mark);
                }
            },
            'stop': calls.rive_lanes_stop,
            'release': calls.rive_lanes_release,
            'result': calls.rive_lanes_result,
            'watch': calls.rive_lanes_watch,
            'wait': calls.rive_lanes_wait,
            'cancel_wait': calls.rive_lanes_cancel_wait,
            'wait_within': calls.rive_lanes_wait_within,
        },
        'rive_jobs_v1': want('rive_jobs_v1') && {
            'threads': calls.rive_jobs_threads,
            'join': calls.rive_jobs_join,
            'join_any': (jobs, count, timeoutSeconds) => {
                const mark = stackSave();
                let jobs_p = 0;
                try {
                    jobs_p = stageIn(jobs, count * 4);
                    return calls.rive_jobs_join_any(jobs_p, count, timeoutSeconds);
                } finally {
                    unstage(jobs_p, count * 4);
                    stackRestore(mark);
                }
            },
        },
        'rive_parallel_v1': want('rive_parallel_v1') && {
            'size': calls.rive_parallel_size,
            'run': calls.rive_parallel_run,
            'waiting': () => undefined,
        },
        'rive_shared_v1': want('rive_shared_v1') && {
            'region_create': calls.rive_shared_region_create,
            'region_size': calls.rive_shared_region_size,
            'region_lock': calls.rive_shared_region_lock,
            'region_unlock': calls.rive_shared_region_unlock,
            'region_read': (region, offset, out, outByteCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageOut(out, outByteCount);
                    const ret = calls.rive_shared_region_read(region, offset, out_p, outByteCount);
                    copyOut(out_p, out, ret !== 0 ? outByteCount : 0);
                    return ret;
                } finally {
                    unstage(out_p, outByteCount);
                    stackRestore(mark);
                }
            },
            'region_write': (region, offset, data, dataByteCount) => {
                const mark = stackSave();
                let data_p = 0;
                try {
                    data_p = stageIn(data, dataByteCount);
                    return calls.rive_shared_region_write(region, offset, data_p, dataByteCount);
                } finally {
                    unstage(data_p, dataByteCount);
                    stackRestore(mark);
                }
            },
            'region_poisoned': calls.rive_shared_region_poisoned,
            'atomic_load': calls.rive_shared_atomic_load,
            'atomic_store': calls.rive_shared_atomic_store,
            'atomic_add': calls.rive_shared_atomic_add,
            'atomic_cas': calls.rive_shared_atomic_cas,
            'ring_create': calls.rive_shared_ring_create,
            'ring_write': (ring, data, dataByteCount, holds, holdCount) => {
                const mark = stackSave();
                let data_p = 0;
                let holds_p = 0;
                try {
                    data_p = stageIn(data, dataByteCount);
                    holds_p = stageIn(holds, holdCount * 4);
                    return calls.rive_shared_ring_write(ring, data_p, dataByteCount, holds_p, holdCount);
                } finally {
                    unstage(holds_p, holdCount * 4);
                    unstage(data_p, dataByteCount);
                    stackRestore(mark);
                }
            },
            'ring_read': (ring, out, outByteCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageOut(out, outByteCount);
                    const ret = calls.rive_shared_ring_read(ring, out_p, outByteCount);
                    copyOut(out_p, out, fitted(ret - 1, outByteCount));
                    return ret;
                } finally {
                    unstage(out_p, outByteCount);
                    stackRestore(mark);
                }
            },
            'ring_drop': calls.rive_shared_ring_drop,
            'ring_used': calls.rive_shared_ring_used,
            'ring_signal': calls.rive_shared_ring_signal,
            'snapshot_create': calls.rive_shared_snapshot_create,
            'snapshot_publish': (snapshot, data, dataByteCount, holds, holdCount) => {
                const mark = stackSave();
                let data_p = 0;
                let holds_p = 0;
                try {
                    data_p = stageIn(data, dataByteCount);
                    holds_p = stageIn(holds, holdCount * 4);
                    return calls.rive_shared_snapshot_publish(snapshot, data_p, dataByteCount, holds_p, holdCount);
                } finally {
                    unstage(holds_p, holdCount * 4);
                    unstage(data_p, dataByteCount);
                    stackRestore(mark);
                }
            },
            'snapshot_read': (snapshot, out, outByteCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageOut(out, outByteCount);
                    const ret = calls.rive_shared_snapshot_read(snapshot, out_p, outByteCount);
                    copyOut(out_p, out, fitted(ret - 1, outByteCount));
                    return ret;
                } finally {
                    unstage(out_p, outByteCount);
                    stackRestore(mark);
                }
            },
            'snapshot_seq': calls.rive_shared_snapshot_seq,
            'read_done': calls.rive_shared_read_done,
            'signal_create': calls.rive_shared_signal_create,
            'signal_notify': calls.rive_shared_signal_notify,
            'signal_seq': calls.rive_shared_signal_seq,
            'blob_create': (data, dataByteCount) => {
                const mark = stackSave();
                let data_p = 0;
                try {
                    data_p = stageIn(data, dataByteCount);
                    return calls.rive_shared_blob_create(data_p, dataByteCount);
                } finally {
                    unstage(data_p, dataByteCount);
                    stackRestore(mark);
                }
            },
            'blob_size': calls.rive_shared_blob_size,
            'blob_read': (blob, offset, out, outByteCount) => {
                const mark = stackSave();
                let out_p = 0;
                try {
                    out_p = stageOut(out, outByteCount);
                    const ret = calls.rive_shared_blob_read(blob, offset, out_p, outByteCount);
                    copyOut(out_p, out, fitted(ret, outByteCount));
                    return ret;
                } finally {
                    unstage(out_p, outByteCount);
                    stackRestore(mark);
                }
            },
            'retain': calls.rive_shared_retain,
            'release': calls.rive_shared_release,
        },
    };
}

// host.calls for one VM. hostCall(index) is the librive function at
// that index of its kRiveWebCalls table, undefined for a missing op.
// ctx.vm is the VM
// handle, zeroed when the VM goes away while its module is still
// instantiating. ctx.raised holds a raiseModuleError message: it is
// thrown once the host call has returned, so only module frames
// unwind. Anything thrown from inside librive unwound its frames
// without their destructors, so ctx.hostFault marks the VM done for.
// ctx.counters, when given, tallies the calls into librive.
// A fault in a nested script call unwinds the outer module frames too.
// only binds just that namespace's calls, as in createRiveModuleImports.
export function bindRiveHostCalls(hostCall, ctx, only = null) {
    const want = (module) => only === null || only === module;
    const counters = ctx.counters ?? { on: false };
    const raise = () => {
        const error = new Error(ctx.raised);
        ctx.raised = null;
        throw error;
    };
    const fault = (error) => {
        ctx.hostFault = true;
        throw error;
    };
    const nestedFault = () => {
        throw new Error('librive faulted in a nested script call');
    };
    const released = () => {
        throw new Error('script VM was released');
    };
    return {
        rive_rt_log: want('rive_rt_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(0)),
        rive_rt_mark_needs_update: want('rive_rt_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(1)),
        rive_rt_budget_exceeded: want('rive_rt_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(2)),
        rive_rt_error: want('rive_rt_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(3)),
        rive_rt_debug_enter: want('rive_rt_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(4)),
        rive_rt_debug_line: want('rive_rt_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(5)),
        rive_rt_debug_leave: want('rive_rt_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(6)),
        rive_rt_utc_offset: want('rive_rt_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(7)),
        rive_rt_is_dst: want('rive_rt_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(8)),
        rive_rt_zone_name: want('rive_rt_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(9)),
        rive_data_view_model: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(10)),
        rive_data_root_view_model: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(11)),
        rive_data_global_view_model: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(12)),
        rive_data_global_view_model_names: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(13)),
        rive_data_context: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(14)),
        rive_data_context_parent: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(15)),
        rive_data_context_view_model: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(16)),
        rive_data_context_release: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(17)),
        rive_data_has_view_model: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(18)),
        rive_data_new_view_model: want('rive_data_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(19)),
        rive_data_vmi_release: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(20)),
        rive_data_vmi_number: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(21)),
        rive_data_vmi_boolean: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(22)),
        rive_data_vmi_string: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(23)),
        rive_data_vmi_trigger: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(24)),
        rive_data_vmi_color: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(25)),
        rive_data_vmi_view_model: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(26)),
        rive_data_vmi_property: want('rive_data_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(27)),
        rive_data_vmi_instance: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(28)),
        rive_data_vmi_symbol_index: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(29)),
        rive_data_vmi_equal: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(30)),
        rive_data_view_model_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(31)),
        rive_data_vmi_list: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(32)),
        rive_data_vmi_enum: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(33)),
        rive_data_vmi_image: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(34)),
        rive_data_vmi_font: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(35)),
        rive_data_vmi_blob: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(36)),
        rive_data_vmi_artboard: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(37)),
        rive_data_image_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(38)),
        rive_data_image_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(39)),
        rive_data_font_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(40)),
        rive_data_font_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(41)),
        rive_data_font_release: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(42)),
        rive_data_blob_present: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(43)),
        rive_data_blob_get: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(44)),
        rive_data_blob_name: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(45)),
        rive_data_blob_set: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(46)),
        rive_data_blob_clear: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(47)),
        rive_data_artboard_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(48)),
        rive_data_artboard_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(49)),
        rive_data_enum_get: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(50)),
        rive_data_enum_set: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(51)),
        rive_data_enum_values: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(52)),
        rive_data_prop_release: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(53)),
        rive_data_trigger_fire: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(54)),
        rive_data_list_length: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(55)),
        rive_data_list_push: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(56)),
        rive_data_list_pop: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(57)),
        rive_data_list_shift: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(58)),
        rive_data_list_clear: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(59)),
        rive_data_list_swap: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(60)),
        rive_data_list_insert: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(61)),
        rive_data_list_remove: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(62)),
        rive_data_list_remove_at: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(63)),
        rive_data_list_remove_all_of: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(64)),
        rive_data_list_get: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(65)),
        rive_data_view_model_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(66)),
        rive_data_color_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(67)),
        rive_data_color_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(68)),
        rive_data_number_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(69)),
        rive_data_number_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(70)),
        rive_data_boolean_get: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(71)),
        rive_data_boolean_set: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(72)),
        rive_data_string_get: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(73)),
        rive_data_string_changed: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(74)),
        rive_data_string_set: want('rive_data_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(75)),
        rive_data_watch: want('rive_data_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(76)),
        rive_data_unwatch: want('rive_data_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(77)),
        rive_data_convert_result: want('rive_data_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(78)),
        rive_artboard_release: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(79)),
        rive_artboard_advance: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(80)),
        rive_artboard_draw: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(81)),
        rive_artboard_instance: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(82)),
        rive_artboard_data: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(83)),
        rive_artboard_width: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(84)),
        rive_artboard_height: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(85)),
        rive_artboard_set_width: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(86)),
        rive_artboard_set_height: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(87)),
        rive_artboard_frame_origin: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(88)),
        rive_artboard_set_frame_origin: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(89)),
        rive_artboard_bounds: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(90)),
        rive_artboard_pointer_event: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(91)),
        rive_artboard_scroll_event: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6, a7, a8) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7, a8); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(92)),
        rive_artboard_gamepad_event: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(93)),
        rive_artboard_animation: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(94)),
        rive_artboard_animation_release: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(95)),
        rive_artboard_animation_duration: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(96)),
        rive_artboard_animation_advance: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(97)),
        rive_artboard_animation_set_time: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(98)),
        rive_artboard_add_to_path: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6, a7) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(99)),
        rive_artboard_node: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(100)),
        rive_artboard_node_release: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(101)),
        rive_artboard_node_transform: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(102)),
        rive_artboard_node_set: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(103)),
        rive_artboard_node_world_transform: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(104)),
        rive_artboard_node_set_world_transform: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(105)),
        rive_artboard_node_decompose: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(106)),
        rive_artboard_node_path_verbs: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(107)),
        rive_artboard_node_path_points: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(108)),
        rive_artboard_node_paint: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(109)),
        rive_artboard_node_children: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(110)),
        rive_artboard_node_parent: want('rive_artboard_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(111)),
        rive_artboard_property_key: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(112)),
        rive_artboard_draw_visit: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(113)),
        rive_artboard_draw_modulated: want('rive_artboard_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(114)),
        rive_artboard_drawable_draw: want('rive_artboard_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(115)),
        rive_artboard_drawable_value: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(116)),
        rive_artboard_drawable_string: want('rive_artboard_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(117)),
        rive_artboard_drawable_properties: want('rive_artboard_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_artboard_v1', 'drawable_properties') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(118)),
        rive_audio_source: want('rive_audio_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(119)),
        rive_audio_source_release: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(120)),
        rive_audio_source_duration: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(121)),
        rive_audio_source_sample_rate: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(122)),
        rive_audio_source_channels: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(123)),
        rive_audio_source_to_blob: want('rive_audio_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(124)),
        rive_audio_stream: want('rive_audio_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(125)),
        rive_audio_stream_ring: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(126)),
        rive_audio_stream_seeks: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(127)),
        rive_audio_stream_channels: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(128)),
        rive_audio_stream_sample_rate: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(129)),
        rive_audio_stream_seek_frame: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(130)),
        rive_audio_stream_set_loop: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(131)),
        rive_audio_stream_ended: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(132)),
        rive_audio_stream_release: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(133)),
        rive_audio_play: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(134)),
        rive_audio_play_at_time: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(135)),
        rive_audio_play_in_time: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(136)),
        rive_audio_play_at_frame: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(137)),
        rive_audio_play_in_frame: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(138)),
        rive_audio_time: want('rive_audio_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(139)),
        rive_audio_time_frame: want('rive_audio_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(140)),
        rive_audio_sample_rate: want('rive_audio_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(141)),
        rive_audio_processor_sample_rate: want('rive_audio_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(142)),
        rive_audio_processor_channels: want('rive_audio_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(143)),
        rive_audio_sound_release: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(144)),
        rive_audio_sound_play: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(145)),
        rive_audio_sound_pause: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(146)),
        rive_audio_sound_resume: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(147)),
        rive_audio_sound_stop: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(148)),
        rive_audio_sound_seek: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(149)),
        rive_audio_sound_seek_frame: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(150)),
        rive_audio_sound_completed: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(151)),
        rive_audio_sound_time: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(152)),
        rive_audio_sound_time_frame: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(153)),
        rive_audio_sound_volume: want('rive_audio_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(154)),
        rive_audio_sound_set_volume: want('rive_audio_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(155)),
        rive_path_new: want('rive_path_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(156)),
        rive_path_update: want('rive_path_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(157)),
        rive_path_release: want('rive_path_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(158)),
        rive_path_add: want('rive_path_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6, a7) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(159)),
        rive_path_verbs: want('rive_path_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(160)),
        rive_path_points: want('rive_path_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(161)),
        rive_path_effect_result: want('rive_path_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(162)),
        rive_measure_path_new: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(163)),
        rive_measure_contours_new: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(164)),
        rive_measure_contour_next: want('rive_measure_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(165)),
        rive_measure_length: want('rive_measure_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(166)),
        rive_measure_is_closed: want('rive_measure_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(167)),
        rive_measure_pos_tan: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(168)),
        rive_measure_warp: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(169)),
        rive_measure_extract: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(170)),
        rive_measure_extract_read: want('rive_measure_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(171)),
        rive_measure_release: want('rive_measure_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(172)),
        rive_paint_new: want('rive_paint_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(173)),
        rive_paint_release: want('rive_paint_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(174)),
        rive_paint_style: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(175)),
        rive_paint_color: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(176)),
        rive_paint_thickness: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(177)),
        rive_paint_join: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(178)),
        rive_paint_cap: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(179)),
        rive_paint_blend_mode: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(180)),
        rive_paint_feather: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(181)),
        rive_paint_shader: want('rive_paint_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(182)),
        rive_paint_shader_transform: want('rive_paint_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(183)),
        rive_canvas_new: want('rive_canvas_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(184)),
        rive_canvas_release: want('rive_canvas_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(185)),
        rive_canvas_width: want('rive_canvas_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(186)),
        rive_canvas_height: want('rive_canvas_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(187)),
        rive_canvas_resize: want('rive_canvas_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(188)),
        rive_canvas_image: want('rive_canvas_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(189)),
        rive_canvas_begin_frame: want('rive_canvas_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(190)),
        rive_canvas_end_frame: want('rive_canvas_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(191)),
        rive_gpu_features: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(192)),
        rive_gpu_canvas_new: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(193)),
        rive_gpu_canvas_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(194)),
        rive_gpu_canvas_color_view: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(195)),
        rive_gpu_canvas_image: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(196)),
        rive_gpu_canvas_resize: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(197)),
        rive_gpu_target_view: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(198)),
        rive_gpu_pass_begin: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(199)),
        rive_gpu_pass_set_pipeline: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(200)),
        rive_gpu_pass_set_vertex_buffer: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(201)),
        rive_gpu_pass_set_index_buffer: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(202)),
        rive_gpu_pass_set_bind_group: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(203)),
        rive_gpu_pass_set_viewport: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(204)),
        rive_gpu_pass_set_scissor: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(205)),
        rive_gpu_pass_set_stencil_reference: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(206)),
        rive_gpu_pass_set_blend_color: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(207)),
        rive_gpu_pass_draw: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(208)),
        rive_gpu_pass_draw_indexed: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(209)),
        rive_gpu_pass_finish: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(210)),
        rive_gpu_pass_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(211)),
        rive_gpu_image_view: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(212)),
        rive_gpu_buffer_new: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(213)),
        rive_gpu_buffer_update: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(214)),
        rive_gpu_buffer_update_blob: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(215)),
        rive_gpu_buffer_new_blob: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(216)),
        rive_gpu_buffer_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(217)),
        rive_gpu_texture_new: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(218)),
        rive_gpu_texture_upload: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(219)),
        rive_gpu_texture_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(220)),
        rive_gpu_sampler_new: want('rive_gpu_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(221)),
        rive_gpu_sampler_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(222)),
        rive_gpu_texture_view_new: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(223)),
        rive_gpu_texture_view_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(224)),
        rive_gpu_shader_target: want('rive_gpu_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(225)),
        rive_gpu_shader_asset_bytes: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(226)),
        rive_gpu_shader_asset_id: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(227)),
        rive_gpu_shader_module_from_asset: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(228)),
        rive_gpu_shader_module_from_rstb: want('rive_gpu_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_gpu_v1', 'shader_module_from_rstb') : (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(229)),
        rive_gpu_shader_module_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(230)),
        rive_gpu_bind_group_layout_new: want('rive_gpu_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(231)),
        rive_gpu_bind_group_layout_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(232)),
        rive_gpu_bind_group_layout_from_shader: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(233)),
        rive_gpu_bind_group_layout_from_shaders: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(234)),
        rive_gpu_bind_group_layout_from_entries: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(235)),
        rive_gpu_bind_group_new: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(236)),
        rive_gpu_bind_group_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(237)),
        rive_gpu_pipeline_new: want('rive_gpu_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(238)),
        rive_gpu_pipeline_release: want('rive_gpu_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(239)),
        rive_mat4_multiply: want('rive_mat4_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(240)),
        rive_mat4_invert: want('rive_mat4_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(241)),
        rive_buffer_new: want('rive_buffer_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(242)),
        rive_buffer_update: want('rive_buffer_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(243)),
        rive_buffer_release: want('rive_buffer_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(244)),
        rive_mesh_instances_new: want('rive_mesh_instances_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(245)),
        rive_mesh_instances_resize: want('rive_mesh_instances_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(246)),
        rive_mesh_instances_update: want('rive_mesh_instances_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(247)),
        rive_mesh_instances_release: want('rive_mesh_instances_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(248)),
        rive_blob_asset_bytes: want('rive_blob_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(249)),
        rive_image_from_asset: want('rive_image_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(250)),
        rive_image_width: want('rive_image_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(251)),
        rive_image_height: want('rive_image_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(252)),
        rive_image_release: want('rive_image_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(253)),
        rive_image_decode: want('rive_image_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(254)),
        rive_image_decode_cancel: want('rive_image_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(255)),
        rive_font_from_asset: want('rive_font_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(256)),
        rive_font_decode: want('rive_font_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_font_v1', 'decode') : (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(257)),
        rive_font_release: want('rive_font_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(258)),
        rive_font_metrics: want('rive_font_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(259)),
        rive_font_weight: want('rive_font_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(260)),
        rive_font_is_italic: want('rive_font_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(261)),
        rive_font_axis_count: want('rive_font_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(262)),
        rive_font_axis: want('rive_font_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(263)),
        rive_font_axis_value: want('rive_font_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(264)),
        rive_font_features: want('rive_font_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(265)),
        rive_font_has_glyph: want('rive_font_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(266)),
        rive_font_with_options: want('rive_font_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(267)),
        rive_font_glyph_verbs: want('rive_font_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_font_v1', 'glyph_verbs') : (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(268)),
        rive_font_glyph_points: want('rive_font_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_font_v1', 'glyph_points') : (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(269)),
        rive_text_new: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'new') : () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(270)),
        rive_text_release: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'release') : (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(271)),
        rive_text_append: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'append') : (a0, a1, a2, a3, a4, a5, a6, a7, a8) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7, a8); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(272)),
        rive_text_clear: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'clear') : (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(273)),
        rive_text_layout: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'layout') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(274)),
        rive_text_draw: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'draw') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(275)),
        rive_text_bounds: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'bounds') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(276)),
        rive_text_length: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'length') : (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(277)),
        rive_text_lines: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'lines') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(278)),
        rive_text_runs: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'runs') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(279)),
        rive_text_glyphs: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'glyphs') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(280)),
        rive_text_hit_test: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'hit_test') : (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(281)),
        rive_text_caret: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'caret') : (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(282)),
        rive_text_selection_rects: want('rive_text_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_text_v1', 'selection_rects') : (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(283)),
        rive_shader_linear: want('rive_shader_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(284)),
        rive_shader_radial: want('rive_shader_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(285)),
        rive_shader_release: want('rive_shader_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(286)),
        rive_test_blob: want('rive_test_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(287)),
        rive_transition_child_draw: want('rive_transition_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(288)),
        rive_transition_child_width: want('rive_transition_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(289)),
        rive_transition_child_height: want('rive_transition_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(290)),
        rive_renderer_save: want('rive_renderer_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(291)),
        rive_renderer_restore: want('rive_renderer_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(292)),
        rive_renderer_transform: want('rive_renderer_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(293)),
        rive_renderer_draw_path: want('rive_renderer_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(294)),
        rive_renderer_clip_path: want('rive_renderer_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(295)),
        rive_renderer_modulate_opacity: want('rive_renderer_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(296)),
        rive_renderer_modulate_color: want('rive_renderer_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(297)),
        rive_renderer_draw_image: want('rive_renderer_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(298)),
        rive_renderer_draw_image_mesh: want('rive_renderer_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6, a7) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(299)),
        rive_renderer_draw_image_mesh_instanced: want('rive_renderer_v1') && ((fn) => (a0, a1, a2, a3, a4, a5, a6) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(300)),
        rive_net_fetch: want('rive_net_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(301)),
        rive_net_fetch_cancel: want('rive_net_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(302)),
        rive_file_decode: want('rive_file_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(303)),
        rive_file_release: want('rive_file_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(304)),
        rive_file_artboard_count: want('rive_file_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(305)),
        rive_file_artboard_name: want('rive_file_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(306)),
        rive_file_bindable: want('rive_file_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(307)),
        rive_file_bindable_release: want('rive_file_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(308)),
        rive_file_bindable_name: want('rive_file_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(309)),
        rive_file_bindable_data: want('rive_file_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(310)),
        rive_file_bindable_equal: want('rive_file_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(311)),
        rive_lanes_start: want('rive_lanes_v1') && ((fn) => (a0, a1, a2, a3, a4, a5) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4, a5); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(312)),
        rive_lanes_state: want('rive_lanes_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(313)),
        rive_lanes_failed: want('rive_lanes_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(314)),
        rive_lanes_stop: want('rive_lanes_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(315)),
        rive_lanes_release: want('rive_lanes_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(316)),
        rive_lanes_result: want('rive_lanes_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(317)),
        rive_lanes_watch: want('rive_lanes_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(318)),
        rive_lanes_wait: want('rive_lanes_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(319)),
        rive_lanes_cancel_wait: want('rive_lanes_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(320)),
        rive_lanes_wait_within: want('rive_lanes_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(321)),
        rive_jobs_threads: want('rive_jobs_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(322)),
        rive_jobs_join: want('rive_jobs_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(323)),
        rive_jobs_join_any: want('rive_jobs_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(324)),
        rive_parallel_size: want('rive_parallel_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(325)),
        rive_parallel_run: want('rive_parallel_v1') && ((fn) => fn === undefined ? unlinkedImport('rive_parallel_v1', 'run') : (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(326)),
        rive_shared_region_create: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(327)),
        rive_shared_region_size: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(328)),
        rive_shared_region_lock: want('rive_shared_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(329)),
        rive_shared_region_unlock: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(330)),
        rive_shared_region_read: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(331)),
        rive_shared_region_write: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(332)),
        rive_shared_region_poisoned: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(333)),
        rive_shared_atomic_load: want('rive_shared_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(334)),
        rive_shared_atomic_store: want('rive_shared_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(335)),
        rive_shared_atomic_add: want('rive_shared_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(336)),
        rive_shared_atomic_cas: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(337)),
        rive_shared_ring_create: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(338)),
        rive_shared_ring_write: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(339)),
        rive_shared_ring_read: want('rive_shared_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(340)),
        rive_shared_ring_drop: want('rive_shared_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(341)),
        rive_shared_ring_used: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(342)),
        rive_shared_ring_signal: want('rive_shared_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(343)),
        rive_shared_snapshot_create: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(344)),
        rive_shared_snapshot_publish: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3, a4) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3, a4); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(345)),
        rive_shared_snapshot_read: want('rive_shared_v1') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(346)),
        rive_shared_snapshot_seq: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(347)),
        rive_shared_read_done: want('rive_shared_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(348)),
        rive_shared_signal_create: want('rive_shared_v1') && ((fn) => () => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(349)),
        rive_shared_signal_notify: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(350)),
        rive_shared_signal_seq: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(351)),
        rive_shared_blob_create: want('rive_shared_v1') && ((fn) => (a0, a1) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(352)),
        rive_shared_blob_size: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(353)),
        rive_shared_blob_read: want('rive_shared_v1') && ((fn) => (a0, a1, a2, a3) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0, a1, a2, a3); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(354)),
        rive_shared_retain: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            let ret;
            try { ret = fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
            return ret;
        })(hostCall(355)),
        rive_shared_release: want('rive_shared_v1') && ((fn) => (a0) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(356)),
        rive_console: want('env') && ((fn) => (a0, a1, a2) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(357)),
        rive_trace: want('env') && ((fn) => (a0, a1, a2, a3, a4, a5, a6, a7) => {
            if (ctx.vm === 0) released();
            if (counters.on) counters.hostCalls++;
            try { fn(ctx.vm, a0, a1, a2, a3, a4, a5, a6, a7); } catch (error) { fault(error); }
            if (ctx.hostFault) nestedFault();
            if (ctx.raised !== null) raise();
        })(hostCall(358)),
    };
}

// Stands in for an import the host lacks, so the module still links
// and only a call to it traps, as on WAMR.
export function unlinkedImport(module, name) {
    return () => {
        throw new Error(
            'failed to call unlinked import function ' + module + '.' + name
        );
    };
}