> + 'static,

                        >
                        + std::panic::RefUnwindSafe
                        + 'static,

                            // TODO: error handling

                            let returned_result =
                                function_callback(function_context.env, $($function_argument_name),*)?;

                            $function_create_owned_return_type(returned_result)

                            let function_return_value = match std::panic::catch_unwind(|| function_callback(function_context.env, $($function_argument_name),*)) {
                                Ok(function_result) => function_result?,
                                Err(panic_payload) => {
                                    tracing::error!(
                                        message = "Function panic",
                                        event_handler = $function_js_name,
                                        ?panic_payload
                                    );
                                    return Err(napi::Error::from_reason("Function panic"));
                                }
                            };
                            $function_create_owned_return_type(function_return_value)

                    > + 'static,

                    >
                    + std::panic::RefUnwindSafe
                    + 'static,

                + std::panic::RefUnwindSafe

                                message = "Invalid arguments",

                                message = "Invalid arguments provided to event handler",

                            return Ok(());

                            return Err(napi::Error::from_reason(
                                "Invalid arguments provided to event handler",
                            ));

                    if let Err(error) = handler(function_context.env, event) {
                        tracing::error!(
                            message = "Handler exited unsuccessfully",
                            event_handler = $function_js_name,
                            ?error
                        );
                    }

                    match std::panic::catch_unwind(|| handler(function_context.env, event)) {
                        Ok(handler_result) => match handler_result {
                            Ok(result) => Ok(result),
                            Err(error) => {
                                tracing::error!(
                                    message = "Event handler returned an error",
                                    event_handler = $function_js_name,
                                    ?error
                                );

                    Ok(())

                                Err(napi::Error::from_reason("Event handler returned an error"))
                            }
                        },
                        Err(panic_payload) => {
                            tracing::error!(
                                message = "Event handler panicked",
                                event_handler = $function_js_name,
                                ?panic_payload
                            );
                            Err(napi::Error::from_reason("Event handler panicked"))
                        }
                    }

    std::panic::set_hook(Box::new(|panic_hook_info| {
        tracing::error!(message = "Extension panic", %panic_hook_info);
    }));

// TODO: panic handler

    let mut program_state = ExtensionState::get()?;

    let mut program_state = ExtensionState::get()?;

    let program_state = ExtensionState::get()?;

    let program_state = ExtensionState::get()?;

# Cranelift doesn't support unwinding, so make sure to use LLVM as the codegen backend
# TODO: remove this workaround once unwinding is stable on Linux:
# https://github.com/rust-lang/rustc_codegen_cranelift/issues/1567
[unstable]
codegen-backend = true
[profile.dev]
codegen-backend = "llvm"