From e72477cdc81322df0a769b7b4f223aaab9158f01 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sat, 11 Oct 2025 21:44:14 -0700 Subject: [PATCH 001/174] JavaScriptCore wrapper previously passed nullptr to JSObjectCallAsFunction when the receiver was undefined, so the VM forcibly substituted the global object even in strict mode. The new implementation always routes through Function.prototype.call, preserving the exact thisArg. This only affected JSC: Chakra already pushes recv onto the argv array before invoking JsCallFunction, and V8 hands the raw recv value to Function::Call. Neither engine coerces in strict mode, so no additional fixes were required. --- .../Source/js_native_api_javascriptcore.cc | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 5c8583bc..4cebad54 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -1647,14 +1647,28 @@ napi_status napi_call_function(napi_env env, CHECK_ARG(env, argv); } + JSObjectRef function_object = ToJSObject(env, func); + + std::vector call_args(argc + 1); + call_args[0] = ToJSValue(recv); + for (size_t i = 0; i < argc; ++i) { + call_args[i + 1] = ToJSValue(argv[i]); + } + JSValueRef exception{}; - JSValueRef return_value{JSObjectCallAsFunction( - env->context, - ToJSObject(env, func), - JSValueIsUndefined(env->context, ToJSValue(recv)) ? nullptr : ToJSObject(env, recv), - argc, - ToJSValues(argv), - &exception)}; + JSValueRef call_value{JSObjectGetProperty( + env->context, function_object, JSString("call"), &exception)}; + CHECK_JSC(env, exception); + + JSObjectRef call_object = JSValueToObject(env->context, call_value, &exception); + CHECK_JSC(env, exception); + + JSValueRef return_value{JSObjectCallAsFunction(env->context, + call_object, + function_object, + call_args.size(), + call_args.data(), + &exception)}; CHECK_JSC(env, exception); if (result != nullptr) { From b7551a7a926c6690c29be3daa45cf0249a633007 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sat, 11 Oct 2025 21:49:32 -0700 Subject: [PATCH 002/174] Add the node-lite test suite Vlad added into hermes-windows. The JSC bug fix in strict mode was actually found by the suite! The failing behavior was exercised by Tests/NodeApi/test/js-native-api/3_callbacks/test.js. New cmake targets emit a node-lite binary and a NodeApiTests binary, all currently enabled tests for currently supported NAPI v5 pass on Mac. Next step is to enable them for running in Android simulator. --- Tests/CMakeLists.txt | 1 + Tests/NodeApi/.clang-format | 111 ++ Tests/NodeApi/CMakeLists.txt | 175 +++ Tests/NodeApi/child_process.cpp | 192 +++ Tests/NodeApi/child_process.h | 27 + Tests/NodeApi/child_process_mac.cpp | 166 +++ Tests/NodeApi/compat.h | 51 + Tests/NodeApi/include/node_api.h | 67 + Tests/NodeApi/include/node_api_types.h | 24 + Tests/NodeApi/js_runtime_api.cpp | 112 ++ Tests/NodeApi/js_runtime_api.h | 219 +++ Tests/NodeApi/node_lite.cpp | 1268 ++++++++++++++++ Tests/NodeApi/node_lite.h | 365 +++++ Tests/NodeApi/node_lite_jsruntimehost.cpp | 90 ++ Tests/NodeApi/node_lite_mac.cpp | 39 + Tests/NodeApi/node_lite_windows.cpp | 25 + Tests/NodeApi/string_utils.cpp | 38 + Tests/NodeApi/string_utils.h | 21 + Tests/NodeApi/test/.clang-format | 111 ++ Tests/NodeApi/test/CMakeLists.txt | 91 ++ Tests/NodeApi/test/babel.config.js | 6 + Tests/NodeApi/test/basics/async_rejected.js | 19 + Tests/NodeApi/test/basics/async_resolved.js | 15 + Tests/NodeApi/test/basics/hello.js | 1 + Tests/NodeApi/test/basics/mustcall_failure.js | 3 + Tests/NodeApi/test/basics/mustcall_success.js | 4 + .../test/basics/mustnotcall_failure.js | 4 + .../test/basics/mustnotcall_success.js | 3 + Tests/NodeApi/test/basics/throw_string.js | 1 + Tests/NodeApi/test/common/assert.js | 400 +++++ Tests/NodeApi/test/common/gc.js | 34 + Tests/NodeApi/test/common/index.js | 57 + Tests/NodeApi/test/js-native-api/.gitignore | 7 + .../2_function_arguments.c | 39 + .../2_function_arguments/CMakeLists.txt | 4 + .../2_function_arguments/binding.gyp | 10 + .../2_function_arguments/test.js | 6 + .../js-native-api/3_callbacks/3_callbacks.c | 58 + .../js-native-api/3_callbacks/CMakeLists.txt | 4 + .../js-native-api/3_callbacks/binding.gyp | 10 + .../test/js-native-api/3_callbacks/test.js | 22 + .../4_object_factory/4_object_factory.c | 24 + .../4_object_factory/CMakeLists.txt | 4 + .../4_object_factory/binding.gyp | 10 + .../js-native-api/4_object_factory/test.js | 8 + .../5_function_factory/5_function_factory.c | 24 + .../5_function_factory/CMakeLists.txt | 4 + .../5_function_factory/binding.gyp | 10 + .../js-native-api/5_function_factory/test.js | 7 + .../6_object_wrap/CMakeLists.txt | 21 + .../js-native-api/6_object_wrap/binding.gyp | 28 + .../js-native-api/6_object_wrap/myobject.cc | 270 ++++ .../js-native-api/6_object_wrap/myobject.h | 28 + .../6_object_wrap/nested_wrap.cc | 99 ++ .../js-native-api/6_object_wrap/nested_wrap.h | 33 + .../6_object_wrap/nested_wrap.js | 20 + .../6_object_wrap/test-basic-finalizer.js | 24 + .../6_object_wrap/test-object-wrap-ref.js | 14 + .../test/js-native-api/6_object_wrap/test.js | 48 + .../7_factory_wrap/7_factory_wrap.cc | 32 + .../7_factory_wrap/CMakeLists.txt | 5 + .../js-native-api/7_factory_wrap/binding.gyp | 11 + .../js-native-api/7_factory_wrap/myobject.cc | 101 ++ .../js-native-api/7_factory_wrap/myobject.h | 27 + .../test/js-native-api/7_factory_wrap/test.js | 27 + .../8_passing_wrapped/8_passing_wrapped.cc | 61 + .../8_passing_wrapped/CMakeLists.txt | 5 + .../8_passing_wrapped/binding.gyp | 11 + .../8_passing_wrapped/myobject.cc | 91 ++ .../8_passing_wrapped/myobject.h | 28 + .../js-native-api/8_passing_wrapped/test.js | 21 + .../NodeApi/test/js-native-api/CMakeLists.txt | 7 + Tests/NodeApi/test/js-native-api/common-inl.h | 71 + Tests/NodeApi/test/js-native-api/common.h | 132 ++ .../NodeApi/test/js-native-api/entry_point.h | 12 + .../js-native-api/test_array/CMakeLists.txt | 4 + .../test/js-native-api/test_array/binding.gyp | 10 + .../test/js-native-api/test_array/test.js | 61 + .../js-native-api/test_array/test_array.c | 188 +++ .../js-native-api/test_bigint/CMakeLists.txt | 4 + .../js-native-api/test_bigint/binding.gyp | 10 + .../test/js-native-api/test_bigint/test.js | 52 + .../js-native-api/test_bigint/test_bigint.c | 159 ++ .../test_cannot_run_js/CMakeLists.txt | 13 + .../test_cannot_run_js/binding.gyp | 18 + .../js-native-api/test_cannot_run_js/test.js | 24 + .../test_cannot_run_js/test_cannot_run_js.c | 66 + .../test_constructor/CMakeLists.txt | 5 + .../test_constructor/binding.gyp | 11 + .../js-native-api/test_constructor/test.js | 62 + .../js-native-api/test_constructor/test2.js | 8 + .../test_constructor/test_constructor.c | 200 +++ .../test_constructor/test_null.c | 111 ++ .../test_constructor/test_null.h | 8 + .../test_constructor/test_null.js | 18 + .../test_conversions/CMakeLists.txt | 5 + .../test_conversions/binding.gyp | 11 + .../js-native-api/test_conversions/test.js | 218 +++ .../test_conversions/test_conversions.c | 158 ++ .../test_conversions/test_null.c | 102 ++ .../test_conversions/test_null.h | 8 + .../test_dataview/CMakeLists.txt | 4 + .../js-native-api/test_dataview/binding.gyp | 10 + .../test/js-native-api/test_dataview/test.js | 24 + .../test_dataview/test_dataview.c | 102 ++ .../js-native-api/test_date/CMakeLists.txt | 4 + .../test/js-native-api/test_date/binding.gyp | 10 + .../test/js-native-api/test_date/test.js | 21 + .../test/js-native-api/test_date/test_date.c | 64 + .../js-native-api/test_error/CMakeLists.txt | 6 + .../test/js-native-api/test_error/binding.gyp | 10 + .../test/js-native-api/test_error/test.js | 148 ++ .../js-native-api/test_error/test_error.c | 197 +++ .../test_exception/CMakeLists.txt | 4 + .../js-native-api/test_exception/binding.gyp | 10 + .../test/js-native-api/test_exception/test.js | 115 ++ .../test_exception/testFinalizerException.js | 31 + .../test_exception/test_exception.c | 116 ++ .../test_finalizer/CMakeLists.txt | 7 + .../js-native-api/test_finalizer/binding.gyp | 11 + .../test/js-native-api/test_finalizer/test.js | 45 + .../test_finalizer/test_fatal_finalize.js | 35 + .../test_finalizer/test_finalizer.c | 148 ++ .../test_function/CMakeLists.txt | 4 + .../js-native-api/test_function/binding.gyp | 10 + .../test/js-native-api/test_function/test.js | 52 + .../test_function/test_function.c | 204 +++ .../js-native-api/test_general/CMakeLists.txt | 4 + .../js-native-api/test_general/binding.gyp | 10 + .../test/js-native-api/test_general/test.js | 97 ++ .../test_general/testEnvCleanup.js | 57 + .../test_general/testFinalizer.js | 38 + .../js-native-api/test_general/testGlobals.js | 8 + .../test_general/testInstanceOf.js | 46 + .../js-native-api/test_general/testNapiRun.js | 14 + .../test_general/testNapiStatus.js | 8 + .../test_general/testV8Instanceof.js | 121 ++ .../test_general/testV8Instanceof2.js | 341 +++++ .../js-native-api/test_general/test_general.c | 315 ++++ .../test_handle_scope/CMakeLists.txt | 4 + .../test_handle_scope/binding.gyp | 10 + .../js-native-api/test_handle_scope/test.js | 19 + .../test_handle_scope/test_handle_scope.c | 86 ++ .../test_instance_data/CMakeLists.txt | 4 + .../test_instance_data/binding.gyp | 10 + .../js-native-api/test_instance_data/test.js | 41 + .../test_instance_data/test_instance_data.c | 96 ++ .../test_new_target/CMakeLists.txt | 4 + .../js-native-api/test_new_target/binding.gyp | 11 + .../js-native-api/test_new_target/test.js | 21 + .../test_new_target/test_new_target.c | 92 ++ .../js-native-api/test_number/CMakeLists.txt | 5 + .../js-native-api/test_number/binding.gyp | 11 + .../test/js-native-api/test_number/test.js | 134 ++ .../js-native-api/test_number/test_null.c | 77 + .../js-native-api/test_number/test_null.h | 8 + .../js-native-api/test_number/test_null.js | 18 + .../js-native-api/test_number/test_number.c | 110 ++ .../js-native-api/test_object/CMakeLists.txt | 10 + .../js-native-api/test_object/binding.gyp | 17 + .../test/js-native-api/test_object/test.js | 393 +++++ .../test_object/test_exceptions.c | 82 + .../test_object/test_exceptions.js | 18 + .../js-native-api/test_object/test_null.c | 400 +++++ .../js-native-api/test_object/test_null.h | 8 + .../js-native-api/test_object/test_null.js | 53 + .../js-native-api/test_object/test_object.c | 755 ++++++++++ .../js-native-api/test_promise/CMakeLists.txt | 4 + .../js-native-api/test_promise/binding.gyp | 10 + .../test/js-native-api/test_promise/test.js | 61 + .../js-native-api/test_promise/test_promise.c | 64 + .../test_properties/CMakeLists.txt | 6 + .../js-native-api/test_properties/binding.gyp | 10 + .../js-native-api/test_properties/test.js | 69 + .../test_properties/test_properties.c | 113 ++ .../test_reference/CMakeLists.txt | 11 + .../js-native-api/test_reference/binding.gyp | 16 + .../test/js-native-api/test_reference/test.js | 158 ++ .../test_reference/test_finalizer.c | 79 + .../test_reference/test_finalizer.js | 24 + .../test_reference/test_reference.c | 252 ++++ .../test_reference_double_free/CMakeLists.txt | 4 + .../test_reference_double_free/binding.gyp | 10 + .../test_reference_double_free/test.js | 11 + .../test_reference_double_free.c | 90 ++ .../test_reference_double_free/test_wrap.js | 10 + .../js-native-api/test_string/CMakeLists.txt | 7 + .../js-native-api/test_string/binding.gyp | 14 + .../test/js-native-api/test_string/test.js | 91 ++ .../js-native-api/test_string/test_null.c | 71 + .../js-native-api/test_string/test_null.h | 8 + .../js-native-api/test_string/test_null.js | 17 + .../js-native-api/test_string/test_string.c | 498 +++++++ .../js-native-api/test_symbol/CMakeLists.txt | 4 + .../js-native-api/test_symbol/binding.gyp | 10 + .../test/js-native-api/test_symbol/test1.js | 19 + .../test/js-native-api/test_symbol/test2.js | 17 + .../test/js-native-api/test_symbol/test3.js | 19 + .../js-native-api/test_symbol/test_symbol.c | 38 + .../test_typedarray/CMakeLists.txt | 4 + .../js-native-api/test_typedarray/binding.gyp | 10 + .../js-native-api/test_typedarray/test.js | 109 ++ .../test_typedarray/test_typedarray.c | 249 ++++ Tests/NodeApi/test/package.json | 14 + Tests/NodeApi/test/yarn.lock | 1326 +++++++++++++++++ Tests/NodeApi/test_basics.cpp | 80 + Tests/NodeApi/test_main.cpp | 201 +++ Tests/NodeApi/test_main.h | 23 + 208 files changed, 15531 insertions(+) create mode 100644 Tests/NodeApi/.clang-format create mode 100644 Tests/NodeApi/CMakeLists.txt create mode 100644 Tests/NodeApi/child_process.cpp create mode 100644 Tests/NodeApi/child_process.h create mode 100644 Tests/NodeApi/child_process_mac.cpp create mode 100644 Tests/NodeApi/compat.h create mode 100644 Tests/NodeApi/include/node_api.h create mode 100644 Tests/NodeApi/include/node_api_types.h create mode 100644 Tests/NodeApi/js_runtime_api.cpp create mode 100644 Tests/NodeApi/js_runtime_api.h create mode 100644 Tests/NodeApi/node_lite.cpp create mode 100644 Tests/NodeApi/node_lite.h create mode 100644 Tests/NodeApi/node_lite_jsruntimehost.cpp create mode 100644 Tests/NodeApi/node_lite_mac.cpp create mode 100644 Tests/NodeApi/node_lite_windows.cpp create mode 100644 Tests/NodeApi/string_utils.cpp create mode 100644 Tests/NodeApi/string_utils.h create mode 100644 Tests/NodeApi/test/.clang-format create mode 100644 Tests/NodeApi/test/CMakeLists.txt create mode 100644 Tests/NodeApi/test/babel.config.js create mode 100644 Tests/NodeApi/test/basics/async_rejected.js create mode 100644 Tests/NodeApi/test/basics/async_resolved.js create mode 100644 Tests/NodeApi/test/basics/hello.js create mode 100644 Tests/NodeApi/test/basics/mustcall_failure.js create mode 100644 Tests/NodeApi/test/basics/mustcall_success.js create mode 100644 Tests/NodeApi/test/basics/mustnotcall_failure.js create mode 100644 Tests/NodeApi/test/basics/mustnotcall_success.js create mode 100644 Tests/NodeApi/test/basics/throw_string.js create mode 100644 Tests/NodeApi/test/common/assert.js create mode 100644 Tests/NodeApi/test/common/gc.js create mode 100644 Tests/NodeApi/test/common/index.js create mode 100644 Tests/NodeApi/test/js-native-api/.gitignore create mode 100644 Tests/NodeApi/test/js-native-api/2_function_arguments/2_function_arguments.c create mode 100644 Tests/NodeApi/test/js-native-api/2_function_arguments/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/2_function_arguments/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/2_function_arguments/test.js create mode 100644 Tests/NodeApi/test/js-native-api/3_callbacks/3_callbacks.c create mode 100644 Tests/NodeApi/test/js-native-api/3_callbacks/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/3_callbacks/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/3_callbacks/test.js create mode 100644 Tests/NodeApi/test/js-native-api/4_object_factory/4_object_factory.c create mode 100644 Tests/NodeApi/test/js-native-api/4_object_factory/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/4_object_factory/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/4_object_factory/test.js create mode 100644 Tests/NodeApi/test/js-native-api/5_function_factory/5_function_factory.c create mode 100644 Tests/NodeApi/test/js-native-api/5_function_factory/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/5_function_factory/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/5_function_factory/test.js create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.cc create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.h create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.cc create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.h create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.js create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/test-basic-finalizer.js create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/test-object-wrap-ref.js create mode 100644 Tests/NodeApi/test/js-native-api/6_object_wrap/test.js create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/7_factory_wrap.cc create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.cc create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.h create mode 100644 Tests/NodeApi/test/js-native-api/7_factory_wrap/test.js create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.cc create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.h create mode 100644 Tests/NodeApi/test/js-native-api/8_passing_wrapped/test.js create mode 100644 Tests/NodeApi/test/js-native-api/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/common-inl.h create mode 100644 Tests/NodeApi/test/js-native-api/common.h create mode 100644 Tests/NodeApi/test/js-native-api/entry_point.h create mode 100644 Tests/NodeApi/test/js-native-api/test_array/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_array/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_array/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_array/test_array.c create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint/test_bigint.c create mode 100644 Tests/NodeApi/test/js-native-api/test_cannot_run_js/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_cannot_run_js/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_cannot_run_js/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test2.js create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test_constructor.c create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test_null.c create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test_null.h create mode 100644 Tests/NodeApi/test/js-native-api/test_constructor/test_null.js create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/test_conversions.c create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/test_null.c create mode 100644 Tests/NodeApi/test/js-native-api/test_conversions/test_null.h create mode 100644 Tests/NodeApi/test/js-native-api/test_dataview/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_dataview/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_dataview/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_dataview/test_dataview.c create mode 100644 Tests/NodeApi/test/js-native-api/test_date/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_date/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_date/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_date/test_date.c create mode 100644 Tests/NodeApi/test/js-native-api/test_error/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_error/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_error/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_error/test_error.c create mode 100644 Tests/NodeApi/test/js-native-api/test_exception/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_exception/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_exception/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_exception/testFinalizerException.js create mode 100644 Tests/NodeApi/test/js-native-api/test_exception/test_exception.c create mode 100644 Tests/NodeApi/test/js-native-api/test_finalizer/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_finalizer/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_finalizer/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_finalizer/test_fatal_finalize.js create mode 100644 Tests/NodeApi/test/js-native-api/test_finalizer/test_finalizer.c create mode 100644 Tests/NodeApi/test/js-native-api/test_function/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_function/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_function/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_function/test_function.c create mode 100644 Tests/NodeApi/test/js-native-api/test_general/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_general/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_general/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testEnvCleanup.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testFinalizer.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testGlobals.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testInstanceOf.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testNapiRun.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testNapiStatus.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof2.js create mode 100644 Tests/NodeApi/test/js-native-api/test_general/test_general.c create mode 100644 Tests/NodeApi/test/js-native-api/test_handle_scope/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_handle_scope/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_handle_scope/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_handle_scope/test_handle_scope.c create mode 100644 Tests/NodeApi/test/js-native-api/test_instance_data/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_instance_data/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_instance_data/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_instance_data/test_instance_data.c create mode 100644 Tests/NodeApi/test/js-native-api/test_new_target/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_new_target/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_new_target/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_new_target/test_new_target.c create mode 100644 Tests/NodeApi/test/js-native-api/test_number/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_number/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_number/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_number/test_null.c create mode 100644 Tests/NodeApi/test/js-native-api/test_number/test_null.h create mode 100644 Tests/NodeApi/test/js-native-api/test_number/test_null.js create mode 100644 Tests/NodeApi/test/js-native-api/test_number/test_number.c create mode 100644 Tests/NodeApi/test/js-native-api/test_object/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_object/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_exceptions.c create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_exceptions.js create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_null.c create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_null.h create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_null.js create mode 100644 Tests/NodeApi/test/js-native-api/test_object/test_object.c create mode 100644 Tests/NodeApi/test/js-native-api/test_promise/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_promise/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_promise/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_promise/test_promise.c create mode 100644 Tests/NodeApi/test/js-native-api/test_properties/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_properties/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_properties/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_properties/test_properties.c create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.c create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.js create mode 100644 Tests/NodeApi/test/js-native-api/test_reference/test_reference.c create mode 100644 Tests/NodeApi/test/js-native-api/test_reference_double_free/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_reference_double_free/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_reference_double_free/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_reference_double_free/test_reference_double_free.c create mode 100644 Tests/NodeApi/test/js-native-api/test_reference_double_free/test_wrap.js create mode 100644 Tests/NodeApi/test/js-native-api/test_string/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_string/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_string/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_string/test_null.c create mode 100644 Tests/NodeApi/test/js-native-api/test_string/test_null.h create mode 100644 Tests/NodeApi/test/js-native-api/test_string/test_null.js create mode 100644 Tests/NodeApi/test/js-native-api/test_string/test_string.c create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/test1.js create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/test2.js create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/test3.js create mode 100644 Tests/NodeApi/test/js-native-api/test_symbol/test_symbol.c create mode 100644 Tests/NodeApi/test/js-native-api/test_typedarray/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_typedarray/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_typedarray/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_typedarray/test_typedarray.c create mode 100644 Tests/NodeApi/test/package.json create mode 100644 Tests/NodeApi/test/yarn.lock create mode 100644 Tests/NodeApi/test_basics.cpp create mode 100644 Tests/NodeApi/test_main.cpp create mode 100644 Tests/NodeApi/test_main.h diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index 2cb5d26c..a7efe8f4 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -1,2 +1,3 @@ add_subdirectory(UnitTests) +add_subdirectory(NodeApi) npm(install --silent) diff --git a/Tests/NodeApi/.clang-format b/Tests/NodeApi/.clang-format new file mode 100644 index 00000000..b3fd9613 --- /dev/null +++ b/Tests/NodeApi/.clang-format @@ -0,0 +1,111 @@ +--- +Language: Cpp +# BasedOnStyle: Google +AccessModifierOffset: -1 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortIfStatementsOnASingleLine: true +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: true +BinPackArguments: false +BinPackParameters: false +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^' + Priority: 2 + - Regex: '^<.*\.h>' + Priority: 1 + - Regex: '^<.*' + Priority: 2 + - Regex: '.*' + Priority: 3 +IncludeIsMainRegex: '([-_](test|unittest))?$' +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 2 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Auto +TabWidth: 8 +UseTab: Never diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt new file mode 100644 index 00000000..48c5b5a8 --- /dev/null +++ b/Tests/NodeApi/CMakeLists.txt @@ -0,0 +1,175 @@ +set(NODE_API_TEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR}) + +option(JSR_NODE_API_BUILD_NATIVE_TESTS "Build Node-API native addon test modules" OFF) + +if(JSR_NODE_API_BUILD_NATIVE_TESTS) + set(JSR_NODE_API_NATIVE_TEST_DIRS + 2_function_arguments + 3_callbacks + 4_object_factory + 5_function_factory + ) +endif() + +function(node_api_copy_test_sources TARGET_NAME) + add_custom_command(TARGET ${TARGET_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${NODE_API_TEST_ROOT}/test + $/test + COMMENT "Copying Node-API test assets for ${TARGET_NAME}" + ) +endfunction() + +if(APPLE) + set(NODE_LITE_PLATFORM_SRC node_lite_mac.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_mac.cpp) +elseif(WIN32) + set(NODE_LITE_PLATFORM_SRC node_lite_windows.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process.cpp) +else() + set(NODE_LITE_PLATFORM_SRC node_lite_mac.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_mac.cpp) + message(WARNING "Node-API node_lite platform not yet customized for ${CMAKE_SYSTEM_NAME}; using POSIX defaults.") +endif() + +add_executable(node_lite + ${NODE_LITE_CHILD_PROCESS_SRC} + child_process.h + compat.h + js_runtime_api.cpp + js_runtime_api.h + node_lite.cpp + node_lite.h + node_lite_jsruntimehost.cpp + ${NODE_LITE_PLATFORM_SRC} + string_utils.cpp + string_utils.h +) + +target_include_directories(node_lite + PRIVATE + ${NODE_API_TEST_ROOT} + ${NODE_API_TEST_ROOT}/include + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} + ${CMAKE_SOURCE_DIR}/Core/Node-API/Source +) + +target_compile_definitions(node_lite + PRIVATE + NODE_API_EXPERIMENTAL_NO_WARNING +) + +target_link_libraries(node_lite + PRIVATE + napi +) + +node_api_copy_test_sources(node_lite) + +add_executable(NodeApiTests + ${NODE_LITE_CHILD_PROCESS_SRC} + child_process.h + string_utils.cpp + string_utils.h + test_basics.cpp + test_main.cpp + test_main.h +) + +target_include_directories(NodeApiTests + PRIVATE + ${NODE_API_TEST_ROOT} + ${NODE_API_TEST_ROOT}/include +) + +target_link_libraries(NodeApiTests + PRIVATE + gtest_main +) + +node_api_copy_test_sources(NodeApiTests) + +add_dependencies(NodeApiTests node_lite) + +add_custom_target(NodeApiModules) + +if(JSR_NODE_API_BUILD_NATIVE_TESTS) + list(JOIN JSR_NODE_API_NATIVE_TEST_DIRS "," NODE_API_NATIVE_TESTS_STRING) + target_compile_definitions(node_lite + PRIVATE + NODE_API_TESTS_HAVE_NATIVE_MODULES=1 + NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" + ) + target_compile_definitions(NodeApiTests + PRIVATE + NODE_API_TESTS_HAVE_NATIVE_MODULES=1 + NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" + ) +endif() + +function(add_node_api_module MODULE_TARGET) + cmake_parse_arguments(PARSE_ARGV 0 ARG "" "" "SOURCES;DEFINES") + + get_filename_component(FOLDER_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) + + if(NOT "${MODULE_TARGET}" STREQUAL "${FOLDER_NAME}") + set(MODULE_TARGET "${FOLDER_NAME}_${MODULE_TARGET}") + endif() + + add_library(${MODULE_TARGET} MODULE) + target_sources(${MODULE_TARGET} PRIVATE ${ARG_SOURCES}) + target_include_directories(${MODULE_TARGET} + PRIVATE + ${NODE_API_TEST_ROOT}/include + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared/napi + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} + ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE}/napi + ) + + target_compile_definitions(${MODULE_TARGET} + PRIVATE + NODE_API_EXPERIMENTAL_NO_WARNING + NODE_GYP_MODULE_NAME=\"${FOLDER_NAME}\" + ${ARG_DEFINES} + ) + + if(APPLE) + target_link_options(${MODULE_TARGET} + PRIVATE + "-undefined" "dynamic_lookup" + ) + endif() + + set(MODULE_OUTPUT_DIR + ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "" + SUFFIX ".node" + ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + ) + + add_dependencies(NodeApiModules ${MODULE_TARGET}) + + add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" + ) +endfunction() + +add_dependencies(NodeApiTests NodeApiModules) + +add_subdirectory(test) diff --git a/Tests/NodeApi/child_process.cpp b/Tests/NodeApi/child_process.cpp new file mode 100644 index 00000000..2fd22cd8 --- /dev/null +++ b/Tests/NodeApi/child_process.cpp @@ -0,0 +1,192 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// Windows-specific implementation of the `spawnSync` function for creating +// child processes and capturing their output. This code is designed to work +// with the Windows API and is not portable to other platforms. It uses pipes +// to redirect the standard output and error streams of the child process back +// to the parent process, allowing the parent to read the output and error +// messages generated by the child process. +// +// The `spawnSync` function takes a command and a list of arguments, creates a +// child process to execute the command, and returns a `ProcessResult` structure +// containing the exit status and the captured output and error messages. +// + +#include "child_process.h" + +#include +#include +#include +#include +#include "string_utils.h" + +#ifndef VerifyElseExit +#define VerifyElseExit(condition) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition); \ + } \ + } while (false) +#endif + +namespace node_api_tests { + +namespace { + +std::string ReadFromPipe(HANDLE pipeHandle); +void ExitOnError(const char* message); + +struct AutoHandle { + HANDLE handle{NULL}; + + AutoHandle() = default; + AutoHandle(HANDLE handle) : handle(handle) {} + ~AutoHandle() { ::CloseHandle(handle); } + + AutoHandle(const AutoHandle&) = delete; + AutoHandle& operator=(const AutoHandle&) = delete; + + void Close() { + ::CloseHandle(handle); + handle = NULL; + } +}; +} // namespace + +// Create a child process that uses the previously created pipes for STDIN and +// STDOUT. +ProcessResult SpawnSync(std::string_view command, + std::vector args) { + ProcessResult result{}; + + // Set the bInheritHandle flag so pipe handles are inherited. + + SECURITY_ATTRIBUTES handles_are_inheritable = { + sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE}; + + AutoHandle out_read_handle, out_write_handle; + VerifyElseExit(CreatePipe(&out_read_handle.handle, + &out_write_handle.handle, + &handles_are_inheritable, + 0)); + // Ensure the read handle to the pipe for STDOUT is not inherited. + VerifyElseExit( + SetHandleInformation(out_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); + + AutoHandle err_read_handle, err_write_handle; + VerifyElseExit(CreatePipe(&err_read_handle.handle, + &err_write_handle.handle, + &handles_are_inheritable, + 0)); + // Ensure the read handle to the pipe for STDERR is not inherited. + VerifyElseExit( + SetHandleInformation(err_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); + + // Set up members of the STARTUPINFO structure. + // This structure specifies the STDIN and STDOUT handles for redirection. + STARTUPINFOA startup_info{}; + startup_info.cb = sizeof(STARTUPINFOA); + startup_info.dwFlags |= STARTF_USESTDHANDLES; + startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); + startup_info.hStdOutput = out_write_handle.handle; + startup_info.hStdError = err_write_handle.handle; + + // Create the child process. + + std::string commandLine = std::string(command); + for (std::string& arg : args) { + commandLine += " " + arg; + } + PROCESS_INFORMATION process_info{}; + VerifyElseExit( + CreateProcessA(nullptr, + const_cast(commandLine.c_str()), // command line + nullptr, // process security attributes + nullptr, // primary thread security attributes + TRUE, // handles are inherited + CREATE_DEFAULT_ERROR_MODE, // creation flags + nullptr, // use parent's environment + nullptr, // use parent's current directory + &startup_info, // STARTUPINFO pointer + &process_info)); // receives PROCESS_INFORMATION + + VerifyElseExit(WAIT_OBJECT_0 == + ::WaitForSingleObject(process_info.hProcess, INFINITE)); + + DWORD exit_code; + VerifyElseExit(::GetExitCodeProcess(process_info.hProcess, &exit_code)); + + // Close handles to the child process and its primary thread. + // Some applications might keep these handles to monitor the status + // of the child process, for example. + ::CloseHandle(process_info.hProcess); + ::CloseHandle(process_info.hThread); + + // Close handles to the stdin and stdout pipes no longer needed by the child + // process. If they are not explicitly closed, there is no way to recognize + // that the child process has ended. + + out_write_handle.Close(); + err_write_handle.Close(); + + result.status = exit_code; + result.std_output = + ReplaceAll(ReadFromPipe(out_read_handle.handle), "\r\n", "\n"); + result.std_error = + ReplaceAll(ReadFromPipe(err_read_handle.handle), "\r\n", "\n"); + + return result; +} + +namespace { +std::string ReadFromPipe(HANDLE pipeHandle) { + std::string result; + constexpr size_t bufferSize = 4096; + char buffer[bufferSize]; + + for (;;) { + DWORD bytesRead; + BOOL isSuccess = + ::ReadFile(pipeHandle, buffer, bufferSize, &bytesRead, nullptr); + if (!isSuccess || bytesRead == 0) break; + + result.append(buffer, bytesRead); + } + + return result; +} + +// Format a readable error message, display a message box, +// and exit from the application. +void ExitOnError(const char* message) { + LPVOID lpMsgBuf; + LPVOID lpDisplayBuf; + DWORD dw = GetLastError(); + + ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + nullptr, + dw, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPSTR)&lpMsgBuf, + 0, + nullptr); + + lpDisplayBuf = (LPVOID)LocalAlloc( + LMEM_ZEROINIT, (lstrlenA((LPCSTR)lpMsgBuf) + lstrlenA(message) + 40)); + ::StringCchPrintfA((LPSTR)lpDisplayBuf, + LocalSize(lpDisplayBuf), + "%s failed with error %d: %s", + message, + dw, + lpMsgBuf); + fprintf(stderr, "%s\n", (const char*)lpDisplayBuf); + + ::LocalFree(lpMsgBuf); + ::LocalFree(lpDisplayBuf); + ::ExitProcess(1); +} + +} // namespace +} // namespace node_api_tests \ No newline at end of file diff --git a/Tests/NodeApi/child_process.h b/Tests/NodeApi/child_process.h new file mode 100644 index 00000000..aed58908 --- /dev/null +++ b/Tests/NodeApi/child_process.h @@ -0,0 +1,27 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#ifndef NODE_API_TEST_CHILD_PROCESS_H +#define NODE_API_TEST_CHILD_PROCESS_H + +#include +#include +#include + +namespace node_api_tests { + +// Struct to hold the result of a child process execution. +struct ProcessResult { + uint32_t status; // Exit status of the child process. + std::string std_output; // Standard output from the child process. + std::string std_error; // Standard error from the child process. +}; + +// Creates a child process to run the given command with the specified +// arguments. +ProcessResult SpawnSync(std::string_view command, + std::vector args); + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_CHILD_PROCESS_H \ No newline at end of file diff --git a/Tests/NodeApi/child_process_mac.cpp b/Tests/NodeApi/child_process_mac.cpp new file mode 100644 index 00000000..8e5f0d18 --- /dev/null +++ b/Tests/NodeApi/child_process_mac.cpp @@ -0,0 +1,166 @@ +#include "child_process.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Verify the condition. +// - If true, resume execution. +// - If false, print a message to stderr and exit the app with exit code 1. +#ifndef VerifyElseExit +#define VerifyElseExit(condition) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition, nullptr); \ + } \ + } while (false) +#endif + +// Verify the condition. +// - If true, resume execution. +// - If false, destroy the passed `posix_spawn_file_actions_t* actions`, then +// print a message to stderr and exit the app with exit code 1. +#ifndef VerifyElseExitWithCleanup +#define VerifyElseExitWithCleanup(condition, actions_ptr) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition, actions_ptr); \ + } \ + } while (false) +#endif + +extern char** environ; + +namespace node_api_tests { + +namespace { + +std::string ReadFromFd(int fd); +void ExitOnError(const char* message, posix_spawn_file_actions_t* actions); + +} // namespace + +ProcessResult SpawnSync(std::string_view command, + std::vector args) { + ProcessResult result{}; + + // These int arrays each comprise two file descriptors: { readEnd, writeEnd }. + int stdout_pipe[2], stderr_pipe[2]; + VerifyElseExit(pipe(stdout_pipe) == 0); + VerifyElseExit(pipe(stderr_pipe) == 0); + + posix_spawn_file_actions_t actions; + VerifyElseExit(posix_spawn_file_actions_init(&actions) == 0); + + VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( + &actions, stdout_pipe[1], STDOUT_FILENO) == 0, + &actions); + VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( + &actions, stderr_pipe[1], STDERR_FILENO) == 0, + &actions); + + VerifyElseExitWithCleanup( + posix_spawn_file_actions_addclose(&actions, stdout_pipe[0]) == 0, + &actions); + VerifyElseExitWithCleanup( + posix_spawn_file_actions_addclose(&actions, stderr_pipe[0]) == 0, + &actions); + + std::vector argv; + argv.push_back(strdup(std::string(command).c_str())); + for (const std::string& arg : args) { + argv.push_back(strdup(arg.c_str())); + } + argv.push_back(nullptr); + + pid_t pid; + VerifyElseExitWithCleanup( + posix_spawnp(&pid, argv[0], &actions, nullptr, argv.data(), environ) == 0, + &actions); + + posix_spawn_file_actions_destroy(&actions); + + // Close the write ends of the pipes. + close(stdout_pipe[1]); + close(stderr_pipe[1]); + + int wait_status; + pid_t waited_pid; + do { + waited_pid = waitpid(pid, &wait_status, 0); + } while (waited_pid == -1 && errno == EINTR); + + VerifyElseExit(waited_pid == pid); + + if (WIFEXITED(wait_status)) { + result.status = WEXITSTATUS(wait_status); + } else if (WIFSIGNALED(wait_status)) { + result.status = 128 + WTERMSIG(wait_status); + } else { + result.status = 1; + } + result.std_output = ReadFromFd(stdout_pipe[0]); + result.std_error = ReadFromFd(stderr_pipe[0]); + + // Close the read ends of the pipes. + close(stdout_pipe[0]); + close(stderr_pipe[0]); + + for (char* arg : argv) { + free(arg); + } + + return result; +} + +namespace { + +std::string ReadFromFd(int fd) { + std::string result; + constexpr size_t bufferSize = 4096; + char buffer[bufferSize]; + ssize_t bytesRead; + while (true) { + bytesRead = read(fd, buffer, bufferSize); + if (bytesRead > 0) { + result.append(buffer, bytesRead); + continue; + } + + if (bytesRead == 0) { + break; + } + + if (errno == EINTR) { + continue; + } + + ExitOnError("read", nullptr); + } + return result; +} + +// Format a readable error message, print it to console, and exit from the +// application. +void ExitOnError(const char* message, posix_spawn_file_actions_t* actions) { + int err = errno; + const char* err_msg = strerror(err); + + fprintf(stderr, "%s failed with error %d: %s\n", message, err, err_msg); + + if (actions != nullptr) { + posix_spawn_file_actions_destroy(actions); + } + + exit(1); +} + +} // namespace +} // namespace node_api_tests diff --git a/Tests/NodeApi/compat.h b/Tests/NodeApi/compat.h new file mode 100644 index 00000000..7974b34c --- /dev/null +++ b/Tests/NodeApi/compat.h @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#ifndef SRC_PUBLIC_COMPAT_H_ +#define SRC_PUBLIC_COMPAT_H_ + +// This file contains some useful datatypes recently introduced in C++17 and +// C++20. They must be removed after we switch the toolset to the newer C++ +// language version. + +#include +#ifdef __cpp_lib_span +#include +#endif + +namespace node_api_tests { + +#ifdef __cpp_lib_span +using std::span; +#else +/** + * @brief A span of values that can be used to pass arguments to function. + * + * For C++20 we should consider to replace it with std::span. + */ +template +struct span { + constexpr span(std::initializer_list il) noexcept + : data_{const_cast(il.begin())}, size_{il.size()} {} + constexpr span(T* data, size_t size) noexcept : data_{data}, size_{size} {} + + [[nodiscard]] constexpr T* data() const noexcept { return data_; } + + [[nodiscard]] constexpr size_t size() const noexcept { return size_; } + + [[nodiscard]] constexpr T* begin() const noexcept { return data_; } + + [[nodiscard]] constexpr T* end() const noexcept { return data_ + size_; } + + const T& operator[](size_t index) const noexcept { return *(data_ + index); } + + private: + T* data_; + size_t size_; +}; +#endif // __cpp_lib_span + +} // namespace node_api_tests + +#endif // SRC_PUBLIC_COMPAT_H_ diff --git a/Tests/NodeApi/include/node_api.h b/Tests/NodeApi/include/node_api.h new file mode 100644 index 00000000..0ba4bc6e --- /dev/null +++ b/Tests/NodeApi/include/node_api.h @@ -0,0 +1,67 @@ +#ifndef NODE_API_H_ +#define NODE_API_H_ + +#include +#include "node_api_types.h" + +#ifdef __cplusplus +#define NODE_API_EXTERN_C_START extern "C" { +#define NODE_API_EXTERN_C_END } +#else +#define NODE_API_EXTERN_C_START +#define NODE_API_EXTERN_C_END +#endif + +#ifdef _WIN32 +#define NAPI_MODULE_EXPORT __declspec(dllexport) +#else +#define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) +#endif + +#ifndef NAPI_MODULE_VERSION +#define NAPI_MODULE_VERSION 1 +#endif + +typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env, + napi_value exports); + +typedef struct napi_module_s { + int nm_version; + unsigned int nm_flags; + const char* nm_filename; + napi_addon_register_func nm_register_func; + const char* nm_modname; + void* nm_priv; + void* reserved[4]; +} napi_module; + +#define NODE_API_MODULE_GET_API_VERSION_FUNCTION node_api_module_get_api_version_v1 +#define NODE_API_MODULE_REGISTER_FUNCTION napi_register_module_v1 + +#define NAPI_MODULE_INIT() \ + NODE_API_EXTERN_C_START \ + NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION_FUNCTION(void) {\ + return NAPI_VERSION; \ + } \ + NAPI_MODULE_EXPORT napi_value NODE_API_MODULE_REGISTER_FUNCTION( \ + napi_env env, napi_value exports); \ + NODE_API_EXTERN_C_END \ + static napi_value napi_module_init_impl(napi_env env, napi_value exports); \ + NODE_API_EXTERN_C_START \ + NAPI_MODULE_EXPORT napi_value NODE_API_MODULE_REGISTER_FUNCTION( \ + napi_env env, napi_value exports) { \ + return napi_module_init_impl(env, exports); \ + } \ + NODE_API_EXTERN_C_END \ + static napi_value napi_module_init_impl(napi_env env, napi_value exports) + +#define NAPI_MODULE(modname, regfunc) \ + NAPI_MODULE_INIT() { \ + (void)(modname); \ + return regfunc(env, exports); \ + } + +#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ + NAPI_MODULE(modname, regfunc) + +#endif // NODE_API_H_ diff --git a/Tests/NodeApi/include/node_api_types.h b/Tests/NodeApi/include/node_api_types.h new file mode 100644 index 00000000..97a2fb22 --- /dev/null +++ b/Tests/NodeApi/include/node_api_types.h @@ -0,0 +1,24 @@ +#ifndef NODE_API_TYPES_H_ +#define NODE_API_TYPES_H_ + +#include + +typedef struct napi_callback_scope__* napi_callback_scope; +typedef struct napi_async_context__* napi_async_context; +typedef struct napi_async_work__* napi_async_work; + +typedef void(NAPI_CDECL* napi_async_execute_callback)(napi_env env, + void* data); +typedef void(NAPI_CDECL* napi_async_complete_callback)(napi_env env, + napi_status status, + void* data); + +typedef struct { + uint32_t major; + uint32_t minor; + uint32_t patch; + const char* release; +} napi_node_version; + +#endif // NODE_API_TYPES_H_ + diff --git a/Tests/NodeApi/js_runtime_api.cpp b/Tests/NodeApi/js_runtime_api.cpp new file mode 100644 index 00000000..c03740ac --- /dev/null +++ b/Tests/NodeApi/js_runtime_api.cpp @@ -0,0 +1,112 @@ +#include "js_runtime_api.h" + +#include +#include + +#if defined(__APPLE__) +#include +#include "js_native_api_javascriptcore.h" +#elif defined(__ANDROID__) +#include +#include "js_native_api_v8.h" +#endif + +struct jsr_napi_env_scope_s { + napi_env env{nullptr}; +}; + +napi_status jsr_open_napi_env_scope(napi_env env, + jsr_napi_env_scope* scope) { + if (scope == nullptr) { + return napi_invalid_arg; + } + + auto* scope_impl = new jsr_napi_env_scope_s{}; + scope_impl->env = env; + *scope = scope_impl; + return napi_ok; +} + +napi_status jsr_close_napi_env_scope(napi_env /*env*/, + jsr_napi_env_scope scope) { + if (scope == nullptr) { + return napi_invalid_arg; + } + + delete scope; + return napi_ok; +} + +napi_status jsr_run_script(napi_env env, + napi_value source, + const char* source_url, + napi_value* result) { + return napi_run_script(env, source, source_url, result); +} + +napi_status jsr_collect_garbage(napi_env env) { +#if defined(__APPLE__) + if (env == nullptr) { + return napi_invalid_arg; + } + + JSGlobalContextRef context = env->context; + if (context == nullptr) { + return napi_invalid_arg; + } + + JSGarbageCollect(context); + return napi_ok; +#elif defined(__ANDROID__) + if (env == nullptr) { + return napi_invalid_arg; + } + + v8::Isolate* isolate = env->isolate; + if (isolate == nullptr) { + return napi_invalid_arg; + } + + isolate->RequestGarbageCollectionForTesting( + v8::Isolate::kFullGarbageCollection); + return napi_ok; +#else + (void)env; + return napi_generic_failure; +#endif +} + +napi_status jsr_initialize_native_module( + napi_env env, + napi_addon_register_func register_module, + int32_t /*api_version*/, + napi_value* exports) { + if (env == nullptr || register_module == nullptr || exports == nullptr) { + return napi_invalid_arg; + } + + napi_value module_exports{}; + napi_status status = napi_create_object(env, &module_exports); + if (status != napi_ok) { + return status; + } + + napi_value returned_exports = register_module(env, module_exports); + + bool has_exception = false; + status = napi_is_exception_pending(env, &has_exception); + if (status != napi_ok) { + return status; + } + + if (has_exception) { + return napi_pending_exception; + } + + if (returned_exports != nullptr && returned_exports != module_exports) { + module_exports = returned_exports; + } + + *exports = module_exports; + return napi_ok; +} diff --git a/Tests/NodeApi/js_runtime_api.h b/Tests/NodeApi/js_runtime_api.h new file mode 100644 index 00000000..27b39461 --- /dev/null +++ b/Tests/NodeApi/js_runtime_api.h @@ -0,0 +1,219 @@ +#ifndef HERMES_JS_RUNTIME_API_H +#define HERMES_JS_RUNTIME_API_H + +#include "node_api.h" + +// +// Node-API extensions required for JavaScript engine hosting. +// +// It is a very early version of the APIs which we consider to be experimental. +// These APIs are not stable yet and are subject to change while we continue +// their development. After some time we will stabilize the APIs and make them +// "officially stable". +// + +#define JSR_API NAPI_EXTERN napi_status NAPI_CDECL + +EXTERN_C_START + +typedef struct jsr_runtime_s *jsr_runtime; +typedef struct jsr_config_s *jsr_config; +typedef struct jsr_prepared_script_s *jsr_prepared_script; +typedef struct jsr_napi_env_scope_s *jsr_napi_env_scope; + +typedef void(NAPI_CDECL *jsr_data_delete_cb)(void *data, void *deleter_data); + +//============================================================================= +// jsr_runtime +//============================================================================= + +JSR_API jsr_create_runtime(jsr_config config, jsr_runtime *runtime); +JSR_API jsr_delete_runtime(jsr_runtime runtime); +JSR_API jsr_runtime_get_node_api_env(jsr_runtime runtime, napi_env *env); + +//============================================================================= +// jsr_config +//============================================================================= + +JSR_API jsr_create_config(jsr_config *config); +JSR_API jsr_delete_config(jsr_config config); + +JSR_API jsr_config_enable_inspector(jsr_config config, bool value); +JSR_API jsr_config_set_inspector_runtime_name( + jsr_config config, + const char *name); +JSR_API jsr_config_set_inspector_port(jsr_config config, uint16_t port); +JSR_API jsr_config_set_inspector_break_on_start(jsr_config config, bool value); + +JSR_API jsr_config_enable_gc_api(jsr_config config, bool value); + +JSR_API jsr_config_set_explicit_microtasks(jsr_config config, bool value); + +// A callback to process unhandled JS error +typedef void(NAPI_CDECL *jsr_unhandled_error_cb)( + void *cb_data, + napi_env env, + napi_value error); + +JSR_API jsr_config_on_unhandled_error( + jsr_config config, + void *cb_data, + jsr_unhandled_error_cb unhandled_error_cb); + +//============================================================================= +// jsr_config task runner +//============================================================================= + +// A callback to run task +typedef void(NAPI_CDECL *jsr_task_run_cb)(void *task_data); + +// A callback to post task to the task runner +typedef void(NAPI_CDECL *jsr_task_runner_post_task_cb)( + void *task_runner_data, + void *task_data, + jsr_task_run_cb task_run_cb, + jsr_data_delete_cb task_data_delete_cb, + void *deleter_data); + +JSR_API jsr_config_set_task_runner( + jsr_config config, + void *task_runner_data, + jsr_task_runner_post_task_cb task_runner_post_task_cb, + jsr_data_delete_cb task_runner_data_delete_cb, + void *deleter_data); + +//============================================================================= +// jsr_config script cache +//============================================================================= + +typedef void(NAPI_CDECL *jsr_script_cache_load_cb)( + void *script_cache_data, + const char *source_url, + uint64_t source_hash, + const char *runtime_name, + uint64_t runtime_version, + const char *cache_tag, + const uint8_t **buffer, + size_t *buffer_size, + jsr_data_delete_cb *buffer_delete_cb, + void **deleter_data); + +typedef void(NAPI_CDECL *jsr_script_cache_store_cb)( + void *script_cache_data, + const char *source_url, + uint64_t source_hash, + const char *runtime_name, + uint64_t runtime_version, + const char *cache_tag, + const uint8_t *buffer, + size_t buffer_size, + jsr_data_delete_cb buffer_delete_cb, + void *deleter_data); + +JSR_API jsr_config_set_script_cache( + jsr_config config, + void *script_cache_data, + jsr_script_cache_load_cb script_cache_load_cb, + jsr_script_cache_store_cb script_cache_store_cb, + jsr_data_delete_cb script_cache_data_delete_cb, + void *deleter_data); + +//============================================================================= +// napi_env scope +//============================================================================= + +// Opens the napi_env scope in the current thread. +// Calling Node-API functions without the opened scope may cause a failure. +// The scope must be closed by the jsr_close_napi_env_scope call. +JSR_API jsr_open_napi_env_scope(napi_env env, jsr_napi_env_scope *scope); + +// Closes the napi_env scope in the current thread. It must match to the +// jsr_open_napi_env_scope call. +JSR_API jsr_close_napi_env_scope(napi_env env, jsr_napi_env_scope scope); + +//============================================================================= +// Additional functions to implement JSI +//============================================================================= + +// To implement JSI description() +JSR_API jsr_get_description(napi_env env, const char **result); + +// To implement JSI queueMicrotask() +JSR_API jsr_queue_microtask(napi_env env, napi_value callback); + +// To implement JSI drainMicrotasks() +JSR_API +jsr_drain_microtasks(napi_env env, int32_t max_count_hint, bool *result); + +// To implement JSI isInspectable() +JSR_API jsr_is_inspectable(napi_env env, bool *result); + +//============================================================================= +// Script preparing and running. +// +// Script is usually converted to byte code, or in other words - prepared - for +// execution. Then, we can run the prepared script. +//============================================================================= + +// Run script with source URL. +JSR_API jsr_run_script( + napi_env env, + napi_value source, + const char *source_url, + napi_value *result); + +// Prepare the script for running. +JSR_API jsr_create_prepared_script( + napi_env env, + const uint8_t *script_data, + size_t script_length, + jsr_data_delete_cb script_delete_cb, + void *deleter_data, + const char *source_url, + jsr_prepared_script *result); + +// Delete the prepared script. +JSR_API jsr_delete_prepared_script( + napi_env env, + jsr_prepared_script prepared_script); + +// Run the prepared script. +JSR_API jsr_prepared_script_run( + napi_env env, + jsr_prepared_script prepared_script, + napi_value *result); + +//============================================================================= +// Functions to support unit tests. +//============================================================================= + +// Provides a hint to run garbage collection. +// It is typically used for unit tests. +// It requires enabling GC by calling jsr_config_enable_gc_api. +JSR_API jsr_collect_garbage(napi_env env); + +// Checks if the environment has an unhandled promise rejection. +JSR_API jsr_has_unhandled_promise_rejection(napi_env env, bool *result); + +// Gets and clears the last unhandled promise rejection. +JSR_API jsr_get_and_clear_last_unhandled_promise_rejection( + napi_env env, + napi_value *result); + +// Create new napi_env for the runtime. +JSR_API +jsr_create_node_api_env(napi_env root_env, int32_t api_version, napi_env *env); + +// Run task in the environment context. +JSR_API jsr_run_task(napi_env env, jsr_task_run_cb task_cb, void *data); + +// Initializes native module. +JSR_API jsr_initialize_native_module( + napi_env env, + napi_addon_register_func register_module, + int32_t api_version, + napi_value *exports); + +EXTERN_C_END + +#endif // HERMES_JS_RUNTIME_API_H \ No newline at end of file diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp new file mode 100644 index 00000000..5401d39c --- /dev/null +++ b/Tests/NodeApi/node_lite.cpp @@ -0,0 +1,1268 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "node_lite.h" +#include "js_runtime_api.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "child_process.h" + +namespace fs = std::filesystem; + +namespace node_api_tests { + +namespace { + +NodeApiRef MakeNodeApiRef(napi_env env, napi_value value) { + napi_ref ref{}; + NODE_LITE_CALL(napi_create_reference(env, value, 1, &ref)); + return NodeApiRef(ref, NodeApiRefDeleter(env)); +} + +template +void ThrowJSErrorOnException(napi_env env, TCallback&& callback) noexcept { + try { + callback(); + } catch (const NodeLiteException& e) { + if (e.error_status() == napi_pending_exception) { + napi_value error = NodeApi::GetAndClearLastException(env); + NodeApi::ThrowError(env, error); + } else { + NodeApi::ThrowError(env, e.what()); + } + } catch (const std::exception& e) { + NodeApi::ThrowError(env, e.what()); + } +} + +template +void ExitOnException(napi_env env, TCallback&& callback) noexcept { + try { + callback(); + } catch (const NodeLiteException& e) { + if (e.error_status() == napi_pending_exception) { + napi_value error = NodeApi::GetAndClearLastException(env); + NodeLiteErrorHandler::ExitWithJSError(env, error); + } else { + NodeLiteErrorHandler::ExitWithMessage(e.what()); + } + } catch (const std::exception& e) { + NodeLiteErrorHandler::ExitWithMessage(e.what()); + } +} + +std::string ReadFileText(napi_env env, fs::path file_path) { + std::ifstream file_stream(file_path.string()); + NODE_LITE_ASSERT(file_stream.is_open(), + "Failed to open file: %s. Error: %s", + file_path.c_str(), + std::strerror(errno)); + std::ostringstream ss; + ss << file_stream.rdbuf(); + return ss.str(); +} + +class NodeApiCallbackInfo { + public: + NodeApiCallbackInfo(napi_env env, napi_callback_info info) { + size_t argc{inline_args_.size()}; + napi_value* argv = inline_args_.data(); + NODE_LITE_CALL( + napi_get_cb_info(env, info, &argc, argv, &this_arg_, &data_)); + if (argc > inline_args_.size()) { + dynamic_args_ = std::make_unique(argc); + argv = dynamic_args_.get(); + NODE_LITE_CALL( + napi_get_cb_info(env, info, &argc, argv, &this_arg_, &data_)); + } + args_ = span(argv, argc); + } + + span args() const { return args_; } + napi_value this_arg() const { return this_arg_; } + void* data() const { return data_; } + + private: + std::array inline_args_{}; + std::unique_ptr dynamic_args_{}; + span args_{}; + napi_value this_arg_{}; + void* data_{}; +}; + +} // namespace + +//============================================================================= +// NodeApiTest implementation +//============================================================================= + +std::unique_ptr CreateEnvHolder( + std::shared_ptr taskRunner, + std::function onUnhandledError); + +//============================================================================= +// NodeLiteModule implementation +//============================================================================= + +using ModuleRegisterFuncCallback = napi_value(NAPI_CDECL*)(napi_env env, + napi_value exports); +using ModuleApiVersionCallback = int32_t(NAPI_CDECL*)(); + +NodeLiteModule::NodeLiteModule(std::filesystem::path module_path) noexcept + : module_path_(std::move(module_path)) {} + +NodeLiteModule::NodeLiteModule(std::filesystem::path module_path, + InitModuleCallback init_module) noexcept + : module_path_(std::move(module_path)), + init_module_(std::move(init_module)) {} + +napi_value NodeLiteModule::LoadModule(napi_env env) { + if (state_ == State::kLoaded) { + return NodeApi::GetReferenceValue(env, exports_.get()); + } + if (state_ == State::kLoading) { + return NodeApi::GetUndefined(env); + } + NODE_LITE_ASSERT(state_ == State::kNotLoaded, + "Unexpected module '%s' state: %d", + module_path_.string().c_str(), + static_cast(state_)); + state_ = State::kLoading; + struct ResetStateIfFailed { + NodeLiteModule* module_; + ~ResetStateIfFailed() { + if (module_->state_ == State::kLoading) { + module_->state_ = State::kNotLoaded; + } + } + } reset_state_if_failed{this}; + + if (init_module_) { + napi_value exports = NodeApi::CreateObject(env); + napi_value init_exports = init_module_(env, exports); + if (init_exports != nullptr && + NodeApi::TypeOf(env, init_exports) != napi_undefined) { + exports = init_exports; + } + exports_ = MakeNodeApiRef(env, exports); + } else if (module_path_.extension() == ".js") { + exports_ = MakeNodeApiRef(env, LoadScriptModule(env)); + } else if (module_path_.extension() == ".node") { + exports_ = MakeNodeApiRef(env, LoadNativeModule(env)); + } else { + NODE_LITE_ASSERT( + false, "Unsupported module type: %s", module_path_.string().c_str()); + } + state_ = State::kLoaded; + return NodeApi::GetReferenceValue(env, exports_.get()); +} + +napi_value NodeLiteModule::LoadScriptModule(napi_env env) { + std::string module_func_wrapper = + "(function(module, exports, require, __filename, __dirname) {"; + module_func_wrapper += ReadModuleFileText(env); + + size_t source_map_index = module_func_wrapper.find("//# sourceMappingURL"); + constexpr const char* module_suffix = "\nreturn module.exports; })\n"; + if (source_map_index != std::string::npos) { + module_func_wrapper.insert(source_map_index, module_suffix); + } else { + module_func_wrapper += module_suffix; + } + + napi_value module_func = NodeApi::RunScript( + env, module_func_wrapper, module_path_.string().c_str()); + + NODE_LITE_ASSERT(NodeApi::TypeOf(env, module_func) == napi_function); + + napi_value exports = NodeApi::CreateObject(env); + napi_value file_name = NodeApi::CreateString(env, module_path_.string()); + napi_value dir_name = + NodeApi::CreateString(env, module_path_.parent_path().string()); + + napi_value module_obj = NodeApi::CreateObject(env); + NodeApi::SetProperty(env, module_obj, "exports", exports); + NodeApi::SetProperty(env, module_obj, "__filename", file_name); + NodeApi::SetProperty(env, module_obj, "__dirname", dir_name); + + napi_value require = NodeApi::CreateFunction( + env, "require", [this](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least one argument"); + std::string module_path = NodeApi::ToStdString(env, args[0]); + NodeLiteRuntime* runtime = NodeLiteRuntime::GetRuntime(env); + return runtime + ->ResolveModule(module_path_.parent_path().string(), module_path) + .LoadModule(env); + }); + + return NodeApi::CallFunction( + env, module_func, {module_obj, exports, require, file_name, dir_name}); +} + +napi_value NodeLiteModule::LoadNativeModule(napi_env env) { + ModuleApiVersionCallback getModuleApiVersion = + reinterpret_cast(NodeLitePlatform::LoadFunction( + env, module_path_.c_str(), "node_api_module_get_api_version_v1")); + int32_t moduleApiVersion = getModuleApiVersion ? getModuleApiVersion() : 8; + + ModuleRegisterFuncCallback moduleRegisterFunc = + reinterpret_cast( + NodeLitePlatform::LoadFunction( + env, module_path_.c_str(), "napi_register_module_v1")); + NODE_LITE_ASSERT(moduleRegisterFunc != nullptr, + "Failed to find 'napi_register_module_v1' in module: %s", + module_path_.c_str()); + + napi_value exports{}; + NODE_LITE_CALL(jsr_initialize_native_module( + env, moduleRegisterFunc, moduleApiVersion, &exports)); + return exports; +} + +std::string NodeLiteModule::ReadModuleFileText(napi_env env) { + return ReadFileText(env, module_path_); +} + +//============================================================================= +// NodeLiteRuntime implementation +//============================================================================= + +/*static*/ void NodeLiteRuntime::Run(std::vector argv) { + // Convert arguments to vector of strings and skip all options before the JS + // file name. + std::vector args; + args.reserve(argv.size()); + bool skipOptions = true; + if (argv.size() < 2) { + NodeLiteErrorHandler::ExitWithMessage("", [&](std::ostream& os) { + os << "Usage: " << argv[0] << " "; + }); + } + args.push_back(argv[0]); + for (int i = 1; i < argv.size(); i++) { + if (skipOptions && std::string_view(argv[i]).find("--") == 0) { + continue; + } + skipOptions = false; + args.push_back(argv[i]); + } + + std::shared_ptr taskRunner = + std::make_shared(); + + fs::path exe_path = fs::canonical(argv[0]); + + fs::path test_root_path = exe_path.parent_path(); + fs::path js_root = test_root_path / "test"; + if (!fs::exists(js_root)) { + test_root_path = test_root_path.parent_path(); + js_root = test_root_path / "test"; + } + if (!fs::exists(js_root)) { + NodeLiteErrorHandler::ExitWithMessage("Error: Cannot find test directory."); + } + + std::string jsFilePath = args[1]; + std::unique_ptr runtime = NodeLiteRuntime::Create( + std::move(taskRunner), js_root.string(), std::move(args)); + runtime->RunTestScript(jsFilePath); +} + +/*static*/ std::unique_ptr NodeLiteRuntime::Create( + std::shared_ptr task_runner, + std::string js_root, + std::vector args) { + std::unique_ptr runtime = + std::make_unique(PrivateTag{}, + std::move(task_runner), + std::move(js_root), + std::move(args)); + runtime->Initialize(); + return runtime; +} + +NodeLiteRuntime::NodeLiteRuntime( + PrivateTag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args) + : task_runner_(std::move(task_runner)), + js_root_(std::move(js_root)), + args_(std::move(args)) {} + +void NodeLiteRuntime::Initialize() { + env_holder_ = + CreateEnvHolder(task_runner_, [this](napi_env env, napi_value error) { + NODE_LITE_ASSERT(env == env_, + "Unhandled error in different napi_env: %p != %p", + env, + env_); + OnUncaughtException(error); + }); + env_ = env_holder_->getEnv(); + NodeApiEnvScope env_scope{env_}; + NodeApiHandleScope handle_scope{env_}; + DefineBuiltInModules(); + DefineGlobalFunctions(); +} + +NodeLiteModule& NodeLiteRuntime::ResolveModule( + const std::string& parent_module_path, const std::string& module_path) { + napi_env env = env_; + fs::path fs_module_path = ResolveModulePath(parent_module_path, module_path); + if (auto it = registered_modules_.find(fs_module_path.string()); + it != registered_modules_.end()) { + return *it->second; + } + + if (auto [it, succeeded] = registered_modules_.try_emplace( + fs_module_path.string(), + std::make_unique(fs_module_path.string())); + succeeded) { + return *it->second; + } + + NODE_LITE_ASSERT( + false, "Failed to register module: %s", fs_module_path.string().c_str()); +} + +fs::path NodeLiteRuntime::ResolveModulePath( + const std::string& parent_module_path, const std::string& module_path) { + napi_env env = env_; + // 1. See if it is an embedded module such as "assert". + auto it = node_js_modules_.find(module_path); + if (it != node_js_modules_.end()) { + return fs::path(it->second); + } + + // 2. Check if it is a relative or an absolute path to a module. + { + fs::path fs_module_path = fs::path(module_path); + if (!fs_module_path.is_absolute()) { + fs::path fs_parent_module_path = fs::path(parent_module_path); + NODE_LITE_ASSERT(fs_parent_module_path.is_absolute(), + "Parent module path '%s' is not absolute", + parent_module_path.c_str()); + fs_module_path = fs_parent_module_path / fs_module_path; + } + fs_module_path = fs::weakly_canonical(fs_module_path); + + if (fs::exists(fs_module_path) && fs::is_regular_file(fs_module_path)) { + return fs_module_path; + } + if (fs::path result = fs::path(fs_module_path).replace_extension(".js"); + fs::exists(result)) { + return result; + } + if (fs::path result = fs_module_path / "index.js"; fs::exists(result)) { + return result; + } + // See if it is a native module. + fs::path node_module_path = + fs::path(fs_module_path).replace_extension(".node"); + if (fs::exists(node_module_path)) { + return node_module_path; + } + // See if the module was prefixed with the parent folder to disambiguate C++ + // project name. + fs::path fs_parent_folder = fs::path(parent_module_path).filename(); + node_module_path.replace_filename(fs_parent_folder.string() + "_" + + node_module_path.filename().string()); + if (fs::exists(node_module_path)) { + return node_module_path; + } + } + + // 3. Check if it is in the node_modules folder. + { + fs::path fs_module_path = fs::weakly_canonical( + fs::path(js_root_) / "node_modules" / fs::path(module_path)); + + if (fs::exists(fs_module_path) && fs::is_regular_file(fs_module_path)) { + return fs_module_path; + } + if (fs::path result = fs::path(fs_module_path).replace_extension(".js"); + fs::exists(result)) { + return result; + } + if (fs::path result = fs_module_path / "index.js"; fs::exists(result)) { + return result; + } + } + + NODE_LITE_ASSERT( + false, "Cannot resolve module path '%s'", module_path.c_str()); +} + +void NodeLiteRuntime::AddNativeModule( + const std::string& module_name, + std::function initModule) { + napi_env env = env_; + auto [_, succeeded] = registered_modules_.try_emplace( + module_name, + std::make_unique(module_name, std::move(initModule))); + NODE_LITE_ASSERT( + succeeded, "Failed to register module: %s", module_name.c_str()); +} + +void NodeLiteRuntime::RunTestScript(const std::string& script_path) { + NodeApiEnvScope env_scope{env_}; + NodeApiHandleScope handle_scope{env_}; + { + ExitOnException(env_, [this, &script_path]() { + NodeApiHandleScope scope{env_}; + NodeLiteModule& main_module = ResolveModule(js_root_, script_path); + main_module.LoadModule(env_); + }); + ExitOnException(env_, [this]() { + task_runner_->DrainTaskQueue(); + OnExit(); + on_exit_callbacks_.clear(); + on_uncaughtException_callbacks_.clear(); + }); + } +} + +void NodeLiteRuntime::OnExit() { + for (NodeApiRef& callback_ref : on_exit_callbacks_) { + napi_value callback = NodeApi::GetReferenceValue(env_, callback_ref.get()); + NodeApi::CallFunction(env_, callback, {NodeApi::CreateUInt32(env_, 0)}); + } +} + +void NodeLiteRuntime::OnUncaughtException(napi_value error) { + bool shouldExit = true; + for (NodeApiRef& callback_ref : on_uncaughtException_callbacks_) { + napi_value callback = NodeApi::GetReferenceValue(env_, callback_ref.get()); + napi_value result = NodeApi::CallFunction( + env_, + callback, + {error, NodeApi::CreateString(env_, "uncaughtException")}); + // If at least one callback returns false, we do not exit. + // TODO: (vmoroz) Investigate the Node.js behavior in that case + // if (shouldExit && NodeApi::TypeOf(env_, result) == napi_boolean) { + // shouldExit = NodeApi::GetBoolean(env_, result); + //} + shouldExit = false; + } + + if (shouldExit) { + NodeLiteErrorHandler::ExitWithJSError(env_, error); + } +} + +/*static*/ NodeLiteRuntime* NodeLiteRuntime::GetRuntime(napi_env env) { + napi_value global = NodeApi::GetGlobal(env); + return static_cast(NodeApi::GetValueExternal( + env, NodeApi::GetProperty(env, global, "__NodeLiteRuntime__"))); +} + +void NodeLiteRuntime::DefineBuiltInModules() { + napi_env env = env_; + // Define "assert" module + { + fs::path assert_path = + fs::weakly_canonical(fs::path(js_root_) / "common" / "assert.js"); + std::string assert_path_str = assert_path.string(); + NODE_LITE_ASSERT(fs::exists(assert_path), + "Failed to find assert.js file: %s", + assert_path_str.c_str()); + node_js_modules_.try_emplace(assert_path_str, assert_path_str); + node_js_modules_.try_emplace(assert_path.replace_extension().string(), + assert_path_str); + node_js_modules_.try_emplace("assert", assert_path_str); + node_js_modules_.try_emplace("node:assert", assert_path_str); + } + + // Define "child_process" module + { + node_js_modules_.try_emplace("child_process", "child_process"); + node_js_modules_.try_emplace("node:child_process", "child_process"); + AddNativeModule("child_process", [this](napi_env env, napi_value exports) { + NodeApi::SetMethod( + env_, exports, "spawnSync", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 2, + "Expected at least 2 arguments, but got: %zu", + args.size()); + std::string command = NodeApi::ToStdString(env, args[0]); + std::vector command_args = + NodeApi::ToStdStringArray(env, args[1]); + ProcessResult call_result = SpawnSync(command, command_args); + napi_value result = NodeApi::CreateObject(env); + NodeApi::SetPropertyUInt32( + env, result, "status", call_result.status); + NodeApi::SetPropertyString( + env, result, "stderr", call_result.std_error); + NodeApi::SetPropertyString( + env, result, "stdout", call_result.std_output); + NodeApi::SetPropertyNull(env, result, "signal"); + return result; + }); + return exports; + }); + } + + // Define "fs" module + { + node_js_modules_.try_emplace("fs", "fs"); + node_js_modules_.try_emplace("node:fs", "fs"); + AddNativeModule("fs", [this](napi_env env, napi_value exports) { + NodeApi::SetMethod( + env_, exports, "existsSync", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + fs::path path = fs::path{NodeApi::ToStdString(env, args[0])}; + return NodeApi::GetBoolean(env, fs::exists(path)); + }); + NodeApi::SetMethod( + env_, + exports, + "readFileSync", + [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + fs::path path = fs::path{NodeApi::ToStdString(env, args[0])}; + return NodeApi::CreateString(env, ReadFileText(env, path)); + }); + return exports; + }); + } + + // Define "path" module + { + node_js_modules_.try_emplace("path", "path"); + node_js_modules_.try_emplace("node:path", "path"); + AddNativeModule("path", [this](napi_env env, napi_value exports) { + NodeApi::SetMethod( + env_, exports, "join", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 2, + "Expected at least 2 arguments, but got: %zu", + args.size()); + fs::path path = fs::path{NodeApi::ToStdString(env, args[0])}; + for (size_t i = 1; i < args.size(); ++i) { + path /= NodeApi::ToStdString(env, args[i]); + } + return NodeApi::CreateString(env, path.string()); + }); + return exports; + }); + } +} + +void NodeLiteRuntime::DefineGlobalFunctions() { + NodeApiHandleScope scope{env_}; + napi_value global = NodeApi::GetGlobal(env_); + + // Add global.global + NodeApi::SetProperty(env_, global, "global", global); + + // Add global.__NodeLiteRuntime__ + NodeApi::SetProperty( + env_, global, "__NodeLiteRuntime__", NodeApi::CreateExternal(env_, this)); + + // Remove the global.require defined by Hermes + NodeApi::DeleteProperty(env_, global, "require"); + + // global.gc() + NodeApi::SetMethod( + env_, global, "gc", [](napi_env env, span /*args*/) { + NODE_LITE_CALL(jsr_collect_garbage(env)); + return nullptr; + }); + + auto set_immediate_cb = [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, + "Expected at least 1 argument, but got: %zu", + args.size()); + std::shared_ptr callback_ref = + std::make_shared(MakeNodeApiRef(env, args[0])); + uint32_t task_id = GetRuntime(env)->task_runner_->PostTask( + [env, callback_ref = std::move(callback_ref)]() { + ExitOnException(env, [env, &callback_ref]() { + NodeApiHandleScope scope{env}; + napi_value callback = + NodeApi::GetReferenceValue(env, callback_ref->get()); + NodeApi::CallFunction(env, callback, {}); + }); + }); + return NodeApi::CreateUInt32(env, task_id); + }; + + // global.setImmediate() + NodeApi::SetMethod(env_, global, "setImmediate", set_immediate_cb); + + // global.setTimeout() + NodeApi::SetMethod(env_, global, "setTimeout", set_immediate_cb); + + // global.clearTimeout() + NodeApi::SetMethod( + env_, global, "clearTimeout", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, + "Expected at least 1 argument, but got: %zu", + args.size()); + uint32_t task_id = NodeApi::GetValueUInt32(env, args[0]); + GetRuntime(env)->task_runner_->RemoveTask(task_id); + return nullptr; + }); + + // global.process + { + napi_value process_obj = NodeApi::CreateObject(env_); + NodeApi::SetProperty(env_, global, "process", process_obj); + + // process.argv + NodeApi::SetPropertyStringArray(env_, process_obj, "argv", args_); + + // process.execPath + NodeApi::SetPropertyString(env_, process_obj, "execPath", args_[0]); + +// process.target_config +#ifdef NDEBUG + NodeApi::SetPropertyString(env_, process_obj, "target_config", "Release"); +#else + NodeApi::SetPropertyString(env_, process_obj, "target_config", "Debug"); +#endif + +// process.platform +#ifdef WIN32 + NodeApi::SetPropertyString(env_, process_obj, "platform", "win32"); +#else + // TODO: (vmoroz) Add support for other platforms. + NodeApi::SetPropertyString(env_, process_obj, "platform", "other"); +#endif + + // process.exit(exit_code) + NodeApi::SetMethod( + env_, process_obj, "exit", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, + "Expected at least 1 argument, but got: " + "%zu", + args.size()); + int32_t exit_code = NodeApi::GetValueInt32(env, args[0]); + exit(exit_code); + return nullptr; + }); + + // process.on('event_name', callback) + NodeApi::SetMethod( + env_, process_obj, "on", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 2, + "Expected at least 2 arguments, but got: %zu", + args.size()); + std::string event_name = NodeApi::ToStdString(env, args[0]); + if (event_name == "exit") { + NODE_LITE_ASSERT(NodeApi::TypeOf(env, args[1]) == napi_function, + "Expected function as second argument"); + GetRuntime(env)->on_exit_callbacks_.push_back( + MakeNodeApiRef(env, args[1])); + } else if (event_name == "uncaughtException") { + NODE_LITE_ASSERT(NodeApi::TypeOf(env, args[1]) == napi_function, + "Expected function as second argument"); + GetRuntime(env)->on_uncaughtException_callbacks_.push_back( + MakeNodeApiRef(env, args[1])); + } else { + NODE_LITE_ASSERT(false, + "Unsupported process event name: %s", + event_name.c_str()); + } + return nullptr; + }); + } + + // global.console + { + napi_value console_obj = NodeApi::CreateObject(env_); + NodeApi::SetProperty(env_, global, "console", console_obj); + + // console.log() + NodeApi::SetMethod( + env_, console_obj, "log", [](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + std::cout << message << std::endl; + return nullptr; + }); + + // console.error() + NodeApi::SetMethod( + env_, + console_obj, + "error", + [](napi_env env, span args) -> napi_value { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + std::cerr << message << std::endl; + return nullptr; + }); + } +} + +std::string NodeLiteRuntime::ProcessStack(std::string const& stack, + std::string const& assertMethod) { + // Split up the stack string into an array of stack frames + auto stackStream = std::istringstream(stack); + std::string stackFrame; + std::vector stackFrames; + while (std::getline(stackStream, stackFrame, '\n')) { + stackFrames.push_back(std::move(stackFrame)); + } + + // Remove first and last stack frames: one is the error message + // and another is the module root call. + if (!stackFrames.empty()) { + stackFrames.pop_back(); + } + if (!stackFrames.empty()) { + stackFrames.erase(stackFrames.begin()); + } + + std::string processedStack; + bool assertFuncFound = false; + std::string assertFuncPattern = assertMethod + " ("; + const std::regex locationRE("(\\w+):(\\d+)"); + std::smatch locationMatch; + // for (auto const& frame : stackFrames) { + // if (assertFuncFound) { + // std::string processedFrame; + // if (std::regex_search(frame, locationMatch, locationRE)) { + // if (auto const* scriptInfo = + // GetTestScriptInfo(locationMatch[1].str())) { + // int32_t cppLine = + // scriptInfo->line + std::stoi(locationMatch[2].str()) - 1; + // processedFrame = locationMatch.prefix().str() + + // UseSrcFilePath(scriptInfo->filePath.string()) + + // ':' + std::to_string(cppLine) + + // locationMatch.suffix().str(); + // } + // } + // processedStack += + // (!processedFrame.empty() ? processedFrame : frame) + '\n'; + // } else { + // auto pos = frame.find(assertFuncPattern); + // if (pos != std::string::npos) { + // if (frame[pos - 1] == '.' || frame[pos - 1] == ' ') { + // assertFuncFound = true; + // } + // } + // } + // } + + return processedStack; +} + +//============================================================================= +// NodeApiRefDeleter implementation +//============================================================================= + +NodeApiRefDeleter::NodeApiRefDeleter() noexcept = default; + +NodeApiRefDeleter::NodeApiRefDeleter(napi_env env) noexcept : env_(env) {} + +void NodeApiRefDeleter::operator()(napi_ref ref) noexcept { + if (ref == nullptr || env_ == nullptr) { + return; + } + napi_env env = env_; + NODE_LITE_CALL(napi_delete_reference(env, ref)); +} + +//============================================================================= +// NodeLiteTaskRunner implementation +//============================================================================= + +uint32_t NodeLiteTaskRunner::PostTask(std::function&& task) noexcept { + uint32_t task_id = next_task_id_++; + task_queue_.emplace_back(task_id, std::move(task)); + return task_id; +} + +void NodeLiteTaskRunner::RemoveTask(uint32_t task_id) noexcept { + task_queue_.remove_if( + [task_id](const std::pair>& entry) { + return entry.first == task_id; + }); +} + +void NodeLiteTaskRunner::DrainTaskQueue() noexcept { + while (!task_queue_.empty()) { + std::pair> task = + std::move(task_queue_.front()); + task_queue_.pop_front(); + task.second(); + } +} + +/*static*/ void NodeLiteTaskRunner::PostTaskCallback( + void* task_runner_data, + void* task_data, + jsr_task_run_cb task_run_cb, + jsr_data_delete_cb task_data_delete_cb, + void* deleter_data) { + NodeLiteTaskRunner* taskRunnerPtr = + static_cast*>(task_runner_data) + ->get(); + taskRunnerPtr->PostTask( + [task_run_cb, task_data, task_data_delete_cb, deleter_data]() { + if (task_run_cb != nullptr) { + task_run_cb(task_data); + } + if (task_data_delete_cb != nullptr) { + task_data_delete_cb(task_data, deleter_data); + } + }); +} + +/*static*/ void NodeLiteTaskRunner::DeleteCallback(void* data, + void* /*deleter_data*/) { + delete static_cast*>(data); +} + +//============================================================================= +// NodeApiHandleScope implementation +//============================================================================= + +NodeApiHandleScope::NodeApiHandleScope(napi_env env) noexcept : env_{env} { + NODE_LITE_CALL(napi_open_handle_scope(env, &scope_)); +} + +NodeApiHandleScope::~NodeApiHandleScope() noexcept { + napi_env env = env_; + NODE_LITE_CALL(napi_close_handle_scope(env, scope_)); +} + +//============================================================================= +// NodeApiEnvScope implementation +//============================================================================= + +NodeApiEnvScope::NodeApiEnvScope(napi_env env) noexcept : env_{env} { + NODE_LITE_CALL(jsr_open_napi_env_scope(env, &scope_)); +} + +NodeApiEnvScope ::~NodeApiEnvScope() noexcept { + if (env_ != nullptr) { + napi_env env = env_; + NODE_LITE_CALL(jsr_close_napi_env_scope(env, scope_)); + } +} + +NodeApiEnvScope::NodeApiEnvScope(NodeApiEnvScope&& other) noexcept + : env_{std::exchange(other.env_, nullptr)}, + scope_{std::exchange(other.scope_, nullptr)} {} + +NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { + if (this != &other) { + NodeApiEnvScope temp(std::move(*this)); + env_ = std::exchange(other.env_, nullptr); + scope_ = std::exchange(other.scope_, nullptr); + } + return *this; +} + +//============================================================================= +// NodeLiteErrorHandler implementation +//============================================================================= + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnNodeApiFailed( + napi_env env, napi_status error_code) { + const char* errorMessage = "An exception is pending"; + if (NodeApi::IsExceptionPending(env)) { + error_code = napi_pending_exception; + } else { + const napi_extended_error_info* error_info{}; + napi_status status = napi_get_last_error_info(env, &error_info); + if (status != napi_ok) { + NodeLiteErrorHandler::ExitWithMessage("", [&](std::ostream& os) { + os << "Failed to get last error info: " << status; + }); + } + errorMessage = error_info->error_message; + } + throw NodeLiteException(error_code, errorMessage); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnAssertFailed( + napi_env env, char const* expr, char const* message) { + std::string error_message = FormatString("Assert failed: %s.", expr); + if (message != nullptr) { + std::string message_str{message}; + if (!message_str.empty()) { + error_message += " " + message_str; + } + } + napi_status error_code = NodeApi::IsExceptionPending(env) + ? napi_pending_exception + : napi_generic_failure; + + throw NodeLiteException(error_code, error_message.c_str()); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSError( + napi_env env, napi_value error) noexcept { + // TODO: protect from stack overflow + napi_valuetype error_value_type = NodeApi::TypeOf(env, error); + if (error_value_type == napi_object) { + std::string name = NodeApi::GetPropertyString(env, error, "name"); + if (name == "AssertionError") { + ExitWithJSAssertError(env, error); + } + std::string message = NodeApi::GetPropertyString(env, error, "message"); + std::string stack = NodeApi::GetPropertyString(env, error, "stack"); + ExitWithMessage("JavaScript error", [&](std::ostream& os) { + os << "Exception: " << name << '\n' + << " Message: " << message << '\n' + << "Callstack: " << '\n' + << stack; + }); + } else { + std::string message = NodeApi::CoerceToString(env, error); + ExitWithMessage("JavaScript error", + [&](std::ostream& os) { os << " Message: " << message; }); + } +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSAssertError( + napi_env env, napi_value error) noexcept { + std::string message = NodeApi::GetPropertyString(env, error, "message"); + std::string method = NodeApi::GetPropertyString(env, error, "method"); + std::string expected = NodeApi::GetPropertyString(env, error, "expected"); + std::string actual = NodeApi::GetPropertyString(env, error, "actual"); + std::string source_file = + NodeApi::GetPropertyString(env, error, "sourceFile"); + int32_t source_line = NodeApi::GetPropertyInt32(env, error, "sourceLine"); + std::string error_stack = + NodeApi::GetPropertyString(env, error, "errorStack"); + if (error_stack.empty()) { + error_stack = NodeApi::GetPropertyString(env, error, "stack"); + } + std::string method_name = "assert." + method; + std::stringstream error_details; + if (method_name != "assert.fail") { + error_details << " Expected: " << expected << '\n' + << " Actual: " << actual << '\n'; + } + + ExitWithMessage("JavaScript assertion error", [&](std::ostream& os) { + os << "Exception: " << "AssertionError" << '\n' + << " Method: " << method_name << '\n' + << " Message: " << message << '\n' + << error_details.str(/*a filler for formatting*/) + << "Callstack: " << '\n' + << error_stack; + }); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( + const std::string& message, + std::function get_error_details) noexcept { + std::ostringstream details_stream; + get_error_details(details_stream); + std::string details = details_stream.str(); + if (!message.empty()) { + std::cerr << message; + } + if (!details.empty()) { + if (!message.empty()) { + std::cerr << "\n"; + } + std::cerr << details; + } + std::cerr << std::endl; + exit(1); +} + +//============================================================================= +// NodeApi implementation +//============================================================================= + +/*static*/ bool NodeApi::IsExceptionPending(napi_env env) { + bool result{}; + NODE_LITE_CALL(napi_is_exception_pending(env, &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetAndClearLastException(napi_env env) { + napi_value result{}; + NODE_LITE_CALL(napi_get_and_clear_last_exception(env, &result)); + return result; +} + +/*static*/ void NodeApi::ThrowError(napi_env env, napi_value error) { + NODE_LITE_CALL(napi_throw(env, error)); +} + +/*static*/ void NodeApi::ThrowError(napi_env env, const char* error_message) { + NODE_LITE_CALL(napi_throw_error(env, "", error_message)); +} + +/*static*/ napi_value NodeApi::GetNull(napi_env env) { + napi_value result{}; + NODE_LITE_CALL(napi_get_null(env, &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetUndefined(napi_env env) { + napi_value result{}; + NODE_LITE_CALL(napi_get_undefined(env, &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetGlobal(napi_env env) { + napi_value result{}; + NODE_LITE_CALL(napi_get_global(env, &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetBoolean(napi_env env, bool value) { + napi_value result{}; + NODE_LITE_CALL(napi_get_boolean(env, value, &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetReferenceValue(napi_env env, napi_ref ref) { + napi_value result{}; + NODE_LITE_CALL(napi_get_reference_value(env, ref, &result)); + return result; +} + +/*static*/ napi_value NodeApi::CreateUInt32(napi_env env, std::uint32_t value) { + napi_value result{}; + NODE_LITE_CALL(napi_create_uint32(env, value, &result)); + return result; +} + +/*static*/ napi_value NodeApi::CreateString(napi_env env, + std::string_view value) { + napi_value result{}; + NODE_LITE_CALL( + napi_create_string_utf8(env, value.data(), value.size(), &result)); + return result; +} + +/*static*/ napi_value NodeApi::CreateStringArray( + napi_env env, std::vector const& value) { + napi_value result{}; + NODE_LITE_CALL(napi_create_array(env, &result)); + + uint32_t index = 0; + for (const std::string& item : value) { + NODE_LITE_CALL( + napi_set_element(env, result, index++, CreateString(env, item))); + } + return result; +} + +/*static*/ napi_value NodeApi::CreateObject(napi_env env) { + napi_value result{}; + NODE_LITE_CALL(napi_create_object(env, &result)); + return result; +} + +/*static*/ napi_value NodeApi::CreateExternal(napi_env env, void* data) { + napi_value result{}; + NODE_LITE_CALL(napi_create_external(env, data, nullptr, nullptr, &result)); + return result; +} + +/*static*/ int32_t NodeApi::GetValueInt32(napi_env env, napi_value value) { + int32_t result{}; + NODE_LITE_CALL(napi_get_value_int32(env, value, &result)); + return result; +} + +/*static*/ uint32_t NodeApi::GetValueUInt32(napi_env env, napi_value value) { + uint32_t result{}; + NODE_LITE_CALL(napi_get_value_uint32(env, value, &result)); + return result; +} + +/*static*/ void* NodeApi::GetValueExternal(napi_env env, napi_value value) { + void* result{}; + NODE_LITE_CALL(napi_get_value_external(env, value, &result)); + return result; +} + +/*static*/ bool NodeApi::HasProperty(napi_env env, + napi_value obj, + std::string_view utf8_name) { + bool result{}; + NODE_LITE_CALL(napi_has_named_property(env, obj, utf8_name.data(), &result)); + return result; +} + +/*static*/ napi_value NodeApi::GetProperty(napi_env env, + napi_value obj, + std::string_view utf8_name) { + napi_value result{}; + NODE_LITE_CALL(napi_get_named_property(env, obj, utf8_name.data(), &result)); + return result; +} + +/*static*/ std::string NodeApi::GetPropertyString(napi_env env, + napi_value obj, + std::string_view utf8_name) { + if (HasProperty(env, obj, utf8_name)) { + return ToStdString(env, GetProperty(env, obj, utf8_name)); + } else { + return ""; + } +} + +/*static*/ int32_t NodeApi::GetPropertyInt32(napi_env env, + napi_value obj, + std::string_view utf8_name) { + return GetValueInt32(env, GetProperty(env, obj, utf8_name)); +} + +/*static*/ std::string NodeApi::CoerceToString(napi_env env, napi_value value) { + napi_value str_value; + NODE_LITE_CALL(napi_coerce_to_string(env, value, &str_value)); + return ToStdString(env, str_value); +} + +/*static*/ void NodeApi::SetProperty(napi_env env, + napi_value obj, + std::string_view utf8_name, + napi_value value) { + NODE_LITE_CALL(napi_set_named_property(env, obj, utf8_name.data(), value)); +} + +/*static*/ void NodeApi::SetPropertyUInt32(napi_env env, + napi_value obj, + std::string_view utf8_name, + uint32_t value) { + SetProperty(env, obj, utf8_name, CreateUInt32(env, value)); +} + +/*static*/ void NodeApi::SetPropertyString(napi_env env, + napi_value obj, + std::string_view utf8_name, + std::string_view value) { + SetProperty(env, obj, utf8_name, CreateString(env, value)); +} + +/*static*/ void NodeApi::SetPropertyStringArray( + napi_env env, + napi_value obj, + std::string_view utf8_name, + std::vector const& value) { + SetProperty(env, obj, utf8_name, CreateStringArray(env, value)); +} + +/*static*/ void NodeApi::SetPropertyNull(napi_env env, + napi_value obj, + std::string_view utf8_name) { + SetProperty(env, obj, utf8_name, GetNull(env)); +} + +/*static*/ void NodeApi::SetMethod(napi_env env, + napi_value obj, + std::string_view utf8_name, + NodeApiCallback cb) { + NodeApi::SetProperty(env, obj, utf8_name, CreateFunction(env, utf8_name, cb)); +} + +/*static*/ bool NodeApi::DeleteProperty(napi_env env, + napi_value obj, + std::string_view utf8_name) { + bool result{}; + NODE_LITE_CALL( + napi_delete_property(env, obj, CreateString(env, utf8_name), &result)); + return result; +} + +/*static*/ std::string NodeApi::ToStdString(napi_env env, napi_value value) { + size_t str_size{}; + NODE_LITE_CALL(napi_get_value_string_utf8(env, value, nullptr, 0, &str_size)); + std::string result(str_size, '\0'); + NODE_LITE_CALL(napi_get_value_string_utf8( + env, value, &result[0], str_size + 1, nullptr)); + return result; +} + +/*static*/ std::vector NodeApi::ToStdStringArray( + napi_env env, napi_value value) { + std::vector result; + bool is_array; + NODE_LITE_CALL(napi_is_array(env, value, &is_array)); + if (is_array) { + uint32_t length; + NODE_LITE_CALL(napi_get_array_length(env, value, &length)); + result.reserve(length); + for (uint32_t i = 0; i < length; i++) { + napi_value element; + NODE_LITE_CALL(napi_get_element(env, value, i, &element)); + result.push_back(CoerceToString(env, element)); + } + } + return result; +} + +/*static*/ napi_value NodeApi::RunScript(napi_env env, napi_value script) { + napi_value result{}; + NODE_LITE_CALL(napi_run_script(env, script, nullptr, &result)); + return result; +} + +/*static*/ napi_value NodeApi::RunScript(napi_env env, + const std::string& code, + char const* source_url) { + napi_value script = NodeApi::CreateString(env, code); + + if (source_url != nullptr) { + napi_value result{}; + NODE_LITE_CALL(jsr_run_script(env, script, source_url, &result)); + return result; + } + return RunScript(env, script); +} + +/*static*/ napi_valuetype NodeApi::TypeOf(napi_env env, napi_value value) { + napi_valuetype result{}; + NODE_LITE_CALL(napi_typeof(env, value, &result)); + return result; +} + +/*static*/ napi_value NodeApi::CallFunction(napi_env env, + napi_value func, + span args) { + napi_value result{}; + NODE_LITE_CALL(napi_call_function( + env, GetUndefined(env), func, args.size(), args.data(), &result)); + return result; +} + +/*static*/ napi_value NodeApi::CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb) { + napi_value result{}; + NODE_LITE_CALL(napi_create_function( + env, + name.data(), + name.size(), + [](napi_env env, napi_callback_info info) { + napi_value result{}; + ThrowJSErrorOnException(env, [env, info, &result]() { + NodeApiCallbackInfo callback_info{env, info}; + NodeApiCallback* cb = + static_cast(callback_info.data()); + result = (*cb)(env, callback_info.args()); + }); + return result; + }, + // TODO: (vmoroz) Find a way to delete it on close. + new NodeApiCallback(std::move(cb)), + &result)); + return result; +} + +} // namespace node_api_tests + +int main(int argc, char* argv[]) { + node_api_tests::NodeLiteRuntime::Run( + std::vector(argv, argv + argc)); +} diff --git a/Tests/NodeApi/node_lite.h b/Tests/NodeApi/node_lite.h new file mode 100644 index 00000000..5b9044dd --- /dev/null +++ b/Tests/NodeApi/node_lite.h @@ -0,0 +1,365 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +// A simple Node.js-like runtime that runs Node-API test scripts. + +#ifndef NODE_API_TEST_NODE_LITE_H +#define NODE_API_TEST_NODE_LITE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "compat.h" +#include "string_utils.h" + +#define NAPI_EXPERIMENTAL +#include "js_runtime_api.h" + +#define NODE_LITE_CALL(expr) \ + do { \ + napi_status temp_status__ = (expr); \ + if (temp_status__ != napi_status::napi_ok) { \ + NodeLiteErrorHandler::OnNodeApiFailed(env, temp_status__); \ + } \ + } while (false) + +#define NODE_LITE_ASSERT(expr, ...) \ + do { \ + if (!(expr)) { \ + NodeLiteErrorHandler::OnAssertFailed( \ + env, #expr, FormatString("" __VA_ARGS__).c_str()); \ + } \ + } while (false) + +namespace node_api_tests { + +// Forward declarations +class NodeLiteModule; +class NodeLiteRuntime; +class NodeLiteTaskRunner; +class NodeApiRefDeleter; +class NodeApiHandleScope; +class NodeApiEnvScope; +class NodeLiteErrorHandler; + +struct IEnvHolder { + virtual ~IEnvHolder() {} + virtual napi_env getEnv() = 0; +}; + +class NodeLiteTaskRunner { + public: + using QueueEntry = std::pair>; + + uint32_t PostTask(std::function&& task) noexcept; + void RemoveTask(uint32_t task_id) noexcept; + void DrainTaskQueue() noexcept; + + static void PostTaskCallback(void* task_runner_data, + void* task_data, + jsr_task_run_cb task_run_cb, + jsr_data_delete_cb task_data_delete_cb, + void* deleter_data); + + static void DeleteCallback(void* data, void* /*deleter_data*/); + + private: + std::list task_queue_; + uint32_t next_task_id_{1}; +}; + +class NodeLiteException : public std::runtime_error { + public: + explicit NodeLiteException(napi_status error_status, + const char* message) noexcept + : runtime_error{message}, error_status_{error_status} {} + + napi_status error_status() const noexcept { return error_status_; } + + private: + napi_status error_status_; +}; + +class NodeLiteErrorHandler { + public: + [[noreturn]] static void OnNodeApiFailed(napi_env env, + napi_status error_status); + + [[noreturn]] static void OnAssertFailed(napi_env env, + char const* expr, + char const* message); + + [[noreturn]] static void ExitWithJSError(napi_env env, + napi_value error) noexcept; + + [[noreturn]] static void ExitWithJSAssertError(napi_env env, + napi_value error) noexcept; + + [[noreturn]] static void ExitWithMessage( + const std::string& message, + std::function get_error_details = nullptr) noexcept; +}; + +// Define NodeApiRef "smart pointer" for napi_ref as unique_ptr with a custom +// deleter. +class NodeApiRefDeleter { + public: + NodeApiRefDeleter() noexcept; + explicit NodeApiRefDeleter(napi_env env) noexcept; + + void operator()(napi_ref ref) noexcept; + + private: + napi_env env_{}; +}; + +using NodeApiRef = std::unique_ptr; + +class NodeApiHandleScope { + public: + explicit NodeApiHandleScope(napi_env env) noexcept; + ~NodeApiHandleScope() noexcept; + + private: + napi_env env_{}; + napi_handle_scope scope_{}; +}; + +class NodeApiEnvScope { + public: + explicit NodeApiEnvScope(napi_env env) noexcept; + + ~NodeApiEnvScope() noexcept; + + NodeApiEnvScope(NodeApiEnvScope&& other) noexcept; + NodeApiEnvScope& operator=(NodeApiEnvScope&& other) noexcept; + + NodeApiEnvScope(const NodeApiEnvScope&) = delete; + NodeApiEnvScope& operator=(const NodeApiEnvScope&) = delete; + + private: + napi_env env_{}; + jsr_napi_env_scope scope_{}; +}; + +class NodeLiteModule { + public: + using InitModuleCallback = + std::function; + + explicit NodeLiteModule(std::filesystem::path module_path) noexcept; + explicit NodeLiteModule(std::filesystem::path module_path, + InitModuleCallback init_module) noexcept; + + napi_value LoadModule(napi_env env); + + NodeLiteModule(const NodeLiteModule&) = delete; + NodeLiteModule& operator=(const NodeLiteModule&) = delete; + + private: + napi_value LoadScriptModule(napi_env env); + napi_value LoadNativeModule(napi_env env); + std::string ReadModuleFileText(napi_env env); + + private: + enum class State { + kNotLoaded, + kLoading, + kLoaded, + }; + + private: + State state_{State::kNotLoaded}; + std::filesystem::path module_path_; + InitModuleCallback init_module_; + NodeApiRef exports_; +}; + +// The Node.js-like runtime that is enough to run Node-API tests. +class NodeLiteRuntime { + struct PrivateTag {}; + + public: + static std::unique_ptr Create( + std::shared_ptr task_runner, + std::string js_root, + std::vector args); + + explicit NodeLiteRuntime(PrivateTag tag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args); + + static void Run(std::vector args); + + NodeLiteModule& ResolveModule(const std::string& parent_module_path, + const std::string& module_path); + + std::filesystem::path ResolveModulePath(const std::string& parent_module_path, + const std::string& module_path); + + void RunTestScript(const std::string& script_path); + + void AddNativeModule( + const std::string& module_name, + std::function initModule); + + void HandleUnhandledPromiseRejections(); + void OnExit(); + void OnUncaughtException(napi_value error); + + std::string ProcessStack(std::string const& stack, + std::string const& assertMethod); + + static NodeLiteRuntime* GetRuntime(napi_env env); + + private: + void Initialize(); + void DefineGlobalFunctions(); + void DefineBuiltInModules(); + + private: + std::shared_ptr task_runner_; + std::string js_root_; + std::vector args_; + std::unique_ptr env_holder_; + napi_env env_{}; + std::unordered_map> + registered_modules_; + std::unordered_map node_js_modules_; + std::vector on_exit_callbacks_; + std::vector on_uncaughtException_callbacks_; +}; + +class NodeLitePlatform { + public: + static void* LoadFunction(napi_env env, + const std::filesystem::path& lib_path, + const std::string& function_name) noexcept; +}; + +using NodeApiCallback = + std::function args)>; + +// Wraps up Node-API function calls. +// To simplify usage patterns it throws NodeApiException on errors. +class NodeApi { + public: + static bool IsExceptionPending(napi_env env); + + static napi_value GetAndClearLastException(napi_env env); + + static void ThrowError(napi_env env, napi_value error); + + static void ThrowError(napi_env env, const char* error_message); + + static napi_value GetNull(napi_env env); + + static napi_value GetUndefined(napi_env env); + + static napi_value GetGlobal(napi_env env); + + static napi_value GetBoolean(napi_env env, bool value); + + static napi_value GetReferenceValue(napi_env env, napi_ref ref); + + static napi_value CreateUInt32(napi_env env, std::uint32_t value); + + static napi_value CreateString(napi_env env, std::string_view value); + + static napi_value CreateStringArray(napi_env env, + std::vector const& value); + + static napi_value CreateObject(napi_env env); + + static napi_value CreateExternal(napi_env env, void* data); + + static int32_t GetValueInt32(napi_env env, napi_value value); + + static uint32_t GetValueUInt32(napi_env env, napi_value value); + + static void* GetValueExternal(napi_env env, napi_value value); + + static bool HasProperty(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static napi_value GetProperty(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static std::string GetPropertyString(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static int32_t GetPropertyInt32(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static void SetProperty(napi_env env, + napi_value obj, + std::string_view utf8_name, + napi_value value); + + static void SetPropertyUInt32(napi_env env, + napi_value obj, + std::string_view utf8_name, + uint32_t value); + + static void SetPropertyString(napi_env env, + napi_value obj, + std::string_view utf8_name, + std::string_view value); + + static void SetPropertyStringArray(napi_env env, + napi_value obj, + std::string_view utf8_name, + std::vector const& value); + + static void SetPropertyNull(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static void SetMethod(napi_env env, + napi_value obj, + std::string_view utf8_name, + NodeApiCallback cb); + + static bool DeleteProperty(napi_env env, + napi_value obj, + std::string_view utf8_name); + + static std::string CoerceToString(napi_env env, napi_value value); + + static std::string ToStdString(napi_env env, napi_value value); + + static std::vector ToStdStringArray(napi_env env, + napi_value value); + + static napi_value RunScript(napi_env env, napi_value script); + + static napi_value RunScript(napi_env env, + const std::string& code, + char const* source_url); + + static napi_valuetype TypeOf(napi_env env, napi_value value); + + static napi_value CallFunction(napi_env env, + napi_value func, + span args); + + static napi_value CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb); +}; + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_NODE_LITE_H \ No newline at end of file diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp new file mode 100644 index 00000000..6833672e --- /dev/null +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -0,0 +1,90 @@ +#include "node_lite.h" + +#include +#include + +#include +#include + +#if defined(__APPLE__) +#include +#include "js_native_api_javascriptcore.h" +#elif defined(__ANDROID__) +#include +#include "js_native_api_v8.h" +#endif + +namespace node_api_tests { + +namespace { + +class JsRuntimeHostEnvHolder : public IEnvHolder { + public: + JsRuntimeHostEnvHolder( + std::shared_ptr /*taskRunner*/, + std::function onUnhandledError) + : onUnhandledError_(std::move(onUnhandledError)) { +#if defined(__APPLE__) + context_ = JSGlobalContextCreateInGroup(nullptr, nullptr); + env_ = Napi::Attach(context_); +#elif defined(__ANDROID__) + // TODO: Implement a dedicated V8 environment for Android Node-API tests. + // For now we surface a clear failure so we remember to provide a proper + // implementation before enabling Android execution. + (void)onUnhandledError_; + throw std::runtime_error( + "Android Node-API tests are not yet implemented for node_lite."); +#else + (void)onUnhandledError_; + throw std::runtime_error( + "node_lite is only implemented for Apple platforms in this port."); +#endif + } + + ~JsRuntimeHostEnvHolder() override { +#if defined(__APPLE__) + if (env_ != nullptr) { + Napi::Env napiEnv{env_}; + + if (onUnhandledError_) { + bool hasPending = false; + if (napi_is_exception_pending(env_, &hasPending) == napi_ok && + hasPending) { + napi_value error{}; + if (napi_get_and_clear_last_exception(env_, &error) == napi_ok) { + onUnhandledError_(env_, error); + } + } + } + + Napi::Detach(napiEnv); + env_ = nullptr; + } + + if (context_ != nullptr) { + JSGlobalContextRelease(context_); + context_ = nullptr; + } +#endif + } + + napi_env getEnv() override { return env_; } + + private: +#if defined(__APPLE__) + JSGlobalContextRef context_{}; +#endif + napi_env env_{}; + std::function onUnhandledError_{}; +}; + +} // namespace + +std::unique_ptr CreateEnvHolder( + std::shared_ptr taskRunner, + std::function onUnhandledError) { + return std::make_unique( + std::move(taskRunner), std::move(onUnhandledError)); +} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/node_lite_mac.cpp b/Tests/NodeApi/node_lite_mac.cpp new file mode 100644 index 00000000..ce8ffb17 --- /dev/null +++ b/Tests/NodeApi/node_lite_mac.cpp @@ -0,0 +1,39 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include +#include "node_lite.h" +#include "string_utils.h" + +namespace node_api_tests { + +//============================================================================= +// NodeLitePlatform implementation +//============================================================================= + +/*static*/ void* NodeLitePlatform::LoadFunction( + napi_env env, + const std::filesystem::path& lib_path, + const std::string& function_name) noexcept { + void* library_handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); + if (library_handle == nullptr) { + const char* error_message = dlerror(); + NODE_LITE_ASSERT(false, + "Failed to load dynamic library: %s. Error: %s", + lib_path.c_str(), + error_message != nullptr ? error_message : "Unknown error"); + return nullptr; + } + + dlerror(); // Clear any existing error state before dlsym. + void* symbol = dlsym(library_handle, function_name.c_str()); + const char* error_message = dlerror(); + NODE_LITE_ASSERT(error_message == nullptr, + "Failed to resolve symbol: %s in %s. Error: %s", + function_name.c_str(), + lib_path.c_str(), + error_message != nullptr ? error_message : "Unknown error"); + return symbol; +} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/node_lite_windows.cpp b/Tests/NodeApi/node_lite_windows.cpp new file mode 100644 index 00000000..6b41d83a --- /dev/null +++ b/Tests/NodeApi/node_lite_windows.cpp @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include +#include "node_lite.h" +#include "string_utils.h" + +namespace node_api_tests { + +//============================================================================= +// NodeLitePlatform implementation +//============================================================================= + +/*static*/ void* NodeLitePlatform::LoadFunction( + napi_env env, + const std::filesystem::path& lib_path, + const std::string& function_name) noexcept { + HMODULE dll_module = ::LoadLibraryA(lib_path.string().c_str()); + NODE_LITE_ASSERT(dll_module != NULL, + "Failed to load DLL: %s. Error: %s", + lib_path.c_str(), + std::strerror(errno)); + return ::GetProcAddress(dll_module, function_name.c_str()); +} +} // namespace node_api_tests diff --git a/Tests/NodeApi/string_utils.cpp b/Tests/NodeApi/string_utils.cpp new file mode 100644 index 00000000..583f3e15 --- /dev/null +++ b/Tests/NodeApi/string_utils.cpp @@ -0,0 +1,38 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "string_utils.h" +#include + +namespace node_api_tests { + +std::string FormatString(const char *format, ...) noexcept { + va_list args1; + va_start(args1, format); + va_list args2; + va_copy(args2, args1); + std::string result = + std::string(std::vsnprintf(nullptr, 0, format, args1), '\0'); + va_end(args1); + std::vsnprintf(&result[0], result.size() + 1, format, args2); + va_end(args2); + return result; +} + +std::string ReplaceAll( + std::string str, + std::string_view from, + std::string_view to) noexcept { + std::string result = std::move(str); + if (from.empty()) + return result; + size_t start_pos = 0; + while ((start_pos = result.find(from, start_pos)) != std::string::npos) { + result.replace(start_pos, from.length(), to); + start_pos += to.length(); // In case if 'to' contains 'from', like + // replacing 'x' with 'yx' + } + return result; +} + +} // namespace node_api_tests \ No newline at end of file diff --git a/Tests/NodeApi/string_utils.h b/Tests/NodeApi/string_utils.h new file mode 100644 index 00000000..0d290208 --- /dev/null +++ b/Tests/NodeApi/string_utils.h @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#ifndef NODE_API_TEST_STRING_UTILS_H +#define NODE_API_TEST_STRING_UTILS_H + +#include +#include + +namespace node_api_tests { + +std::string FormatString(const char *format, ...) noexcept; + +std::string ReplaceAll( + std::string str, + std::string_view from, + std::string_view to) noexcept; + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_STRING_UTILS_H \ No newline at end of file diff --git a/Tests/NodeApi/test/.clang-format b/Tests/NodeApi/test/.clang-format new file mode 100644 index 00000000..b3fd9613 --- /dev/null +++ b/Tests/NodeApi/test/.clang-format @@ -0,0 +1,111 @@ +--- +Language: Cpp +# BasedOnStyle: Google +AccessModifierOffset: -1 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Inline +AllowShortIfStatementsOnASingleLine: true +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: true +BinPackArguments: false +BinPackParameters: false +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^' + Priority: 2 + - Regex: '^<.*\.h>' + Priority: 1 + - Regex: '^<.*' + Priority: 2 + - Regex: '.*' + Priority: 3 +IncludeIsMainRegex: '([-_](test|unittest))?$' +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 2 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Auto +TabWidth: 8 +UseTab: Never diff --git a/Tests/NodeApi/test/CMakeLists.txt b/Tests/NodeApi/test/CMakeLists.txt new file mode 100644 index 00000000..01521826 --- /dev/null +++ b/Tests/NodeApi/test/CMakeLists.txt @@ -0,0 +1,91 @@ +if(WIN32) + # "npx" interrupts current shell script execution without the "call" + set(npx cmd /c npx) + set(yarn cmd /c yarn) +else() + set(npx "npx") + set(yarn "yarn") +endif() + +# copy JS Tools package files +add_custom_command( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/babel.config.js + ${CMAKE_CURRENT_BINARY_DIR}/package.json + ${CMAKE_CURRENT_BINARY_DIR}/yarn.lock + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${CMAKE_CURRENT_SOURCE_DIR}/babel.config.js + ${CMAKE_CURRENT_SOURCE_DIR}/package.json + ${CMAKE_CURRENT_SOURCE_DIR}/yarn.lock + ${CMAKE_CURRENT_BINARY_DIR} +) +add_custom_target(copyNodeApiJSToolsFiles) + +# run "yarn install" +add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/node_modules.sha1 + DEPENDS + ${CMAKE_CURRENT_BINARY_DIR}/package.json + ${CMAKE_CURRENT_BINARY_DIR}/yarn.lock + COMMAND ${yarn} install --frozen-lockfile + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} +) +add_custom_target(installNodeApiTestJsTools + DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/node_modules.sha1 +) +add_dependencies(installNodeApiTestJsTools copyNodeApiJSToolsFiles) + +# add the Babel transform commands for each test JS file +set(testJSRootDir ${CMAKE_CURRENT_SOURCE_DIR}) + +# Collect all .js files recursively +file(GLOB_RECURSE basicsTestJSFiles "basics/*.js") +file(GLOB_RECURSE commonTestJSFiles "common/*.js") +file(GLOB_RECURSE jsNativeApiTestJSFiles "js-native-api/*.js") +set(testJSFiles + ${basicsTestJSFiles} + ${commonTestJSFiles} + ${jsNativeApiTestJSFiles}) + +foreach(absoluteTestJSFile ${testJSFiles}) + # create target directory + file(RELATIVE_PATH testJSFile ${testJSRootDir} ${absoluteTestJSFile}) + get_filename_component(testJSDir ${testJSFile} DIRECTORY) + file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${testJSDir}) + + # generate Hermes-compatible JavaScript code + add_custom_command( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/${testJSFile} + ${CMAKE_CURRENT_BINARY_DIR}/${testJSFile}.map + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${testJSFile} + COMMAND + ${npx} + "babel" + "--retain-lines" + "--source-maps" + "true" + "--out-file" + "${CMAKE_CURRENT_BINARY_DIR}/${testJSFile}" + "--source-map-target" + "${CMAKE_CURRENT_BINARY_DIR}/${testJSFile}.map" + "${CMAKE_CURRENT_SOURCE_DIR}/${testJSFile}" + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + + # build a list of all outputs + list(APPEND transformedJSFiles + ${CMAKE_CURRENT_BINARY_DIR}/${testJSFile} + ${CMAKE_CURRENT_BINARY_DIR}/${testJSFile}.map + ) +endforeach() + +# run the Babel transforms for all required output files +add_custom_target(transformJSFiles + DEPENDS ${transformedJSFiles} +) +add_dependencies(transformJSFiles installNodeApiTestJsTools) + +if(JSR_NODE_API_BUILD_NATIVE_TESTS) + add_subdirectory(js-native-api) +endif() diff --git a/Tests/NodeApi/test/babel.config.js b/Tests/NodeApi/test/babel.config.js new file mode 100644 index 00000000..c8cda4fe --- /dev/null +++ b/Tests/NodeApi/test/babel.config.js @@ -0,0 +1,6 @@ +module.exports = { + presets: [ + ['module:@react-native/babel-preset', + { "unstable_transformProfile": "hermes-canary"}] + ], +}; \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/async_rejected.js b/Tests/NodeApi/test/basics/async_rejected.js new file mode 100644 index 00000000..3c2d956a --- /dev/null +++ b/Tests/NodeApi/test/basics/async_rejected.js @@ -0,0 +1,19 @@ +function resolveAfterTimeout() { + return new Promise((_, reject) => { + setTimeout(() => { + reject("test async rejected"); + }, 0); + }); +} + +async function asyncCall() { + console.log("test async calling"); + try { + const result = await resolveAfterTimeout(); + console.log(`Unexpected: ${result}`); + } catch (error) { + console.error(`Expected: ${error}`); + } +} + +asyncCall(); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/async_resolved.js b/Tests/NodeApi/test/basics/async_resolved.js new file mode 100644 index 00000000..d9b44145 --- /dev/null +++ b/Tests/NodeApi/test/basics/async_resolved.js @@ -0,0 +1,15 @@ +function resolveAfterTimeout() { + return new Promise((resolve) => { + setTimeout(() => { + resolve("test async resolved"); + }, 0); + }); +} + +async function asyncCall() { + console.log("test async calling"); + const result = await resolveAfterTimeout(); + console.log(`Expected: ${result}`); +} + +asyncCall(); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/hello.js b/Tests/NodeApi/test/basics/hello.js new file mode 100644 index 00000000..7a2bb74e --- /dev/null +++ b/Tests/NodeApi/test/basics/hello.js @@ -0,0 +1 @@ +console.log("Hello"); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/mustcall_failure.js b/Tests/NodeApi/test/basics/mustcall_failure.js new file mode 100644 index 00000000..105650f8 --- /dev/null +++ b/Tests/NodeApi/test/basics/mustcall_failure.js @@ -0,0 +1,3 @@ +const common = require('../common'); + +common.mustCall(); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/mustcall_success.js b/Tests/NodeApi/test/basics/mustcall_success.js new file mode 100644 index 00000000..cec9ac6a --- /dev/null +++ b/Tests/NodeApi/test/basics/mustcall_success.js @@ -0,0 +1,4 @@ +const common = require('../common'); + +var fn = common.mustCall(); +fn(); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/mustnotcall_failure.js b/Tests/NodeApi/test/basics/mustnotcall_failure.js new file mode 100644 index 00000000..49db06cc --- /dev/null +++ b/Tests/NodeApi/test/basics/mustnotcall_failure.js @@ -0,0 +1,4 @@ +const common = require('../common'); + +var fn = common.mustNotCall(); +fn(); \ No newline at end of file diff --git a/Tests/NodeApi/test/basics/mustnotcall_success.js b/Tests/NodeApi/test/basics/mustnotcall_success.js new file mode 100644 index 00000000..b933a30f --- /dev/null +++ b/Tests/NodeApi/test/basics/mustnotcall_success.js @@ -0,0 +1,3 @@ +const common = require('../common'); + +common.mustNotCall(); diff --git a/Tests/NodeApi/test/basics/throw_string.js b/Tests/NodeApi/test/basics/throw_string.js new file mode 100644 index 00000000..f6cc7b60 --- /dev/null +++ b/Tests/NodeApi/test/basics/throw_string.js @@ -0,0 +1 @@ +throw "Script failed"; \ No newline at end of file diff --git a/Tests/NodeApi/test/common/assert.js b/Tests/NodeApi/test/common/assert.js new file mode 100644 index 00000000..12bb4dac --- /dev/null +++ b/Tests/NodeApi/test/common/assert.js @@ -0,0 +1,400 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// The JavaScript code in this file is adopted from the Node.js project. +// See the src\napi\Readme.md about the Node.js copyright notice. + +"use strict"; + +class AssertionError extends Error { + constructor(options) { + const { message, actual, expected, method, errorStack } = options; + + super(String(message)); + + this.name = "AssertionError"; + this.method = String(method); + this.actual = String(actual); + this.expected = String(expected); + this.errorStack = errorStack || ""; + setAssertionSource(this, method); + } +} + +function setAssertionSource(error, method) { + let result = { sourceFile: "", sourceLine: 0 }; + const stackArray = (error.errorStack || error.stack).split("\n"); + const methodNamePattern = `${method} (`; + let methodNameFound = false; + for (const stackFrame of stackArray) { + if (methodNameFound) { + const stackFrameParts = stackFrame.split(":"); + if (stackFrameParts.length >= 2) { + let sourceFile = stackFrameParts[0]; + if (sourceFile.startsWith(" at ")) { + sourceFile = sourceFile.substr(7); + } + result = { sourceFile, sourceLine: Number(stackFrameParts[1]) }; + } + break; + } else { + methodNameFound = stackFrame.indexOf(methodNamePattern) >= 0; + } + } + Object.assign(error, result); +} + +const assert = (module.exports = ok); + +assert.fail = function fail(message) { + message = message || "Failed"; + let errorInfo = message; + if (typeof message !== "object") { + errorInfo = { message, method: fail.name }; + } + throw new AssertionError(errorInfo); +}; + +function innerOk(fn, argLen, value, message) { + if (!value) { + if (argLen === 0) { + message = "No value argument passed to `assert.ok()`"; + } else if (message == null) { + message = "The expression evaluated to a falsy value"; + } + + assert.fail({ + message, + actual: formatValue(value), + expected: formatValue(true), + method: fn.name, + }); + } +} + +// Pure assertion tests whether a value is truthy, as determined by !!value. +function ok(...args) { + innerOk(ok, args.length, ...args); +} +assert.ok = ok; + +let compareErrorMessage = undefined; +function innerComparison( + method, + compare, + defaultMessage, + argLen, + actual, + expected, + message +) { + if (!compare(actual, expected)) { + if (argLen < 2) { + message = `'assert.${method.name}' expects two or more arguments.`; + } else if (message == null) { + message = defaultMessage; + } + if (typeof compareErrorMessage === "string") { + message += "; " + compareErrorMessage; + compareErrorMessage = undefined; + } + assert.fail({ + message, + actual: formatValue(actual), + expected: formatValue(expected), + method: method.name, + }); + } +} + +assert.strictEqual = function strictEqual(...args) { + innerComparison( + strictEqual, + Object.is, + "Values are not strict equal", + args.length, + ...args + ); +}; + +assert.notStrictEqual = function notStrictEqual(...args) { + innerComparison( + notStrictEqual, + negate(Object.is), + "Values must not be strict equal", + args.length, + ...args + ); +}; + +assert.deepStrictEqual = function deepStrictEqual(...args) { + innerComparison( + deepStrictEqual, + isDeepStrictEqual, + "Values are not deep strict equal", + args.length, + ...args + ); +}; + +assert.notDeepStrictEqual = function notDeepStrictEqual(...args) { + innerComparison( + notDeepStrictEqual, + negate(isDeepStrictEqual), + "Values must not be deep strict equal", + args.length, + ...args + ); +}; + +function innerThrows(method, argLen, fn, expected, message) { + let actual = "Did not throw"; + function succeeds() { + try { + fn(); + return false; + } catch (error) { + if (typeof expected === "function") { + if (expected.prototype !== undefined && error instanceof expected) { + return true; + } else { + return expected(error); + } + } else if (expected instanceof RegExp) { + actual = `${error.name}: ${error.message}`; + return expected.test(actual); + } else if (expected) { + actual = `${error.name}: ${error.message}`; + if (expected.name && expected.name != error.name) { + return false; + } else if (expected.message && expected.message != error.message) { + return false; + } else if (expected.code && expected.code != error.code) { + return false; + } + } + return true; + } + } + + if (argLen < 1 || typeof fn !== "function") { + message = `'assert.${method.name}' expects a function parameter.`; + } else if (message == null) { + if (expected) { + message = `'assert.${method.name}' failed to throw an exception that matches '${expected}'.`; + } else { + message = `'assert.${method.name}' failed to throw an exception.`; + } + } + + if (!succeeds()) { + throw new AssertionError({ + message, + actual, + expected, + method: method.name, + }); + } +} + +assert.throws = function throws(...args) { + innerThrows(throws, args.length, ...args); +}; + +function innerMatch(method, argLen, value, expected, message) { + let succeeds = false; + if (argLen < 1 || typeof value !== "string") { + message = `'assert.${method.name}' expects a string parameter.`; + } else if (!(expected instanceof RegExp)) { + message = `'assert.${method.name}' expects a RegExp as a second parameter.`; + } else { + succeeds = expected.test(value); + if (!succeeds && message == null) { + message = `'assert.${method.name}' failed to match '${expected}'.`; + } + } + + if (!succeeds) { + throw new AssertionError({ + message, + actual: value, + expected, + method: method.name, + }); + } +} + +assert.match = function match(...args) { + innerMatch(match, args.length, ...args); +}; + +function negate(compare) { + return (...args) => !compare(...args); +} + +function isDeepStrictEqual(left, right) { + function check(left, right) { + if (left === right) { + return true; + } + if (typeof left !== typeof right) { + compareErrorMessage = `Different types: ${typeof left} vs ${typeof right}`; + return false; + } + if (Array.isArray(left)) { + return Array.isArray(right) && checkArray(left, right); + } + if (typeof left === "number") { + return isNaN(left) && isNaN(right); + } + if (typeof left === "object") { + return typeof right === "object" && checkObject(left, right); + } + return false; + } + + function checkArray(left, right) { + if (left.length !== right.length) { + compareErrorMessage = `Different array lengths: ${left.length} vs ${right.length}`; + return false; + } + for (let i = 0; i < left.length; ++i) { + if (!check(left[i], right[i])) { + compareErrorMessage = `Different values at index ${i}: ${left[i]} vs ${right[i]}`; + return false; + } + } + return true; + } + + function checkObject(left, right) { + const leftNames = Object.getOwnPropertyNames(left); + const rightNames = Object.getOwnPropertyNames(right); + if (leftNames.length !== rightNames.length) { + compareErrorMessage = `Different set of property names: ${leftNames.length} vs ${rightNames.length}`; + return false; + } + for (let i = 0; i < leftNames.length; ++i) { + if (!check(left[leftNames[i]], right[leftNames[i]])) { + compareErrorMessage = `Different values for property '${leftNames[i]}': ${left[leftNames[i]]} vs ${right[leftNames[i]]}`; + return false; + } + } + const leftSymbols = Object.getOwnPropertySymbols(left); + const rightSymbols = Object.getOwnPropertySymbols(right); + if (leftSymbols.length !== rightSymbols.length) { + compareErrorMessage = `Different set of symbol names: ${leftSymbols.length} vs ${rightSymbols.length}`; + return false; + } + for (let i = 0; i < leftSymbols.length; ++i) { + if (!check(left[leftSymbols[i]], right[leftSymbols[i]])) { + compareErrorMessage = `${leftSymbols[i].toString()}: different value`; + return false; + } + } + return check(Object.getPrototypeOf(left), Object.getPrototypeOf(right)); + } + + return check(left, right); +} + +const mustCallChecks = []; + +function runCallChecks() { + const failed = mustCallChecks.filter((context) => { + if ("minimum" in context) { + context.messageSegment = `at least ${context.minimum}`; + return context.actual < context.minimum; + } + context.messageSegment = `exactly ${context.exact}`; + return context.actual !== context.exact; + }); + + mustCallChecks.length = 0; + + failed.forEach((context) => { + assert.fail({ + message: `Mismatched ${context.name} function calls`, + actual: `${context.actual} calls`, + expected: `${context.messageSegment} calls`, + method: context.method.name, + errorStack: context.stack, + }); + }); +}; +assert.runCallChecks = runCallChecks; + +function getCallSite() { + try { + throw new Error(""); + } catch (err) { + return err.stack; + } +} + +assert.mustNotCall = function mustNotCall(msg) { + return function mustNotCall(...args) { + assert.fail({ + message: String(msg || "Function should not have been called"), + actual: + args.length > 0 + ? `Called with arguments: ${args.map(String).join(", ")}` + : "Called without arguments", + expected: "Not to be called", + method: mustNotCall.name, + }); + }; +}; + +assert.mustCall = function mustCall(fn, exact) { + return _mustCallInner(fn, exact, "exact", mustCall); +}; + +assert.mustCallAtLeast = function mustCallAtLeast(fn, minimum) { + return _mustCallInner(fn, minimum, "minimum", mustCallAtLeast); +}; + +const noop = () => {}; + +function _mustCallInner(fn, criteria = 1, field, method) { + if (typeof fn === "number") { + criteria = fn; + fn = noop; + } else if (fn === undefined) { + fn = noop; + } + + if (typeof criteria !== "number") { + throw new TypeError(`Invalid ${field} value: ${criteria}`); + } + + const context = { + [field]: criteria, + actual: 0, + stack: getCallSite(), + name: fn.name || "", + method, + }; + + // Add the exit listener only once to avoid listener leak warnings + if (mustCallChecks.length === 0) process.on('exit', runCallChecks); + + mustCallChecks.push(context); + + return function () { + context.actual++; + return fn.apply(this, arguments); + }; +} + +function formatValue(value) { + let type = typeof value; + if (type === "object") { + if (Array.isArray(value)) { + return " []"; + } else { + return " {}"; + } + } + return `<${type}> ${value}`; +} diff --git a/Tests/NodeApi/test/common/gc.js b/Tests/NodeApi/test/common/gc.js new file mode 100644 index 00000000..66f77055 --- /dev/null +++ b/Tests/NodeApi/test/common/gc.js @@ -0,0 +1,34 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// The JavaScript code in this file is adopted from the Node.js project. +// See the src\napi\Readme.md about the Node.js copyright notice. +"use strict"; + +function gcUntil(name, condition) { + if (typeof name === "function") { + condition = name; + name = undefined; + } + return new Promise((resolve, reject) => { + let count = 0; + function gcAndCheck() { + setImmediate(() => { + count++; + global.gc(); + if (condition()) { + resolve(); + } else if (count < 10) { + gcAndCheck(); + } else { + reject(name === undefined ? undefined : "Test " + name + " failed"); + } + }); + } + gcAndCheck(); + }); +} + +Object.assign(module.exports, { + gcUntil, +}); diff --git a/Tests/NodeApi/test/common/index.js b/Tests/NodeApi/test/common/index.js new file mode 100644 index 00000000..e4ec6151 --- /dev/null +++ b/Tests/NodeApi/test/common/index.js @@ -0,0 +1,57 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// The JavaScript code in this file is adopted from the Node.js project. +// See the src\napi\Readme.md about the Node.js copyright notice. +"use strict"; + +const { mustCall, mustCallAtLeast, mustNotCall } = require("assert"); +const { gcUntil } = require("gc"); + +const buildType = process.target_config; +const isWindows = process.platform === 'win32'; + +// Returns true if the exit code "exitCode" and/or signal name "signal" +// represent the exit code and/or signal name of a node process that aborted, +// false otherwise. +function nodeProcessAborted(exitCode, signal) { + // Depending on the compiler used, node will exit with either + // exit code 132 (SIGILL), 133 (SIGTRAP) or 134 (SIGABRT). + let expectedExitCodes = [132, 133, 134]; + + // On platforms using KSH as the default shell (like SmartOS), + // when a process aborts, KSH exits with an exit code that is + // greater than 256, and thus the exit code emitted with the 'exit' + // event is null and the signal is set to either SIGILL, SIGTRAP, + // or SIGABRT (depending on the compiler). + const expectedSignals = ['SIGILL', 'SIGTRAP', 'SIGABRT']; + + // On Windows, 'aborts' are of 2 types, depending on the context: + // (i) Exception breakpoint, if --abort-on-uncaught-exception is on + // which corresponds to exit code 2147483651 (0x80000003) + // (ii) Otherwise, _exit(134) which is called in place of abort() due to + // raising SIGABRT exiting with ambiguous exit code '3' by default + if (isWindows) + expectedExitCodes = [0x80000003, 134]; + + // When using --abort-on-uncaught-exception, V8 will use + // base::OS::Abort to terminate the process. + // Depending on the compiler used, the shell or other aspects of + // the platform used to build the node binary, this will actually + // make V8 exit by aborting or by raising a signal. In any case, + // one of them (exit code or signal) needs to be set to one of + // the expected exit codes or signals. + if (signal !== null) { + return expectedSignals.includes(signal); + } + return expectedExitCodes.includes(exitCode); +} + +Object.assign(module.exports, { + buildType, + gcUntil, + mustCall, + mustCallAtLeast, + mustNotCall, + nodeProcessAborted, +}); \ No newline at end of file diff --git a/Tests/NodeApi/test/js-native-api/.gitignore b/Tests/NodeApi/test/js-native-api/.gitignore new file mode 100644 index 00000000..6e29bde8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/.gitignore @@ -0,0 +1,7 @@ +.buildstamp +.docbuildstamp +Makefile +*.Makefile +*.mk +gyp-mac-tool +/*/build diff --git a/Tests/NodeApi/test/js-native-api/2_function_arguments/2_function_arguments.c b/Tests/NodeApi/test/js-native-api/2_function_arguments/2_function_arguments.c new file mode 100644 index 00000000..c03085db --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/2_function_arguments/2_function_arguments.c @@ -0,0 +1,39 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value Add(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype0 == napi_number && valuetype1 == napi_number, + "Wrong argument type. Numbers expected."); + + double value0; + NODE_API_CALL(env, napi_get_value_double(env, args[0], &value0)); + + double value1; + NODE_API_CALL(env, napi_get_value_double(env, args[1], &value1)); + + napi_value sum; + NODE_API_CALL(env, napi_create_double(env, value0 + value1, &sum)); + + return sum; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor desc = DECLARE_NODE_API_PROPERTY("add", Add); + NODE_API_CALL(env, napi_define_properties(env, exports, 1, &desc)); + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/2_function_arguments/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/2_function_arguments/CMakeLists.txt new file mode 100644 index 00000000..258ed16e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/2_function_arguments/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(2_function_arguments + SOURCES + 2_function_arguments.c +) diff --git a/Tests/NodeApi/test/js-native-api/2_function_arguments/binding.gyp b/Tests/NodeApi/test/js-native-api/2_function_arguments/binding.gyp new file mode 100644 index 00000000..8f89a61e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/2_function_arguments/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "2_function_arguments", + "sources": [ + "2_function_arguments.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/2_function_arguments/test.js b/Tests/NodeApi/test/js-native-api/2_function_arguments/test.js new file mode 100644 index 00000000..2966cc0b --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/2_function_arguments/test.js @@ -0,0 +1,6 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/2_function_arguments`); + +assert.strictEqual(addon.add(3, 5), 8); diff --git a/Tests/NodeApi/test/js-native-api/3_callbacks/3_callbacks.c b/Tests/NodeApi/test/js-native-api/3_callbacks/3_callbacks.c new file mode 100644 index 00000000..fd7b6618 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/3_callbacks/3_callbacks.c @@ -0,0 +1,58 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value RunCallback(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, + "Wrong number of arguments. Expects a single argument."); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + NODE_API_ASSERT(env, valuetype0 == napi_function, + "Wrong type of arguments. Expects a function as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + NODE_API_ASSERT(env, valuetype1 == napi_undefined, + "Additional arguments should be undefined."); + + napi_value argv[1]; + const char* str = "hello world"; + size_t str_len = strlen(str); + NODE_API_CALL(env, napi_create_string_utf8(env, str, str_len, argv)); + + napi_value global; + NODE_API_CALL(env, napi_get_global(env, &global)); + + napi_value cb = args[0]; + NODE_API_CALL(env, napi_call_function(env, global, cb, 1, argv, NULL)); + + return NULL; +} + +static napi_value RunCallbackWithRecv(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value cb = args[0]; + napi_value recv = args[1]; + NODE_API_CALL(env, napi_call_function(env, recv, cb, 0, NULL, NULL)); + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor desc[2] = { + DECLARE_NODE_API_PROPERTY("RunCallback", RunCallback), + DECLARE_NODE_API_PROPERTY("RunCallbackWithRecv", RunCallbackWithRecv), + }; + NODE_API_CALL(env, napi_define_properties(env, exports, 2, desc)); + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/3_callbacks/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/3_callbacks/CMakeLists.txt new file mode 100644 index 00000000..02134621 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/3_callbacks/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(3_callbacks + SOURCES + 3_callbacks.c +) diff --git a/Tests/NodeApi/test/js-native-api/3_callbacks/binding.gyp b/Tests/NodeApi/test/js-native-api/3_callbacks/binding.gyp new file mode 100644 index 00000000..d64b5e48 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/3_callbacks/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "3_callbacks", + "sources": [ + "3_callbacks.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/3_callbacks/test.js b/Tests/NodeApi/test/js-native-api/3_callbacks/test.js new file mode 100644 index 00000000..ace0f2a7 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/3_callbacks/test.js @@ -0,0 +1,22 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/3_callbacks`); + +addon.RunCallback(function(msg) { + assert.strictEqual(msg, 'hello world'); +}); + +function testRecv(desiredRecv) { + addon.RunCallbackWithRecv(function() { + assert.strictEqual(this, desiredRecv); + }, desiredRecv); +} + +testRecv(undefined); +testRecv(null); +testRecv(5); +testRecv(true); +testRecv('Hello'); +testRecv([]); +testRecv({}); diff --git a/Tests/NodeApi/test/js-native-api/4_object_factory/4_object_factory.c b/Tests/NodeApi/test/js-native-api/4_object_factory/4_object_factory.c new file mode 100644 index 00000000..38169b0f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/4_object_factory/4_object_factory.c @@ -0,0 +1,24 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value CreateObject(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value obj; + NODE_API_CALL(env, napi_create_object(env, &obj)); + + NODE_API_CALL(env, napi_set_named_property(env, obj, "msg", args[0])); + + return obj; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + NODE_API_CALL(env, + napi_create_function(env, "exports", -1, CreateObject, NULL, &exports)); + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/4_object_factory/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/4_object_factory/CMakeLists.txt new file mode 100644 index 00000000..b4a9917c --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/4_object_factory/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(4_object_factory + SOURCES + 4_object_factory.c +) diff --git a/Tests/NodeApi/test/js-native-api/4_object_factory/binding.gyp b/Tests/NodeApi/test/js-native-api/4_object_factory/binding.gyp new file mode 100644 index 00000000..86f8b1f0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/4_object_factory/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "4_object_factory", + "sources": [ + "4_object_factory.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/4_object_factory/test.js b/Tests/NodeApi/test/js-native-api/4_object_factory/test.js new file mode 100644 index 00000000..fbfbd67f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/4_object_factory/test.js @@ -0,0 +1,8 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/4_object_factory`); + +const obj1 = addon('hello'); +const obj2 = addon('world'); +assert.strictEqual(`${obj1.msg} ${obj2.msg}`, 'hello world'); diff --git a/Tests/NodeApi/test/js-native-api/5_function_factory/5_function_factory.c b/Tests/NodeApi/test/js-native-api/5_function_factory/5_function_factory.c new file mode 100644 index 00000000..744a8c72 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/5_function_factory/5_function_factory.c @@ -0,0 +1,24 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value MyFunction(napi_env env, napi_callback_info info) { + napi_value str; + NODE_API_CALL(env, napi_create_string_utf8(env, "hello world", -1, &str)); + return str; +} + +static napi_value CreateFunction(napi_env env, napi_callback_info info) { + napi_value fn; + NODE_API_CALL(env, + napi_create_function(env, "theFunction", -1, MyFunction, NULL, &fn)); + return fn; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + NODE_API_CALL(env, + napi_create_function(env, "exports", -1, CreateFunction, NULL, &exports)); + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/5_function_factory/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/5_function_factory/CMakeLists.txt new file mode 100644 index 00000000..4a7e51a7 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/5_function_factory/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(5_function_factory + SOURCES + 5_function_factory.c +) diff --git a/Tests/NodeApi/test/js-native-api/5_function_factory/binding.gyp b/Tests/NodeApi/test/js-native-api/5_function_factory/binding.gyp new file mode 100644 index 00000000..06bd385e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/5_function_factory/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "5_function_factory", + "sources": [ + "5_function_factory.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/5_function_factory/test.js b/Tests/NodeApi/test/js-native-api/5_function_factory/test.js new file mode 100644 index 00000000..bacb22ce --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/5_function_factory/test.js @@ -0,0 +1,7 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/5_function_factory`); + +const fn = addon(); +assert.strictEqual(fn(), 'hello world'); // 'hello world' diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/6_object_wrap/CMakeLists.txt new file mode 100644 index 00000000..27486730 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/CMakeLists.txt @@ -0,0 +1,21 @@ +add_node_api_module(myobject + SOURCES + myobject.cc + myobject.h +) + +add_node_api_module(myobject_basic_finalizer + SOURCES + myobject.cc + myobject.h + DEFINES + NAPI_EXPERIMENTAL +) + +add_node_api_module(nested_wrap + SOURCES + nested_wrap.cc + nested_wrap.h + DEFINES + "NAPI_VERSION=10" +) diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/binding.gyp b/Tests/NodeApi/test/js-native-api/6_object_wrap/binding.gyp new file mode 100644 index 00000000..e7a9d7ba --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/binding.gyp @@ -0,0 +1,28 @@ +{ + "targets": [ + { + "target_name": "myobject", + "sources": [ + "myobject.cc", + "myobject.h", + ] + }, + { + "target_name": "myobject_basic_finalizer", + "defines": [ "NAPI_EXPERIMENTAL" ], + "sources": [ + "myobject.cc", + "myobject.h", + ] + }, + { + "target_name": "nested_wrap", + # Test without basic finalizers as it schedules differently. + "defines": [ "NAPI_VERSION=10" ], + "sources": [ + "nested_wrap.cc", + "nested_wrap.h", + ], + }, + ] +} diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.cc b/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.cc new file mode 100644 index 00000000..5633d929 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.cc @@ -0,0 +1,270 @@ +#include "myobject.h" +#include "../common.h" +#include "../entry_point.h" +#include "assert.h" + +typedef int32_t FinalizerData; + +napi_ref MyObject::constructor; + +MyObject::MyObject(double value) + : value_(value), env_(nullptr), wrapper_(nullptr) {} + +MyObject::~MyObject() { + napi_delete_reference(env_, wrapper_); +} + +void MyObject::Destructor(node_api_basic_env env, + void* nativeObject, + void* /*finalize_hint*/) { + MyObject* obj = static_cast(nativeObject); + delete obj; + + FinalizerData* data; + NODE_API_BASIC_CALL_RETURN_VOID( + env, napi_get_instance_data(env, reinterpret_cast(&data))); + *data += 1; +} + +void MyObject::Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + {"value", nullptr, nullptr, GetValue, SetValue, 0, napi_default, 0}, + {"valueReadonly", + nullptr, + nullptr, + GetValue, + nullptr, + 0, + napi_default, + 0}, + DECLARE_NODE_API_PROPERTY("plusOne", PlusOne), + DECLARE_NODE_API_PROPERTY("multiply", Multiply), + }; + + napi_value cons; + NODE_API_CALL_RETURN_VOID( + env, + napi_define_class(env, + "MyObject", + -1, + New, + nullptr, + sizeof(properties) / sizeof(napi_property_descriptor), + properties, + &cons)); + + NODE_API_CALL_RETURN_VOID(env, + napi_create_reference(env, cons, 1, &constructor)); + + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, exports, "MyObject", cons)); +} + +napi_value MyObject::New(napi_env env, napi_callback_info info) { + napi_value new_target; + NODE_API_CALL(env, napi_get_new_target(env, info, &new_target)); + bool is_constructor = (new_target != nullptr); + + size_t argc = 1; + napi_value args[1]; + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr)); + + if (is_constructor) { + // Invoked as constructor: `new MyObject(...)` + double value = 0; + + napi_valuetype valuetype; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype)); + + if (valuetype != napi_undefined) { + NODE_API_CALL(env, napi_get_value_double(env, args[0], &value)); + } + + MyObject* obj = new MyObject(value); + + obj->env_ = env; + NODE_API_CALL(env, + napi_wrap(env, + _this, + obj, + MyObject::Destructor, + nullptr /* finalize_hint */, + &obj->wrapper_)); + + return _this; + } + + // Invoked as plain function `MyObject(...)`, turn into construct call. + argc = 1; + napi_value argv[1] = {args[0]}; + + napi_value cons; + NODE_API_CALL(env, napi_get_reference_value(env, constructor, &cons)); + + napi_value instance; + NODE_API_CALL(env, napi_new_instance(env, cons, argc, argv, &instance)); + + return instance; +} + +napi_value MyObject::GetValue(napi_env env, napi_callback_info info) { + napi_value _this; + NODE_API_CALL(env, + napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr)); + + MyObject* obj; + NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast(&obj))); + + napi_value num; + NODE_API_CALL(env, napi_create_double(env, obj->value_, &num)); + + return num; +} + +napi_value MyObject::SetValue(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr)); + + MyObject* obj; + NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast(&obj))); + + NODE_API_CALL(env, napi_get_value_double(env, args[0], &obj->value_)); + + return nullptr; +} + +napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) { + napi_value _this; + NODE_API_CALL(env, + napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr)); + + MyObject* obj; + NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast(&obj))); + + obj->value_ += 1; + + napi_value num; + NODE_API_CALL(env, napi_create_double(env, obj->value_, &num)); + + return num; +} + +napi_value MyObject::Multiply(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr)); + + double multiple = 1; + if (argc >= 1) { + NODE_API_CALL(env, napi_get_value_double(env, args[0], &multiple)); + } + + MyObject* obj; + NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast(&obj))); + + napi_value cons; + NODE_API_CALL(env, napi_get_reference_value(env, constructor, &cons)); + + const int kArgCount = 1; + napi_value argv[kArgCount]; + NODE_API_CALL(env, napi_create_double(env, obj->value_ * multiple, argv)); + + napi_value instance; + NODE_API_CALL(env, napi_new_instance(env, cons, kArgCount, argv, &instance)); + + return instance; +} + +// This finalizer should never be invoked. +void ObjectWrapDanglingReferenceFinalizer(node_api_basic_env env, + void* finalize_data, + void* finalize_hint) { + assert(0 && "unreachable"); +} + +napi_ref dangling_ref; +napi_value ObjectWrapDanglingReference(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + // Create a napi_wrap and remove it immediately, whilst leaving the out-param + // ref dangling (not deleted). + NODE_API_CALL(env, + napi_wrap(env, + args[0], + nullptr, + ObjectWrapDanglingReferenceFinalizer, + nullptr, + &dangling_ref)); + NODE_API_CALL(env, napi_remove_wrap(env, args[0], nullptr)); + + return args[0]; +} + +napi_value ObjectWrapDanglingReferenceTest(napi_env env, + napi_callback_info info) { + napi_value out; + napi_value ret; + NODE_API_CALL(env, napi_get_reference_value(env, dangling_ref, &out)); + + if (out == nullptr) { + // If the napi_ref has been invalidated, delete it. + NODE_API_CALL(env, napi_delete_reference(env, dangling_ref)); + NODE_API_CALL(env, napi_get_boolean(env, true, &ret)); + } else { + // The dangling napi_ref is still valid. + NODE_API_CALL(env, napi_get_boolean(env, false, &ret)); + } + return ret; +} + +static napi_value GetFinalizerCallCount(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value argv[1]; + FinalizerData* data; + napi_value result; + + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + NODE_API_CALL(env, + napi_get_instance_data(env, reinterpret_cast(&data))); + NODE_API_CALL(env, napi_create_int32(env, *data, &result)); + return result; +} + +static void finalizeData(napi_env env, void* data, void* hint) { + delete reinterpret_cast(data); +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + FinalizerData* data = new FinalizerData; + *data = 0; + NODE_API_CALL(env, napi_set_instance_data(env, data, finalizeData, nullptr)); + + MyObject::Init(env, exports); + + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("objectWrapDanglingReference", + ObjectWrapDanglingReference), + DECLARE_NODE_API_PROPERTY("objectWrapDanglingReferenceTest", + ObjectWrapDanglingReferenceTest), + DECLARE_NODE_API_PROPERTY("getFinalizerCallCount", GetFinalizerCallCount), + }; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.h b/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.h new file mode 100644 index 00000000..fcb2e575 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/myobject.h @@ -0,0 +1,28 @@ +#ifndef TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_ +#define TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_ + +#include + +class MyObject { + public: + static void Init(napi_env env, napi_value exports); + static void Destructor(node_api_basic_env env, + void* nativeObject, + void* finalize_hint); + + private: + explicit MyObject(double value_ = 0); + ~MyObject(); + + static napi_value New(napi_env env, napi_callback_info info); + static napi_value GetValue(napi_env env, napi_callback_info info); + static napi_value SetValue(napi_env env, napi_callback_info info); + static napi_value PlusOne(napi_env env, napi_callback_info info); + static napi_value Multiply(napi_env env, napi_callback_info info); + static napi_ref constructor; + double value_; + napi_env env_; + napi_ref wrapper_; +}; + +#endif // TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_ diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.cc b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.cc new file mode 100644 index 00000000..1c8594c8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.cc @@ -0,0 +1,99 @@ +#include "nested_wrap.h" +#include "../common.h" +#include "../entry_point.h" + +napi_ref NestedWrap::constructor{}; +static int finalization_count = 0; + +NestedWrap::NestedWrap() {} + +NestedWrap::~NestedWrap() { + napi_delete_reference(env_, wrapper_); + + // Delete the nested reference as well. + napi_delete_reference(env_, nested_); +} + +void NestedWrap::Destructor(node_api_basic_env env, + void* nativeObject, + void* /*finalize_hint*/) { + // Once this destructor is called, it cancels all pending + // finalizers for the object by deleting the references. + NestedWrap* obj = static_cast(nativeObject); + delete obj; + + finalization_count++; +} + +void NestedWrap::Init(napi_env env, napi_value exports) { + napi_value cons; + NODE_API_CALL_RETURN_VOID( + env, + napi_define_class( + env, "NestedWrap", -1, New, nullptr, 0, nullptr, &cons)); + + NODE_API_CALL_RETURN_VOID(env, + napi_create_reference(env, cons, 1, &constructor)); + + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, exports, "NestedWrap", cons)); +} + +napi_value NestedWrap::New(napi_env env, napi_callback_info info) { + napi_value new_target; + NODE_API_CALL(env, napi_get_new_target(env, info, &new_target)); + bool is_constructor = (new_target != nullptr); + NODE_API_BASIC_ASSERT_BASE( + is_constructor, "Constructor called without new", nullptr); + + napi_value this_val; + NODE_API_CALL(env, + napi_get_cb_info(env, info, 0, nullptr, &this_val, nullptr)); + + NestedWrap* obj = new NestedWrap(); + + obj->env_ = env; + NODE_API_CALL(env, + napi_wrap(env, + this_val, + obj, + NestedWrap::Destructor, + nullptr /* finalize_hint */, + &obj->wrapper_)); + + // Create a second napi_ref to be deleted in the destructor. + NODE_API_CALL(env, + napi_add_finalizer(env, + this_val, + obj, + NestedWrap::Destructor, + nullptr /* finalize_hint */, + &obj->nested_)); + + return this_val; +} + +static napi_value GetFinalizerCallCount(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_create_int32(env, finalization_count, &result)); + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + NestedWrap::Init(env, exports); + + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("getFinalizerCallCount", GetFinalizerCallCount), + }; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.h b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.h new file mode 100644 index 00000000..584f24de --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.h @@ -0,0 +1,33 @@ +#ifndef TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_ +#define TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_ + +#include + +/** + * Test that an napi_ref can be nested inside another ObjectWrap. + * + * This test shows a critical case where a finalizer deletes an napi_ref + * whose finalizer is also scheduled. + */ + +class NestedWrap { + public: + static void Init(napi_env env, napi_value exports); + static void Destructor(node_api_basic_env env, + void* nativeObject, + void* finalize_hint); + + private: + explicit NestedWrap(); + ~NestedWrap(); + + static napi_value New(napi_env env, napi_callback_info info); + + static napi_ref constructor; + + napi_env env_{}; + napi_ref wrapper_{}; + napi_ref nested_{}; +}; + +#endif // TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_ diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.js b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.js new file mode 100644 index 00000000..726c6931 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/nested_wrap.js @@ -0,0 +1,20 @@ +// Flags: --expose-gc + +'use strict'; +const common = require('../../common'); +const { gcUntil } = require('../../common/gc'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/nested_wrap`); + +// This test verifies that ObjectWrap and napi_ref can be nested and finalized +// correctly with a non-basic finalizer. +(() => { + let obj = new addon.NestedWrap(); + obj = null; + // Silent eslint about unused variables. + assert.strictEqual(obj, null); +})(); + +gcUntil('object-wrap-ref', () => { + return addon.getFinalizerCallCount() === 1; +}); diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/test-basic-finalizer.js b/Tests/NodeApi/test/js-native-api/6_object_wrap/test-basic-finalizer.js new file mode 100644 index 00000000..5a7ccff4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/test-basic-finalizer.js @@ -0,0 +1,24 @@ +// Flags: --expose-gc + +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/myobject_basic_finalizer`); + +// This test verifies that ObjectWrap can be correctly finalized with a node_api_basic_finalizer +// in the current JS loop tick +(() => { + let obj = new addon.MyObject(9); + obj = null; + // Silent eslint about unused variables. + assert.strictEqual(obj, null); +})(); + +for (let i = 0; i < 10; ++i) { + global.gc(); + if (addon.getFinalizerCallCount() === 1) { + break; + } +} + +assert.strictEqual(addon.getFinalizerCallCount(), 1); diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/test-object-wrap-ref.js b/Tests/NodeApi/test/js-native-api/6_object_wrap/test-object-wrap-ref.js new file mode 100644 index 00000000..8f236410 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/test-object-wrap-ref.js @@ -0,0 +1,14 @@ +// Flags: --expose-gc + +'use strict'; +const common = require('../../common'); +const addon = require(`./build/${common.buildType}/myobject`); +const { gcUntil } = require('../../common/gc'); + +(function scope() { + addon.objectWrapDanglingReference({}); +})(); + +gcUntil('object-wrap-ref', () => { + return addon.objectWrapDanglingReferenceTest(); +}); diff --git a/Tests/NodeApi/test/js-native-api/6_object_wrap/test.js b/Tests/NodeApi/test/js-native-api/6_object_wrap/test.js new file mode 100644 index 00000000..809fddf2 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/6_object_wrap/test.js @@ -0,0 +1,48 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/myobject`); + +const getterOnlyErrorRE = + /^TypeError: Cannot (set|assign to) property .*( of #<.*>)? which has only a getter$/; + +const valueDescriptor = Object.getOwnPropertyDescriptor( + addon.MyObject.prototype, 'value'); +const valueReadonlyDescriptor = Object.getOwnPropertyDescriptor( + addon.MyObject.prototype, 'valueReadonly'); +const plusOneDescriptor = Object.getOwnPropertyDescriptor( + addon.MyObject.prototype, 'plusOne'); +assert.strictEqual(typeof valueDescriptor.get, 'function'); +assert.strictEqual(typeof valueDescriptor.set, 'function'); +assert.strictEqual(valueDescriptor.value, undefined); +assert.strictEqual(valueDescriptor.enumerable, false); +assert.strictEqual(valueDescriptor.configurable, false); +assert.strictEqual(typeof valueReadonlyDescriptor.get, 'function'); +assert.strictEqual(valueReadonlyDescriptor.set, undefined); +assert.strictEqual(valueReadonlyDescriptor.value, undefined); +assert.strictEqual(valueReadonlyDescriptor.enumerable, false); +assert.strictEqual(valueReadonlyDescriptor.configurable, false); + +assert.strictEqual(plusOneDescriptor.get, undefined); +assert.strictEqual(plusOneDescriptor.set, undefined); +assert.strictEqual(typeof plusOneDescriptor.value, 'function'); +assert.strictEqual(plusOneDescriptor.enumerable, false); +assert.strictEqual(plusOneDescriptor.configurable, false); + +const obj = new addon.MyObject(9); +assert.strictEqual(obj.value, 9); +obj.value = 10; +assert.strictEqual(obj.value, 10); +assert.strictEqual(obj.valueReadonly, 10); +assert.throws(() => { obj.valueReadonly = 14; }, getterOnlyErrorRE); +assert.strictEqual(obj.plusOne(), 11); +assert.strictEqual(obj.plusOne(), 12); +assert.strictEqual(obj.plusOne(), 13); + +assert.strictEqual(obj.multiply().value, 13); +assert.strictEqual(obj.multiply(10).value, 130); + +const newobj = obj.multiply(-1); +assert.strictEqual(newobj.value, -13); +assert.strictEqual(newobj.valueReadonly, -13); +assert.notStrictEqual(obj, newobj); diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/7_factory_wrap.cc b/Tests/NodeApi/test/js-native-api/7_factory_wrap/7_factory_wrap.cc new file mode 100644 index 00000000..b0ff0063 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/7_factory_wrap.cc @@ -0,0 +1,32 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "myobject.h" + +napi_value CreateObject(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + napi_value instance; + NODE_API_CALL(env, MyObject::NewInstance(env, args[0], &instance)); + + return instance; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + NODE_API_CALL(env, MyObject::Init(env)); + + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_GETTER("finalizeCount", MyObject::GetFinalizeCount), + DECLARE_NODE_API_PROPERTY("createObject", CreateObject), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/7_factory_wrap/CMakeLists.txt new file mode 100644 index 00000000..1ca18670 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/CMakeLists.txt @@ -0,0 +1,5 @@ +add_node_api_module(7_factory_wrap + SOURCES + 7_factory_wrap.cc + myobject.cc +) diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/binding.gyp b/Tests/NodeApi/test/js-native-api/7_factory_wrap/binding.gyp new file mode 100644 index 00000000..f51f7823 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "7_factory_wrap", + "sources": [ + "7_factory_wrap.cc", + "myobject.cc" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.cc b/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.cc new file mode 100644 index 00000000..142c2dab --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.cc @@ -0,0 +1,101 @@ +#include "myobject.h" +#include "../common.h" + +static int finalize_count = 0; + +MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {} + +MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); } + +void MyObject::Destructor(node_api_basic_env env, + void* nativeObject, + void* /*finalize_hint*/) { + ++finalize_count; + MyObject* obj = static_cast(nativeObject); + delete obj; +} + +napi_value MyObject::GetFinalizeCount(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_create_int32(env, finalize_count, &result)); + return result; +} + +napi_ref MyObject::constructor; + +napi_status MyObject::Init(napi_env env) { + napi_status status; + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("plusOne", PlusOne), + }; + + napi_value cons; + status = napi_define_class( + env, "MyObject", -1, New, nullptr, 1, properties, &cons); + if (status != napi_ok) return status; + + status = napi_create_reference(env, cons, 1, &constructor); + if (status != napi_ok) return status; + + return napi_ok; +} + +napi_value MyObject::New(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr)); + + napi_valuetype valuetype; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype)); + + MyObject* obj = new MyObject(); + + if (valuetype == napi_undefined) { + obj->counter_ = 0; + } else { + NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &obj->counter_)); + } + + obj->env_ = env; + NODE_API_CALL(env, + napi_wrap( + env, _this, obj, MyObject::Destructor, nullptr /* finalize_hint */, + &obj->wrapper_)); + + return _this; +} + +napi_status MyObject::NewInstance(napi_env env, + napi_value arg, + napi_value* instance) { + napi_status status; + + const int argc = 1; + napi_value argv[argc] = {arg}; + + napi_value cons; + status = napi_get_reference_value(env, constructor, &cons); + if (status != napi_ok) return status; + + status = napi_new_instance(env, cons, argc, argv, instance); + if (status != napi_ok) return status; + + return napi_ok; +} + +napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) { + napi_value _this; + NODE_API_CALL(env, + napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr)); + + MyObject* obj; + NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast(&obj))); + + obj->counter_ += 1; + + napi_value num; + NODE_API_CALL(env, napi_create_uint32(env, obj->counter_, &num)); + + return num; +} diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.h b/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.h new file mode 100644 index 00000000..aa2b199a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/myobject.h @@ -0,0 +1,27 @@ +#ifndef TEST_JS_NATIVE_API_7_FACTORY_WRAP_MYOBJECT_H_ +#define TEST_JS_NATIVE_API_7_FACTORY_WRAP_MYOBJECT_H_ + +#include + +class MyObject { + public: + static napi_status Init(napi_env env); + static void + Destructor(node_api_basic_env env, void *nativeObject, void *finalize_hint); + static napi_value GetFinalizeCount(napi_env env, napi_callback_info info); + static napi_status + NewInstance(napi_env env, napi_value arg, napi_value *instance); + + private: + MyObject(); + ~MyObject(); + + static napi_ref constructor; + static napi_value New(napi_env env, napi_callback_info info); + static napi_value PlusOne(napi_env env, napi_callback_info info); + uint32_t counter_; + napi_env env_; + napi_ref wrapper_; +}; + +#endif // TEST_JS_NATIVE_API_7_FACTORY_WRAP_MYOBJECT_H_ diff --git a/Tests/NodeApi/test/js-native-api/7_factory_wrap/test.js b/Tests/NodeApi/test/js-native-api/7_factory_wrap/test.js new file mode 100644 index 00000000..23840b36 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/7_factory_wrap/test.js @@ -0,0 +1,27 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const assert = require('assert'); +const test = require(`./build/${common.buildType}/7_factory_wrap`); +const { gcUntil } = require('../../common/gc'); + +assert.strictEqual(test.finalizeCount, 0); +async function runGCTests() { + (() => { + const obj = test.createObject(10); + assert.strictEqual(obj.plusOne(), 11); + assert.strictEqual(obj.plusOne(), 12); + assert.strictEqual(obj.plusOne(), 13); + })(); + await gcUntil('test 1', () => (test.finalizeCount === 1)); + + (() => { + const obj2 = test.createObject(20); + assert.strictEqual(obj2.plusOne(), 21); + assert.strictEqual(obj2.plusOne(), 22); + assert.strictEqual(obj2.plusOne(), 23); + })(); + await gcUntil('test 2', () => (test.finalizeCount === 2)); +} +runGCTests(); diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc new file mode 100644 index 00000000..f3328d93 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc @@ -0,0 +1,61 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "myobject.h" + +extern size_t finalize_count; + +static napi_value CreateObject(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + napi_value instance; + NODE_API_CALL(env, MyObject::NewInstance(env, args[0], &instance)); + + return instance; +} + +static napi_value Add(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)); + + MyObject* obj1; + NODE_API_CALL(env, + napi_unwrap(env, args[0], reinterpret_cast(&obj1))); + + MyObject* obj2; + NODE_API_CALL(env, + napi_unwrap(env, args[1], reinterpret_cast(&obj2))); + + napi_value sum; + NODE_API_CALL(env, napi_create_double(env, obj1->Val() + obj2->Val(), &sum)); + + return sum; +} + +static napi_value FinalizeCount(napi_env env, napi_callback_info info) { + napi_value return_value; + NODE_API_CALL(env, napi_create_uint32(env, finalize_count, &return_value)); + return return_value; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + MyObject::Init(env); + + napi_property_descriptor desc[] = { + DECLARE_NODE_API_PROPERTY("createObject", CreateObject), + DECLARE_NODE_API_PROPERTY("add", Add), + DECLARE_NODE_API_PROPERTY("finalizeCount", FinalizeCount), + }; + + NODE_API_CALL(env, + napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/CMakeLists.txt new file mode 100644 index 00000000..3ee22eb8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/CMakeLists.txt @@ -0,0 +1,5 @@ +add_node_api_module(8_passing_wrapped + SOURCES + 8_passing_wrapped.cc + myobject.cc +) diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/binding.gyp b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/binding.gyp new file mode 100644 index 00000000..d043d0f5 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "8_passing_wrapped", + "sources": [ + "8_passing_wrapped.cc", + "myobject.cc" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.cc b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.cc new file mode 100644 index 00000000..ff352d3f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.cc @@ -0,0 +1,91 @@ +#include "myobject.h" +#include "../common.h" + +size_t finalize_count = 0; + +MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {} + +MyObject::~MyObject() { + finalize_count++; + napi_delete_reference(env_, wrapper_); +} + +void MyObject::Destructor( + node_api_basic_env env, + void *nativeObject, + void * /*finalize_hint*/) { + MyObject *obj = static_cast(nativeObject); + delete obj; +} + +napi_ref MyObject::constructor; + +napi_status MyObject::Init(napi_env env) { + napi_status status; + + napi_value cons; + status = + napi_define_class(env, "MyObject", -1, New, nullptr, 0, nullptr, &cons); + if (status != napi_ok) + return status; + + status = napi_create_reference(env, cons, 1, &constructor); + if (status != napi_ok) + return status; + + return napi_ok; +} + +napi_value MyObject::New(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr)); + + MyObject *obj = new MyObject(); + + napi_valuetype valuetype; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype)); + + if (valuetype == napi_undefined) { + obj->val_ = 0; + } else { + NODE_API_CALL(env, napi_get_value_double(env, args[0], &obj->val_)); + } + + obj->env_ = env; + + // The below call to napi_wrap() must request a reference to the wrapped + // object via the out-parameter, because this ensures that we test the code + // path that deals with a reference that is destroyed from its own finalizer. + NODE_API_CALL( + env, + napi_wrap( + env, + _this, + obj, + MyObject::Destructor, + nullptr /* finalize_hint */, + &obj->wrapper_)); + + return _this; +} + +napi_status +MyObject::NewInstance(napi_env env, napi_value arg, napi_value *instance) { + napi_status status; + + const int argc = 1; + napi_value argv[argc] = {arg}; + + napi_value cons; + status = napi_get_reference_value(env, constructor, &cons); + if (status != napi_ok) + return status; + + status = napi_new_instance(env, cons, argc, argv, instance); + if (status != napi_ok) + return status; + + return napi_ok; +} diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.h b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.h new file mode 100644 index 00000000..bdde3fb4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/myobject.h @@ -0,0 +1,28 @@ +#ifndef TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_ +#define TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_ + +#include + +class MyObject { + public: + static napi_status Init(napi_env env); + static void + Destructor(node_api_basic_env env, void *nativeObject, void *finalize_hint); + static napi_status + NewInstance(napi_env env, napi_value arg, napi_value *instance); + double Val() const { + return val_; + } + + private: + MyObject(); + ~MyObject(); + + static napi_ref constructor; + static napi_value New(napi_env env, napi_callback_info info); + double val_; + napi_env env_; + napi_ref wrapper_; +}; + +#endif // TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_ diff --git a/Tests/NodeApi/test/js-native-api/8_passing_wrapped/test.js b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/test.js new file mode 100644 index 00000000..145828e6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/8_passing_wrapped/test.js @@ -0,0 +1,21 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const assert = require('assert'); +const addon = require(`./build/${common.buildType}/8_passing_wrapped`); +const { gcUntil } = require('../../common/gc'); + +async function runTest() { + let obj1 = addon.createObject(10); + let obj2 = addon.createObject(20); + const result = addon.add(obj1, obj2); + assert.strictEqual(result, 30); + + // Make sure the native destructor gets called. + obj1 = null; + obj2 = null; + await gcUntil('8_passing_wrapped', + () => (addon.finalizeCount() === 2)); +} +runTest(); diff --git a/Tests/NodeApi/test/js-native-api/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/CMakeLists.txt new file mode 100644 index 00000000..a2426f51 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/CMakeLists.txt @@ -0,0 +1,7 @@ +if(JSR_NODE_API_BUILD_NATIVE_TESTS) + foreach(NODE_API_TEST_DIR ${JSR_NODE_API_NATIVE_TEST_DIRS}) + if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/${NODE_API_TEST_DIR}/CMakeLists.txt) + add_subdirectory(${NODE_API_TEST_DIR}) + endif() + endforeach() +endif() diff --git a/Tests/NodeApi/test/js-native-api/common-inl.h b/Tests/NodeApi/test/js-native-api/common-inl.h new file mode 100644 index 00000000..2a1a8fa6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/common-inl.h @@ -0,0 +1,71 @@ +#ifndef JS_NATIVE_API_COMMON_INL_H_ +#define JS_NATIVE_API_COMMON_INL_H_ + +#include +#include "common.h" + +#include + +inline void add_returned_status(napi_env env, + const char* key, + napi_value object, + const char* expected_message, + napi_status expected_status, + napi_status actual_status) { + char napi_message_string[100] = ""; + napi_value prop_value; + + if (actual_status != expected_status) { + snprintf(napi_message_string, + sizeof(napi_message_string), + "Invalid status [%d]", + actual_status); + } + + NODE_API_CALL_RETURN_VOID( + env, + napi_create_string_utf8( + env, + (actual_status == expected_status ? expected_message + : napi_message_string), + NAPI_AUTO_LENGTH, + &prop_value)); + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, object, key, prop_value)); +} + +inline void add_last_status(napi_env env, + const char* key, + napi_value return_value) { + napi_value prop_value; + napi_value exception; + const napi_extended_error_info* p_last_error; + NODE_API_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error)); + // Content of p_last_error can be updated in subsequent node-api calls. + // Retrieve it immediately. + const char* error_message = p_last_error->error_message == NULL + ? "napi_ok" + : p_last_error->error_message; + + bool is_exception_pending; + NODE_API_CALL_RETURN_VOID( + env, napi_is_exception_pending(env, &is_exception_pending)); + if (is_exception_pending) { + NODE_API_CALL_RETURN_VOID( + env, napi_get_and_clear_last_exception(env, &exception)); + char exception_key[50]; + snprintf(exception_key, sizeof(exception_key), "%s%s", key, "Exception"); + NODE_API_CALL_RETURN_VOID( + env, + napi_set_named_property(env, return_value, exception_key, exception)); + } + + NODE_API_CALL_RETURN_VOID( + env, + napi_create_string_utf8( + env, error_message, NAPI_AUTO_LENGTH, &prop_value)); + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, return_value, key, prop_value)); +} + +#endif // JS_NATIVE_API_COMMON_INL_H_ diff --git a/Tests/NodeApi/test/js-native-api/common.h b/Tests/NodeApi/test/js-native-api/common.h new file mode 100644 index 00000000..7c99da88 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/common.h @@ -0,0 +1,132 @@ +#ifndef JS_NATIVE_API_COMMON_H_ +#define JS_NATIVE_API_COMMON_H_ + +#include +#include // abort() + +// Empty value so that macros here are able to return NULL or void +#define NODE_API_RETVAL_NOTHING // Intentionally blank #define + +#define GET_AND_THROW_LAST_ERROR(env) \ + do { \ + const napi_extended_error_info *error_info; \ + napi_get_last_error_info((env), &error_info); \ + bool is_pending; \ + const char* err_message = error_info->error_message; \ + napi_is_exception_pending((env), &is_pending); \ + /* If an exception is already pending, don't rethrow it */ \ + if (!is_pending) { \ + const char* error_message = err_message != NULL ? \ + err_message : \ + "empty error message"; \ + napi_throw_error((env), NULL, error_message); \ + } \ + } while (0) + +// The basic version of GET_AND_THROW_LAST_ERROR. We cannot access any +// exceptions and we cannot fail by way of JS exception, so we abort. +#define FATALLY_FAIL_WITH_LAST_ERROR(env) \ + do { \ + const napi_extended_error_info* error_info; \ + napi_get_last_error_info((env), &error_info); \ + const char* err_message = error_info->error_message; \ + const char* error_message = \ + err_message != NULL ? err_message : "empty error message"; \ + fprintf(stderr, "%s\n", error_message); \ + abort(); \ + } while (0) + +#define NODE_API_ASSERT_BASE(env, assertion, message, ret_val) \ + do { \ + if (!(assertion)) { \ + napi_throw_error( \ + (env), \ + NULL, \ + "assertion (" #assertion ") failed: " message); \ + return ret_val; \ + } \ + } while (0) + +#define NODE_API_BASIC_ASSERT_BASE(assertion, message, ret_val) \ + do { \ + if (!(assertion)) { \ + fprintf(stderr, "assertion (" #assertion ") failed: " message); \ + abort(); \ + return ret_val; \ + } \ + } while (0) + +// Returns NULL on failed assertion. +// This is meant to be used inside napi_callback methods. +#define NODE_API_ASSERT(env, assertion, message) \ + NODE_API_ASSERT_BASE(env, assertion, message, NULL) + +// Returns empty on failed assertion. +// This is meant to be used inside functions with void return type. +#define NODE_API_ASSERT_RETURN_VOID(env, assertion, message) \ + NODE_API_ASSERT_BASE(env, assertion, message, NODE_API_RETVAL_NOTHING) + +#define NODE_API_BASIC_ASSERT_RETURN_VOID(assertion, message) \ + NODE_API_BASIC_ASSERT_BASE(assertion, message, NODE_API_RETVAL_NOTHING) + +#define NODE_API_CALL_BASE(env, the_call, ret_val) \ + do { \ + if ((the_call) != napi_ok) { \ + GET_AND_THROW_LAST_ERROR((env)); \ + return ret_val; \ + } \ + } while (0) + +#define NODE_API_BASIC_CALL_BASE(env, the_call, ret_val) \ + do { \ + if ((the_call) != napi_ok) { \ + FATALLY_FAIL_WITH_LAST_ERROR((env)); \ + return ret_val; \ + } \ + } while (0) + +// Returns NULL if the_call doesn't return napi_ok. +#define NODE_API_CALL(env, the_call) \ + NODE_API_CALL_BASE(env, the_call, NULL) + +// Returns empty if the_call doesn't return napi_ok. +#define NODE_API_CALL_RETURN_VOID(env, the_call) \ + NODE_API_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) + +#define NODE_API_BASIC_CALL_RETURN_VOID(env, the_call) \ + NODE_API_BASIC_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) + +#define NODE_API_CHECK_STATUS(the_call) \ + do { \ + napi_status status = (the_call); \ + if (status != napi_ok) { \ + return status; \ + } \ + } while (0) + +#define NODE_API_ASSERT_STATUS(env, assertion, message) \ + NODE_API_ASSERT_BASE(env, assertion, message, napi_generic_failure) + +#define DECLARE_NODE_API_PROPERTY(name, func) \ + { (name), NULL, (func), NULL, NULL, NULL, napi_default, NULL } + +#define DECLARE_NODE_API_GETTER(name, func) \ + { (name), NULL, NULL, (func), NULL, NULL, napi_default, NULL } + +#define DECLARE_NODE_API_PROPERTY_VALUE(name, value) \ + { (name), NULL, NULL, NULL, NULL, (value), napi_default, NULL } + +static inline void add_returned_status(napi_env env, + const char* key, + napi_value object, + const char* expected_message, + napi_status expected_status, + napi_status actual_status); + +static inline void add_last_status(napi_env env, + const char* key, + napi_value return_value); + +#include "common-inl.h" + +#endif // JS_NATIVE_API_COMMON_H_ diff --git a/Tests/NodeApi/test/js-native-api/entry_point.h b/Tests/NodeApi/test/js-native-api/entry_point.h new file mode 100644 index 00000000..2e74d6c0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/entry_point.h @@ -0,0 +1,12 @@ +#ifndef JS_NATIVE_API_ENTRY_POINT_H_ +#define JS_NATIVE_API_ENTRY_POINT_H_ + +#include + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports); +EXTERN_C_END + +NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) + +#endif // JS_NATIVE_API_ENTRY_POINT_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_array/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_array/CMakeLists.txt new file mode 100644 index 00000000..bda269e6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_array/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_array + SOURCES + test_array.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_array/binding.gyp b/Tests/NodeApi/test/js-native-api/test_array/binding.gyp new file mode 100644 index 00000000..69545b66 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_array/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_array", + "sources": [ + "test_array.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_array/test.js b/Tests/NodeApi/test/js-native-api/test_array/test.js new file mode 100644 index 00000000..26bcb18f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_array/test.js @@ -0,0 +1,61 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for arrays +const test_array = require(`./build/${common.buildType}/test_array`); + +const array = [ + 1, + 9, + 48, + 13493, + 9459324, + { name: 'hello' }, + [ + 'world', + 'node', + 'abi', + ], +]; + +assert.throws( + () => { + test_array.TestGetElement(array, array.length + 1); + }, + /^Error: assertion \(\(\(uint32_t\)index < length\)\) failed: Index out of bounds!$/, +); + +assert.throws( + () => { + test_array.TestGetElement(array, -2); + }, + /^Error: assertion \(index >= 0\) failed: Invalid index\. Expects a positive integer\.$/, +); + +array.forEach(function(element, index) { + assert.strictEqual(test_array.TestGetElement(array, index), element); +}); + + +assert.deepStrictEqual(test_array.New(array), array); + +assert(test_array.TestHasElement(array, 0)); +assert.strictEqual(test_array.TestHasElement(array, array.length + 1), false); + +assert(test_array.NewWithLength(0) instanceof Array); +assert(test_array.NewWithLength(1) instanceof Array); +// Check max allowed length for an array 2^32 -1 +// TODO: Hermes does not allow such big arrays +// assert(test_array.NewWithLength(4294967295) instanceof Array); + +{ + // Verify that array elements can be deleted. + const arr = ['a', 'b', 'c', 'd']; + + assert.strictEqual(arr.length, 4); + assert.strictEqual(2 in arr, true); + assert.strictEqual(test_array.TestDeleteElement(arr, 2), true); + assert.strictEqual(arr.length, 4); + assert.strictEqual(2 in arr, false); +} diff --git a/Tests/NodeApi/test/js-native-api/test_array/test_array.c b/Tests/NodeApi/test/js-native-api/test_array/test_array.c new file mode 100644 index 00000000..7a34af20 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_array/test_array.c @@ -0,0 +1,188 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value TestGetElement(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an array as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_number, + "Wrong type of arguments. Expects an integer as second argument."); + + napi_value array = args[0]; + int32_t index; + NODE_API_CALL(env, napi_get_value_int32(env, args[1], &index)); + + NODE_API_ASSERT(env, index >= 0, "Invalid index. Expects a positive integer."); + + bool isarray; + NODE_API_CALL(env, napi_is_array(env, array, &isarray)); + + if (!isarray) { + return NULL; + } + + uint32_t length; + NODE_API_CALL(env, napi_get_array_length(env, array, &length)); + + NODE_API_ASSERT(env, ((uint32_t)index < length), "Index out of bounds!"); + + napi_value ret; + NODE_API_CALL(env, napi_get_element(env, array, index, &ret)); + + return ret; +} + +static napi_value TestHasElement(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an array as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_number, + "Wrong type of arguments. Expects an integer as second argument."); + + napi_value array = args[0]; + int32_t index; + NODE_API_CALL(env, napi_get_value_int32(env, args[1], &index)); + + bool isarray; + NODE_API_CALL(env, napi_is_array(env, array, &isarray)); + + if (!isarray) { + return NULL; + } + + bool has_element; + NODE_API_CALL(env, napi_has_element(env, array, index, &has_element)); + + napi_value ret; + NODE_API_CALL(env, napi_get_boolean(env, has_element, &ret)); + + return ret; +} + +static napi_value TestDeleteElement(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an array as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + NODE_API_ASSERT(env, valuetype1 == napi_number, + "Wrong type of arguments. Expects an integer as second argument."); + + napi_value array = args[0]; + int32_t index; + bool result; + napi_value ret; + + NODE_API_CALL(env, napi_get_value_int32(env, args[1], &index)); + NODE_API_CALL(env, napi_is_array(env, array, &result)); + + if (!result) { + return NULL; + } + + NODE_API_CALL(env, napi_delete_element(env, array, index, &result)); + NODE_API_CALL(env, napi_get_boolean(env, result, &ret)); + + return ret; +} + +static napi_value New(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an array as first argument."); + + napi_value ret; + NODE_API_CALL(env, napi_create_array(env, &ret)); + + uint32_t i, length; + NODE_API_CALL(env, napi_get_array_length(env, args[0], &length)); + + for (i = 0; i < length; i++) { + napi_value e; + NODE_API_CALL(env, napi_get_element(env, args[0], i, &e)); + NODE_API_CALL(env, napi_set_element(env, ret, i, e)); + } + + return ret; +} + +static napi_value NewWithLength(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects an integer the first argument."); + + int32_t array_length; + NODE_API_CALL(env, napi_get_value_int32(env, args[0], &array_length)); + + napi_value ret; + NODE_API_CALL(env, napi_create_array_with_length(env, array_length, &ret)); + + return ret; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("TestGetElement", TestGetElement), + DECLARE_NODE_API_PROPERTY("TestHasElement", TestHasElement), + DECLARE_NODE_API_PROPERTY("TestDeleteElement", TestDeleteElement), + DECLARE_NODE_API_PROPERTY("New", New), + DECLARE_NODE_API_PROPERTY("NewWithLength", NewWithLength), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_bigint/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_bigint/CMakeLists.txt new file mode 100644 index 00000000..7027e3be --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_bigint + SOURCES + test_bigint.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_bigint/binding.gyp b/Tests/NodeApi/test/js-native-api/test_bigint/binding.gyp new file mode 100644 index 00000000..6dc71015 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_bigint", + "sources": [ + "test_bigint.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_bigint/test.js b/Tests/NodeApi/test/js-native-api/test_bigint/test.js new file mode 100644 index 00000000..50febf14 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint/test.js @@ -0,0 +1,52 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const { + IsLossless, + TestInt64, + TestUint64, + TestWords, + CreateTooBigBigInt, + MakeBigIntWordsThrow, +} = require(`./build/${common.buildType}/test_bigint`); + +[ + 0n, + -0n, + 1n, + -1n, + 100n, + 2121n, + -1233n, + 986583n, + -976675n, + 98765432213456789876546896323445679887645323232436587988766545658n, + -4350987086545760976737453646576078997096876957864353245245769809n, +].forEach((num) => { + if (num > -(2n ** 63n) && num < 2n ** 63n) { + assert.strictEqual(TestInt64(num), num); + assert.strictEqual(IsLossless(num, true), true); + } else { + assert.strictEqual(IsLossless(num, true), false); + } + + if (num >= 0 && num < 2n ** 64n) { + assert.strictEqual(TestUint64(num), num); + assert.strictEqual(IsLossless(num, false), true); + } else { + assert.strictEqual(IsLossless(num, false), false); + } + + assert.strictEqual(num, TestWords(num)); +}); + +assert.throws(() => CreateTooBigBigInt(), { + name: 'Error', + message: 'Invalid argument', +}); + +// Test that we correctly forward exceptions from the engine. +assert.throws(() => MakeBigIntWordsThrow(), { + name: 'RangeError', + message: 'Maximum BigInt size exceeded', +}); diff --git a/Tests/NodeApi/test/js-native-api/test_bigint/test_bigint.c b/Tests/NodeApi/test/js-native-api/test_bigint/test_bigint.c new file mode 100644 index 00000000..203bc3a7 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint/test_bigint.c @@ -0,0 +1,159 @@ +#include +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value IsLossless(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + bool is_signed; + NODE_API_CALL(env, napi_get_value_bool(env, args[1], &is_signed)); + + bool lossless; + + if (is_signed) { + int64_t input; + NODE_API_CALL(env, napi_get_value_bigint_int64(env, args[0], &input, &lossless)); + } else { + uint64_t input; + NODE_API_CALL(env, napi_get_value_bigint_uint64(env, args[0], &input, &lossless)); + } + + napi_value output; + NODE_API_CALL(env, napi_get_boolean(env, lossless, &output)); + + return output; +} + +static napi_value TestInt64(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_bigint, + "Wrong type of arguments. Expects a bigint as first argument."); + + int64_t input; + bool lossless; + NODE_API_CALL(env, napi_get_value_bigint_int64(env, args[0], &input, &lossless)); + + napi_value output; + NODE_API_CALL(env, napi_create_bigint_int64(env, input, &output)); + + return output; +} + +static napi_value TestUint64(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_bigint, + "Wrong type of arguments. Expects a bigint as first argument."); + + uint64_t input; + bool lossless; + NODE_API_CALL(env, napi_get_value_bigint_uint64( + env, args[0], &input, &lossless)); + + napi_value output; + NODE_API_CALL(env, napi_create_bigint_uint64(env, input, &output)); + + return output; +} + +static napi_value TestWords(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_bigint, + "Wrong type of arguments. Expects a bigint as first argument."); + + size_t expected_word_count; + NODE_API_CALL(env, napi_get_value_bigint_words( + env, args[0], NULL, &expected_word_count, NULL)); + + int sign_bit; + size_t word_count = 10; + uint64_t words[10]; + + NODE_API_CALL(env, napi_get_value_bigint_words( + env, args[0], &sign_bit, &word_count, words)); + + NODE_API_ASSERT(env, word_count == expected_word_count, + "word counts do not match"); + + napi_value output; + NODE_API_CALL(env, napi_create_bigint_words( + env, sign_bit, word_count, words, &output)); + + return output; +} + +// throws RangeError +static napi_value CreateTooBigBigInt(napi_env env, napi_callback_info info) { + int sign_bit = 0; + size_t word_count = SIZE_MAX; + uint64_t words[10] = {0}; + + napi_value output; + + NODE_API_CALL(env, napi_create_bigint_words( + env, sign_bit, word_count, words, &output)); + + return output; +} + +// Test that we correctly forward exceptions from the engine. +static napi_value MakeBigIntWordsThrow(napi_env env, napi_callback_info info) { + uint64_t words[10] = {0}; + napi_value output; + + napi_status status = napi_create_bigint_words(env, + 0, + INT_MAX, + words, + &output); + if (status != napi_pending_exception) + napi_throw_error(env, NULL, "Expected status `napi_pending_exception`"); + + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("IsLossless", IsLossless), + DECLARE_NODE_API_PROPERTY("TestInt64", TestInt64), + DECLARE_NODE_API_PROPERTY("TestUint64", TestUint64), + DECLARE_NODE_API_PROPERTY("TestWords", TestWords), + DECLARE_NODE_API_PROPERTY("CreateTooBigBigInt", CreateTooBigBigInt), + DECLARE_NODE_API_PROPERTY("MakeBigIntWordsThrow", MakeBigIntWordsThrow), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_cannot_run_js/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/CMakeLists.txt new file mode 100644 index 00000000..c708e9cb --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/CMakeLists.txt @@ -0,0 +1,13 @@ +add_node_api_module(test_cannot_run_js + SOURCES + test_cannot_run_js.c + DEFINES + "NAPI_VERSION=10" +) + +add_node_api_module(test_pending_exception + SOURCES + test_cannot_run_js.c + DEFINES + "NAPI_VERSION=9" +) diff --git a/Tests/NodeApi/test/js-native-api/test_cannot_run_js/binding.gyp b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/binding.gyp new file mode 100644 index 00000000..51ff8ccb --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/binding.gyp @@ -0,0 +1,18 @@ +{ + "targets": [ + { + "target_name": "test_cannot_run_js", + "sources": [ + "test_cannot_run_js.c" + ], + "defines": [ "NAPI_VERSION=10" ], + }, + { + "target_name": "test_pending_exception", + "sources": [ + "test_cannot_run_js.c" + ], + "defines": [ "NAPI_VERSION=9" ], + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test.js b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test.js new file mode 100644 index 00000000..31c82480 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test.js @@ -0,0 +1,24 @@ +'use strict'; + +// Test that `napi_call_function()` returns `napi_cannot_run_js` in experimental +// mode and `napi_pending_exception` otherwise. This test calls the add-on's +// `createRef()` method, which creates a strong reference to a JS function. When +// the process exits, it calls all reference finalizers. The finalizer for the +// strong reference created herein will attempt to call `napi_get_property()` on +// a property of the global object and will abort the process if the API doesn't +// return the correct status. + +const { buildType, mustNotCall } = require('../../common'); +const addon_v8 = require(`./build/${buildType}/test_pending_exception`); +const addon_new = require(`./build/${buildType}/test_cannot_run_js`); + +function runTests(addon, isVersion8) { + addon.createRef(mustNotCall()); +} + +function runAllTests() { + runTests(addon_v8, /* isVersion8 */ true); + runTests(addon_new, /* isVersion8 */ false); +} + +runAllTests(); diff --git a/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c new file mode 100644 index 00000000..8ca44c23 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c @@ -0,0 +1,66 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "stdlib.h" + +static void Finalize(napi_env env, void* data, void* hint) { + napi_value global, set_timeout; + napi_ref* ref = data; + + NODE_API_BASIC_ASSERT_RETURN_VOID( + napi_delete_reference(env, *ref) == napi_ok, + "deleting reference in finalizer should succeed"); + NODE_API_BASIC_ASSERT_RETURN_VOID( + napi_get_global(env, &global) == napi_ok, + "getting global reference in finalizer should succeed"); + napi_status result = + napi_get_named_property(env, global, "setTimeout", &set_timeout); + + // The finalizer could be invoked either from check callbacks (as native + // immediates) if the event loop is still running (where napi_ok is returned) + // or during environment shutdown (where napi_cannot_run_js or + // napi_pending_exception is returned). This is not deterministic from + // the point of view of the addon. + +#if NAPI_VERSION > 9 + NODE_API_BASIC_ASSERT_RETURN_VOID( + result == napi_cannot_run_js || result == napi_ok, + "getting named property from global in finalizer should succeed " + "or return napi_cannot_run_js"); +#else + NODE_API_BASIC_ASSERT_RETURN_VOID( + result == napi_pending_exception || result == napi_ok, + "getting named property from global in finalizer should succeed " + "or return napi_pending_exception"); +#endif // NAPI_VERSION > 9 + free(ref); +} + +static napi_value CreateRef(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value cb; + napi_valuetype value_type; + napi_ref* ref = malloc(sizeof(*ref)); + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &cb, NULL, NULL)); + NODE_API_ASSERT(env, argc == 1, "Function takes only one argument"); + NODE_API_CALL(env, napi_typeof(env, cb, &value_type)); + NODE_API_ASSERT( + env, value_type == napi_function, "argument must be function"); + NODE_API_CALL(env, napi_add_finalizer(env, cb, ref, Finalize, NULL, ref)); + return cb; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("createRef", CreateRef), + }; + + NODE_API_CALL( + env, + napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_constructor/CMakeLists.txt new file mode 100644 index 00000000..0582345e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/CMakeLists.txt @@ -0,0 +1,5 @@ +add_node_api_module(test_constructor + SOURCES + test_constructor.c + test_null.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/binding.gyp b/Tests/NodeApi/test/js-native-api/test_constructor/binding.gyp new file mode 100644 index 00000000..af0c5d10 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "test_constructor", + "sources": [ + "test_constructor.c", + "test_null.c", + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test.js b/Tests/NodeApi/test/js-native-api/test_constructor/test.js new file mode 100644 index 00000000..4ef41794 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test.js @@ -0,0 +1,62 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +const getterOnlyErrorRE = + /^TypeError: Cannot (set|assign to) property .*( of #<.*>)? which has only a getter$/; + +// Testing api calls for a constructor that defines properties +const TestConstructor = require(`./build/${common.buildType}/test_constructor`); +const test_object = new TestConstructor(); + +assert.strictEqual(test_object.echo('hello'), 'hello'); + +test_object.readwriteValue = 1; +assert.strictEqual(test_object.readwriteValue, 1); +test_object.readwriteValue = 2; +assert.strictEqual(test_object.readwriteValue, 2); + +assert.throws(() => { test_object.readonlyValue = 3; }, + /^TypeError: Cannot assign to read(-| )only property 'readonlyValue'.*(of object '#')?/); + +assert.ok(test_object.hiddenValue); + +// Properties with napi_enumerable attribute should be enumerable. +const propertyNames = []; +for (const name in test_object) { + propertyNames.push(name); +} +assert.ok(propertyNames.includes('echo')); +assert.ok(propertyNames.includes('readwriteValue')); +assert.ok(propertyNames.includes('readonlyValue')); +assert.ok(!propertyNames.includes('hiddenValue')); +assert.ok(!propertyNames.includes('readwriteAccessor1')); +assert.ok(!propertyNames.includes('readwriteAccessor2')); +assert.ok(!propertyNames.includes('readonlyAccessor1')); +assert.ok(!propertyNames.includes('readonlyAccessor2')); + +// The napi_writable attribute should be ignored for accessors. +test_object.readwriteAccessor1 = 1; +assert.strictEqual(test_object.readwriteAccessor1, 1); +assert.strictEqual(test_object.readonlyAccessor1, 1); +assert.throws(() => { test_object.readonlyAccessor1 = 3; }, getterOnlyErrorRE); +test_object.readwriteAccessor2 = 2; +assert.strictEqual(test_object.readwriteAccessor2, 2); +assert.strictEqual(test_object.readonlyAccessor2, 2); +assert.throws(() => { test_object.readonlyAccessor2 = 3; }, getterOnlyErrorRE); + +// Validate that static properties are on the class as opposed +// to the instance +assert.strictEqual(TestConstructor.staticReadonlyAccessor1, 10); +assert.strictEqual(test_object.staticReadonlyAccessor1, undefined); + +// Verify that passing NULL to napi_define_class() results in the correct +// error. +assert.deepStrictEqual(TestConstructor.TestDefineClass(), { + envIsNull: 'Invalid argument', + nameIsNull: 'Invalid argument', + cbIsNull: 'Invalid argument', + cbDataIsNull: 'napi_ok', + propertiesIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument' +}); diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test2.js b/Tests/NodeApi/test/js-native-api/test_constructor/test2.js new file mode 100644 index 00000000..125af81c --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test2.js @@ -0,0 +1,8 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for a constructor that defines properties +const TestConstructor = + require(`./build/${common.buildType}/test_constructor`).constructorName; +assert.strictEqual(TestConstructor.name, 'MyObject'); diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test_constructor.c b/Tests/NodeApi/test/js-native-api/test_constructor/test_constructor.c new file mode 100644 index 00000000..0c52bc31 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test_constructor.c @@ -0,0 +1,200 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "test_null.h" + +static double value_ = 1; +static double static_value_ = 10; + +static napi_value TestDefineClass(napi_env env, + napi_callback_info info) { + napi_status status; + napi_value result, return_value; + + napi_property_descriptor property_descriptor = { + "TestDefineClass", + NULL, + TestDefineClass, + NULL, + NULL, + NULL, + napi_enumerable | napi_static, + NULL}; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + status = napi_define_class(NULL, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestDefineClass, + NULL, + 1, + &property_descriptor, + &result); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + status); + + napi_define_class(env, + NULL, + NAPI_AUTO_LENGTH, + TestDefineClass, + NULL, + 1, + &property_descriptor, + &result); + + add_last_status(env, "nameIsNull", return_value); + + napi_define_class(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + NULL, + NULL, + 1, + &property_descriptor, + &result); + + add_last_status(env, "cbIsNull", return_value); + + napi_define_class(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestDefineClass, + NULL, + 1, + &property_descriptor, + &result); + + add_last_status(env, "cbDataIsNull", return_value); + + napi_define_class(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestDefineClass, + NULL, + 1, + NULL, + &result); + + add_last_status(env, "propertiesIsNull", return_value); + + + napi_define_class(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestDefineClass, + NULL, + 1, + &property_descriptor, + NULL); + + add_last_status(env, "resultIsNull", return_value); + + return return_value; +} + +static napi_value GetValue(napi_env env, napi_callback_info info) { + size_t argc = 0; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 0, "Wrong number of arguments"); + + napi_value number; + NODE_API_CALL(env, napi_create_double(env, value_, &number)); + + return number; +} + +static napi_value SetValue(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + NODE_API_CALL(env, napi_get_value_double(env, args[0], &value_)); + + return NULL; +} + +static napi_value Echo(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + return args[0]; +} + +static napi_value New(napi_env env, napi_callback_info info) { + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &_this, NULL)); + + return _this; +} + +static napi_value GetStaticValue(napi_env env, napi_callback_info info) { + size_t argc = 0; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 0, "Wrong number of arguments"); + + napi_value number; + NODE_API_CALL(env, napi_create_double(env, static_value_, &number)); + + return number; +} + + +static napi_value NewExtra(napi_env env, napi_callback_info info) { + napi_value _this; + NODE_API_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &_this, NULL)); + + return _this; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_value number, cons; + NODE_API_CALL(env, napi_create_double(env, value_, &number)); + + NODE_API_CALL(env, napi_define_class( + env, "MyObject_Extra", 8, NewExtra, NULL, 0, NULL, &cons)); + + napi_property_descriptor properties[] = { + { "echo", NULL, Echo, NULL, NULL, NULL, napi_enumerable, NULL }, + { "readwriteValue", NULL, NULL, NULL, NULL, number, + napi_enumerable | napi_writable, NULL }, + { "readonlyValue", NULL, NULL, NULL, NULL, number, napi_enumerable, + NULL }, + { "hiddenValue", NULL, NULL, NULL, NULL, number, napi_default, NULL }, + { "readwriteAccessor1", NULL, NULL, GetValue, SetValue, NULL, napi_default, + NULL }, + { "readwriteAccessor2", NULL, NULL, GetValue, SetValue, NULL, + napi_writable, NULL }, + { "readonlyAccessor1", NULL, NULL, GetValue, NULL, NULL, napi_default, + NULL }, + { "readonlyAccessor2", NULL, NULL, GetValue, NULL, NULL, napi_writable, + NULL }, + { "staticReadonlyAccessor1", NULL, NULL, GetStaticValue, NULL, NULL, + napi_default | napi_static, NULL}, + { "constructorName", NULL, NULL, NULL, NULL, cons, + napi_enumerable | napi_static, NULL }, + { "TestDefineClass", NULL, TestDefineClass, NULL, NULL, NULL, + napi_enumerable | napi_static, NULL }, + }; + + NODE_API_CALL(env, napi_define_class(env, "MyObject", NAPI_AUTO_LENGTH, New, + NULL, sizeof(properties)/sizeof(*properties), properties, &cons)); + + init_test_null(env, cons); + + return cons; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test_null.c b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.c new file mode 100644 index 00000000..acbe5982 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.c @@ -0,0 +1,111 @@ +#include + +#include "../common.h" +#include "test_null.h" + +static int some_data = 0; + +static napi_value TestConstructor(napi_env env, napi_callback_info info) { + return NULL; +} + +static napi_value TestDefineClass(napi_env env, napi_callback_info info) { + napi_value return_value, cons; + + const napi_property_descriptor prop = + DECLARE_NODE_API_PROPERTY("testConstructor", TestConstructor); + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_define_class(NULL, + "TestClass", + NAPI_AUTO_LENGTH, + TestConstructor, + &some_data, + 1, + &prop, + &cons)); + + napi_define_class(env, + NULL, + NAPI_AUTO_LENGTH, + TestConstructor, + &some_data, + 1, + &prop, + &cons); + add_last_status(env, "nameIsNull", return_value); + + napi_define_class( + env, "TestClass", 0, TestConstructor, &some_data, 1, &prop, &cons); + add_last_status(env, "lengthIsZero", return_value); + + napi_define_class( + env, "TestClass", NAPI_AUTO_LENGTH, NULL, &some_data, 1, &prop, &cons); + add_last_status(env, "nativeSideIsNull", return_value); + + napi_define_class(env, + "TestClass", + NAPI_AUTO_LENGTH, + TestConstructor, + NULL, + 1, + &prop, + &cons); + add_last_status(env, "dataIsNull", return_value); + + napi_define_class(env, + "TestClass", + NAPI_AUTO_LENGTH, + TestConstructor, + &some_data, + 0, + &prop, + &cons); + add_last_status(env, "propsLengthIsZero", return_value); + + napi_define_class(env, + "TestClass", + NAPI_AUTO_LENGTH, + TestConstructor, + &some_data, + 1, + NULL, + &cons); + add_last_status(env, "propsIsNull", return_value); + + napi_define_class(env, + "TestClass", + NAPI_AUTO_LENGTH, + TestConstructor, + &some_data, + 1, + &prop, + NULL); + add_last_status(env, "resultIsNull", return_value); + + return return_value; +} + +void init_test_null(napi_env env, napi_value exports) { + napi_value test_null; + + const napi_property_descriptor test_null_props[] = { + DECLARE_NODE_API_PROPERTY("testDefineClass", TestDefineClass), + }; + + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null)); + NODE_API_CALL_RETURN_VOID( + env, + napi_define_properties(env, + test_null, + sizeof(test_null_props) / sizeof(*test_null_props), + test_null_props)); + + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, exports, "testNull", test_null)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test_null.h b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.h new file mode 100644 index 00000000..b142570d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.h @@ -0,0 +1,8 @@ +#ifndef TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ +#define TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ + +#include + +void init_test_null(napi_env env, napi_value exports); + +#endif // TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_constructor/test_null.js b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.js new file mode 100644 index 00000000..f944953e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_constructor/test_null.js @@ -0,0 +1,18 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Test passing NULL to object-related N-APIs. +const { testNull } = require(`./build/${common.buildType}/test_constructor`); +const expectedResult = { + envIsNull: 'Invalid argument', + nameIsNull: 'Invalid argument', + lengthIsZero: 'napi_ok', + nativeSideIsNull: 'Invalid argument', + dataIsNull: 'napi_ok', + propsLengthIsZero: 'napi_ok', + propsIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', +}; + +assert.deepStrictEqual(testNull.testDefineClass(), expectedResult); diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_conversions/CMakeLists.txt new file mode 100644 index 00000000..732de7c6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/CMakeLists.txt @@ -0,0 +1,5 @@ +add_node_api_module(test_conversions + SOURCES + test_conversions.c + test_null.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/binding.gyp b/Tests/NodeApi/test/js-native-api/test_conversions/binding.gyp new file mode 100644 index 00000000..a7be5290 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "test_conversions", + "sources": [ + "test_conversions.c", + "test_null.c", + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/test.js b/Tests/NodeApi/test/js-native-api/test_conversions/test.js new file mode 100644 index 00000000..b5d047a4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/test.js @@ -0,0 +1,218 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const test = require(`./build/${common.buildType}/test_conversions`); + +const boolExpected = /boolean was expected/; +const numberExpected = /number was expected/; +const stringExpected = /string was expected/; + +const testSym = Symbol('test'); + +assert.strictEqual(test.asBool(false), false); +assert.strictEqual(test.asBool(true), true); +assert.throws(() => test.asBool(undefined), boolExpected); +assert.throws(() => test.asBool(null), boolExpected); +assert.throws(() => test.asBool(Number.NaN), boolExpected); +assert.throws(() => test.asBool(0), boolExpected); +assert.throws(() => test.asBool(''), boolExpected); +assert.throws(() => test.asBool('0'), boolExpected); +assert.throws(() => test.asBool(1), boolExpected); +assert.throws(() => test.asBool('1'), boolExpected); +assert.throws(() => test.asBool('true'), boolExpected); +assert.throws(() => test.asBool({}), boolExpected); +assert.throws(() => test.asBool([]), boolExpected); +assert.throws(() => test.asBool(testSym), boolExpected); + +[test.asInt32, test.asUInt32, test.asInt64].forEach((asInt) => { + assert.strictEqual(asInt(0), 0); + assert.strictEqual(asInt(1), 1); + assert.strictEqual(asInt(1.0), 1); + assert.strictEqual(asInt(1.1), 1); + assert.strictEqual(asInt(1.9), 1); + assert.strictEqual(asInt(0.9), 0); + assert.strictEqual(asInt(999.9), 999); + assert.strictEqual(asInt(Number.NaN), 0); + assert.throws(() => asInt(undefined), numberExpected); + assert.throws(() => asInt(null), numberExpected); + assert.throws(() => asInt(false), numberExpected); + assert.throws(() => asInt(''), numberExpected); + assert.throws(() => asInt('1'), numberExpected); + assert.throws(() => asInt({}), numberExpected); + assert.throws(() => asInt([]), numberExpected); + assert.throws(() => asInt(testSym), numberExpected); +}); + +assert.strictEqual(test.asInt32(-1), -1); +assert.strictEqual(test.asInt64(-1), -1); +assert.strictEqual(test.asUInt32(-1), Math.pow(2, 32) - 1); + +assert.strictEqual(test.asDouble(0), 0); +assert.strictEqual(test.asDouble(1), 1); +assert.strictEqual(test.asDouble(1.0), 1.0); +assert.strictEqual(test.asDouble(1.1), 1.1); +assert.strictEqual(test.asDouble(1.9), 1.9); +assert.strictEqual(test.asDouble(0.9), 0.9); +assert.strictEqual(test.asDouble(999.9), 999.9); +assert.strictEqual(test.asDouble(-1), -1); +assert.ok(Number.isNaN(test.asDouble(Number.NaN))); +assert.throws(() => test.asDouble(undefined), numberExpected); +assert.throws(() => test.asDouble(null), numberExpected); +assert.throws(() => test.asDouble(false), numberExpected); +assert.throws(() => test.asDouble(''), numberExpected); +assert.throws(() => test.asDouble('1'), numberExpected); +assert.throws(() => test.asDouble({}), numberExpected); +assert.throws(() => test.asDouble([]), numberExpected); +assert.throws(() => test.asDouble(testSym), numberExpected); + +assert.strictEqual(test.asString(''), ''); +assert.strictEqual(test.asString('test'), 'test'); +assert.throws(() => test.asString(undefined), stringExpected); +assert.throws(() => test.asString(null), stringExpected); +assert.throws(() => test.asString(false), stringExpected); +assert.throws(() => test.asString(1), stringExpected); +assert.throws(() => test.asString(1.1), stringExpected); +assert.throws(() => test.asString(Number.NaN), stringExpected); +assert.throws(() => test.asString({}), stringExpected); +assert.throws(() => test.asString([]), stringExpected); +assert.throws(() => test.asString(testSym), stringExpected); + +assert.strictEqual(test.toBool(true), true); +assert.strictEqual(test.toBool(1), true); +assert.strictEqual(test.toBool(-1), true); +assert.strictEqual(test.toBool('true'), true); +assert.strictEqual(test.toBool('false'), true); +assert.strictEqual(test.toBool({}), true); +assert.strictEqual(test.toBool([]), true); +assert.strictEqual(test.toBool(testSym), true); +assert.strictEqual(test.toBool(false), false); +assert.strictEqual(test.toBool(undefined), false); +assert.strictEqual(test.toBool(null), false); +assert.strictEqual(test.toBool(0), false); +assert.strictEqual(test.toBool(Number.NaN), false); +assert.strictEqual(test.toBool(''), false); + +assert.strictEqual(test.toNumber(0), 0); +assert.strictEqual(test.toNumber(1), 1); +assert.strictEqual(test.toNumber(1.1), 1.1); +assert.strictEqual(test.toNumber(-1), -1); +assert.strictEqual(test.toNumber('0'), 0); +assert.strictEqual(test.toNumber('1'), 1); +assert.strictEqual(test.toNumber('1.1'), 1.1); +assert.strictEqual(test.toNumber([]), 0); +assert.strictEqual(test.toNumber(false), 0); +assert.strictEqual(test.toNumber(null), 0); +assert.strictEqual(test.toNumber(''), 0); +assert.ok(Number.isNaN(test.toNumber(Number.NaN))); +assert.ok(Number.isNaN(test.toNumber({}))); +assert.ok(Number.isNaN(test.toNumber(undefined))); +assert.throws(() => test.toNumber(testSym), TypeError); + +assert.deepStrictEqual({}, test.toObject({})); +assert.deepStrictEqual({ 'test': 1 }, test.toObject({ 'test': 1 })); +assert.deepStrictEqual([], test.toObject([])); +assert.deepStrictEqual([ 1, 2, 3 ], test.toObject([ 1, 2, 3 ])); +assert.deepStrictEqual(new Boolean(false), test.toObject(false)); +assert.deepStrictEqual(new Boolean(true), test.toObject(true)); +assert.deepStrictEqual(new String(''), test.toObject('')); +assert.deepStrictEqual(new Number(0), test.toObject(0)); +assert.deepStrictEqual(new Number(Number.NaN), test.toObject(Number.NaN)); +assert.deepStrictEqual(new Object(testSym), test.toObject(testSym)); +assert.notStrictEqual(test.toObject(false), false); +assert.notStrictEqual(test.toObject(true), true); +assert.notStrictEqual(test.toObject(''), ''); +assert.notStrictEqual(test.toObject(0), 0); +assert.ok(!Number.isNaN(test.toObject(Number.NaN))); + +assert.strictEqual(test.toString(''), ''); +assert.strictEqual(test.toString('test'), 'test'); +assert.strictEqual(test.toString(undefined), 'undefined'); +assert.strictEqual(test.toString(null), 'null'); +assert.strictEqual(test.toString(false), 'false'); +assert.strictEqual(test.toString(true), 'true'); +assert.strictEqual(test.toString(0), '0'); +assert.strictEqual(test.toString(1.1), '1.1'); +assert.strictEqual(test.toString(Number.NaN), 'NaN'); +assert.strictEqual(test.toString({}), '[object Object]'); +assert.strictEqual(test.toString({ toString: () => 'test' }), 'test'); +assert.strictEqual(test.toString([]), ''); +assert.strictEqual(test.toString([ 1, 2, 3 ]), '1,2,3'); +assert.throws(() => test.toString(testSym), TypeError); + +assert.deepStrictEqual(test.testNull.getValueBool(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'A boolean was expected', +}); + +assert.deepStrictEqual(test.testNull.getValueInt32(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'A number was expected', +}); + +assert.deepStrictEqual(test.testNull.getValueUint32(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'A number was expected', +}); + +assert.deepStrictEqual(test.testNull.getValueInt64(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'A number was expected', +}); + + +assert.deepStrictEqual(test.testNull.getValueDouble(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'A number was expected', +}); + +assert.deepStrictEqual(test.testNull.coerceToBool(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'napi_ok', +}); + +assert.deepStrictEqual(test.testNull.coerceToObject(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'napi_ok', +}); + +assert.deepStrictEqual(test.testNull.coerceToString(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + inputTypeCheck: 'napi_ok', +}); + +assert.deepStrictEqual(test.testNull.getValueStringUtf8(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + wrongTypeIn: 'A string was expected', + bufAndOutLengthIsNull: 'Invalid argument', +}); + +assert.deepStrictEqual(test.testNull.getValueStringLatin1(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + wrongTypeIn: 'A string was expected', + bufAndOutLengthIsNull: 'Invalid argument', +}); + +assert.deepStrictEqual(test.testNull.getValueStringUtf16(), { + envIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', + wrongTypeIn: 'A string was expected', + bufAndOutLengthIsNull: 'Invalid argument', +}); diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/test_conversions.c b/Tests/NodeApi/test/js-native-api/test_conversions/test_conversions.c new file mode 100644 index 00000000..2db42970 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/test_conversions.c @@ -0,0 +1,158 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "test_null.h" + +static napi_value AsBool(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + bool value; + NODE_API_CALL(env, napi_get_value_bool(env, args[0], &value)); + + napi_value output; + NODE_API_CALL(env, napi_get_boolean(env, value, &output)); + + return output; +} + +static napi_value AsInt32(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + int32_t value; + NODE_API_CALL(env, napi_get_value_int32(env, args[0], &value)); + + napi_value output; + NODE_API_CALL(env, napi_create_int32(env, value, &output)); + + return output; +} + +static napi_value AsUInt32(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + uint32_t value; + NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &value)); + + napi_value output; + NODE_API_CALL(env, napi_create_uint32(env, value, &output)); + + return output; +} + +static napi_value AsInt64(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + int64_t value; + NODE_API_CALL(env, napi_get_value_int64(env, args[0], &value)); + + napi_value output; + NODE_API_CALL(env, napi_create_int64(env, (double)value, &output)); + + return output; +} + +static napi_value AsDouble(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + double value; + NODE_API_CALL(env, napi_get_value_double(env, args[0], &value)); + + napi_value output; + NODE_API_CALL(env, napi_create_double(env, value, &output)); + + return output; +} + +static napi_value AsString(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + char value[100]; + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[0], value, sizeof(value), NULL)); + + napi_value output; + NODE_API_CALL(env, napi_create_string_utf8( + env, value, NAPI_AUTO_LENGTH, &output)); + + return output; +} + +static napi_value ToBool(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value output; + NODE_API_CALL(env, napi_coerce_to_bool(env, args[0], &output)); + + return output; +} + +static napi_value ToNumber(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value output; + NODE_API_CALL(env, napi_coerce_to_number(env, args[0], &output)); + + return output; +} + +static napi_value ToObject(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value output; + NODE_API_CALL(env, napi_coerce_to_object(env, args[0], &output)); + + return output; +} + +static napi_value ToString(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value output; + NODE_API_CALL(env, napi_coerce_to_string(env, args[0], &output)); + + return output; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("asBool", AsBool), + DECLARE_NODE_API_PROPERTY("asInt32", AsInt32), + DECLARE_NODE_API_PROPERTY("asUInt32", AsUInt32), + DECLARE_NODE_API_PROPERTY("asInt64", AsInt64), + DECLARE_NODE_API_PROPERTY("asDouble", AsDouble), + DECLARE_NODE_API_PROPERTY("asString", AsString), + DECLARE_NODE_API_PROPERTY("toBool", ToBool), + DECLARE_NODE_API_PROPERTY("toNumber", ToNumber), + DECLARE_NODE_API_PROPERTY("toObject", ToObject), + DECLARE_NODE_API_PROPERTY("toString", ToString), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + init_test_null(env, exports); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/test_null.c b/Tests/NodeApi/test/js-native-api/test_conversions/test_null.c new file mode 100644 index 00000000..e08b986a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/test_null.c @@ -0,0 +1,102 @@ +#include + +#include "../common.h" +#include "test_null.h" + +#define GEN_NULL_CHECK_BINDING(binding_name, output_type, api) \ + static napi_value binding_name(napi_env env, napi_callback_info info) { \ + napi_value return_value; \ + output_type result; \ + NODE_API_CALL(env, napi_create_object(env, &return_value)); \ + add_returned_status(env, \ + "envIsNull", \ + return_value, \ + "Invalid argument", \ + napi_invalid_arg, \ + api(NULL, return_value, &result)); \ + api(env, NULL, &result); \ + add_last_status(env, "valueIsNull", return_value); \ + api(env, return_value, NULL); \ + add_last_status(env, "resultIsNull", return_value); \ + api(env, return_value, &result); \ + add_last_status(env, "inputTypeCheck", return_value); \ + return return_value; \ + } + +GEN_NULL_CHECK_BINDING(GetValueBool, bool, napi_get_value_bool) +GEN_NULL_CHECK_BINDING(GetValueInt32, int32_t, napi_get_value_int32) +GEN_NULL_CHECK_BINDING(GetValueUint32, uint32_t, napi_get_value_uint32) +GEN_NULL_CHECK_BINDING(GetValueInt64, int64_t, napi_get_value_int64) +GEN_NULL_CHECK_BINDING(GetValueDouble, double, napi_get_value_double) +GEN_NULL_CHECK_BINDING(CoerceToBool, napi_value, napi_coerce_to_bool) +GEN_NULL_CHECK_BINDING(CoerceToObject, napi_value, napi_coerce_to_object) +GEN_NULL_CHECK_BINDING(CoerceToString, napi_value, napi_coerce_to_string) + +#define GEN_NULL_CHECK_STRING_BINDING(binding_name, arg_type, api) \ + static napi_value binding_name(napi_env env, napi_callback_info info) { \ + napi_value return_value; \ + NODE_API_CALL(env, napi_create_object(env, &return_value)); \ + arg_type buf1[4]; \ + size_t length1 = 3; \ + add_returned_status(env, \ + "envIsNull", \ + return_value, \ + "Invalid argument", \ + napi_invalid_arg, \ + api(NULL, return_value, buf1, length1, &length1)); \ + arg_type buf2[4]; \ + size_t length2 = 3; \ + api(env, NULL, buf2, length2, &length2); \ + add_last_status(env, "valueIsNull", return_value); \ + api(env, return_value, NULL, 3, NULL); \ + add_last_status(env, "wrongTypeIn", return_value); \ + napi_value string; \ + NODE_API_CALL(env, \ + napi_create_string_utf8(env, \ + "Something", \ + NAPI_AUTO_LENGTH, \ + &string)); \ + api(env, string, NULL, 3, NULL); \ + add_last_status(env, "bufAndOutLengthIsNull", return_value); \ + return return_value; \ + } + +GEN_NULL_CHECK_STRING_BINDING(GetValueStringUtf8, + char, + napi_get_value_string_utf8) +GEN_NULL_CHECK_STRING_BINDING(GetValueStringLatin1, + char, + napi_get_value_string_latin1) +GEN_NULL_CHECK_STRING_BINDING(GetValueStringUtf16, + char16_t, + napi_get_value_string_utf16) + +void init_test_null(napi_env env, napi_value exports) { + napi_value test_null; + + const napi_property_descriptor test_null_props[] = { + DECLARE_NODE_API_PROPERTY("getValueBool", GetValueBool), + DECLARE_NODE_API_PROPERTY("getValueInt32", GetValueInt32), + DECLARE_NODE_API_PROPERTY("getValueUint32", GetValueUint32), + DECLARE_NODE_API_PROPERTY("getValueInt64", GetValueInt64), + DECLARE_NODE_API_PROPERTY("getValueDouble", GetValueDouble), + DECLARE_NODE_API_PROPERTY("coerceToBool", CoerceToBool), + DECLARE_NODE_API_PROPERTY("coerceToObject", CoerceToObject), + DECLARE_NODE_API_PROPERTY("coerceToString", CoerceToString), + DECLARE_NODE_API_PROPERTY("getValueStringUtf8", GetValueStringUtf8), + DECLARE_NODE_API_PROPERTY("getValueStringLatin1", GetValueStringLatin1), + DECLARE_NODE_API_PROPERTY("getValueStringUtf16", GetValueStringUtf16), + }; + + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null)); + NODE_API_CALL_RETURN_VOID(env, napi_define_properties( + env, test_null, sizeof(test_null_props) / sizeof(*test_null_props), + test_null_props)); + + const napi_property_descriptor test_null_set = { + "testNull", NULL, NULL, NULL, NULL, test_null, napi_enumerable, NULL + }; + + NODE_API_CALL_RETURN_VOID(env, + napi_define_properties(env, exports, 1, &test_null_set)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_conversions/test_null.h b/Tests/NodeApi/test/js-native-api/test_conversions/test_null.h new file mode 100644 index 00000000..fe6ad77a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_conversions/test_null.h @@ -0,0 +1,8 @@ +#ifndef TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_ +#define TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_ + +#include + +void init_test_null(napi_env env, napi_value exports); + +#endif // TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_dataview/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_dataview/CMakeLists.txt new file mode 100644 index 00000000..d809ba9a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_dataview/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_dataview + SOURCES + test_dataview.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_dataview/binding.gyp b/Tests/NodeApi/test/js-native-api/test_dataview/binding.gyp new file mode 100644 index 00000000..a8b4f1d4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_dataview/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_dataview", + "sources": [ + "test_dataview.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_dataview/test.js b/Tests/NodeApi/test/js-native-api/test_dataview/test.js new file mode 100644 index 00000000..2bfd109d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_dataview/test.js @@ -0,0 +1,24 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for arrays +const test_dataview = require(`./build/${common.buildType}/test_dataview`); + +// Test for creating dataview +{ + const buffer = new ArrayBuffer(128); + const template = Reflect.construct(DataView, [buffer]); + + const theDataview = test_dataview.CreateDataViewFromJSDataView(template); + assert.ok(theDataview instanceof DataView, + `Expect ${theDataview} to be a DataView`); +} + +// Test for creating dataview with invalid range +{ + const buffer = new ArrayBuffer(128); + assert.throws(() => { + test_dataview.CreateDataView(buffer, 10, 200); + }, RangeError); +} diff --git a/Tests/NodeApi/test/js-native-api/test_dataview/test_dataview.c b/Tests/NodeApi/test/js-native-api/test_dataview/test_dataview.c new file mode 100644 index 00000000..20a840de --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_dataview/test_dataview.c @@ -0,0 +1,102 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value CreateDataView(napi_env env, napi_callback_info info) { + size_t argc = 3; + napi_value args [3]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 3, "Wrong number of arguments"); + + napi_valuetype valuetype0; + napi_value arraybuffer = args[0]; + + NODE_API_CALL(env, napi_typeof(env, arraybuffer, &valuetype0)); + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects a ArrayBuffer as the first " + "argument."); + + bool is_arraybuffer; + NODE_API_CALL(env, napi_is_arraybuffer(env, arraybuffer, &is_arraybuffer)); + NODE_API_ASSERT(env, is_arraybuffer, + "Wrong type of arguments. Expects a ArrayBuffer as the first " + "argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_number, + "Wrong type of arguments. Expects a number as second argument."); + + size_t byte_offset = 0; + NODE_API_CALL(env, napi_get_value_uint32(env, args[1], (uint32_t*)(&byte_offset))); + + napi_valuetype valuetype2; + NODE_API_CALL(env, napi_typeof(env, args[2], &valuetype2)); + + NODE_API_ASSERT(env, valuetype2 == napi_number, + "Wrong type of arguments. Expects a number as third argument."); + + size_t length = 0; + NODE_API_CALL(env, napi_get_value_uint32(env, args[2], (uint32_t*)(&length))); + + napi_value output_dataview; + NODE_API_CALL(env, + napi_create_dataview(env, length, arraybuffer, + byte_offset, &output_dataview)); + + return output_dataview; +} + +static napi_value CreateDataViewFromJSDataView(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args [1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + napi_valuetype valuetype; + napi_value input_dataview = args[0]; + + NODE_API_CALL(env, napi_typeof(env, input_dataview, &valuetype)); + NODE_API_ASSERT(env, valuetype == napi_object, + "Wrong type of arguments. Expects a DataView as the first " + "argument."); + + bool is_dataview; + NODE_API_CALL(env, napi_is_dataview(env, input_dataview, &is_dataview)); + NODE_API_ASSERT(env, is_dataview, + "Wrong type of arguments. Expects a DataView as the first " + "argument."); + size_t byte_offset = 0; + size_t length = 0; + napi_value buffer; + NODE_API_CALL(env, + napi_get_dataview_info(env, input_dataview, &length, NULL, + &buffer, &byte_offset)); + + napi_value output_dataview; + NODE_API_CALL(env, + napi_create_dataview(env, length, buffer, + byte_offset, &output_dataview)); + + + return output_dataview; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("CreateDataView", CreateDataView), + DECLARE_NODE_API_PROPERTY("CreateDataViewFromJSDataView", + CreateDataViewFromJSDataView) + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_date/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_date/CMakeLists.txt new file mode 100644 index 00000000..9c9736c8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_date/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_date + SOURCES + test_date.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_date/binding.gyp b/Tests/NodeApi/test/js-native-api/test_date/binding.gyp new file mode 100644 index 00000000..e08eaf6d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_date/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_date", + "sources": [ + "test_date.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_date/test.js b/Tests/NodeApi/test/js-native-api/test_date/test.js new file mode 100644 index 00000000..637f9f94 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_date/test.js @@ -0,0 +1,21 @@ +'use strict'; + +const common = require('../../common'); + +// This tests the date-related n-api calls + +const assert = require('assert'); +const test_date = require(`./build/${common.buildType}/test_date`); + +const dateTypeTestDate = test_date.createDate(1549183351); +assert.strictEqual(test_date.isDate(dateTypeTestDate), true); + +assert.strictEqual(test_date.isDate(new Date(1549183351)), true); + +assert.strictEqual(test_date.isDate(2.4), false); +assert.strictEqual(test_date.isDate('not a date'), false); +assert.strictEqual(test_date.isDate(undefined), false); +assert.strictEqual(test_date.isDate(null), false); +assert.strictEqual(test_date.isDate({}), false); + +assert.strictEqual(test_date.getDateValue(new Date(1549183351)), 1549183351); diff --git a/Tests/NodeApi/test/js-native-api/test_date/test_date.c b/Tests/NodeApi/test/js-native-api/test_date/test_date.c new file mode 100644 index 00000000..a9eeb4f0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_date/test_date.c @@ -0,0 +1,64 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value createDate(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects a number as first argument."); + + double time; + NODE_API_CALL(env, napi_get_value_double(env, args[0], &time)); + + napi_value date; + NODE_API_CALL(env, napi_create_date(env, time, &date)); + + return date; +} + +static napi_value isDate(napi_env env, napi_callback_info info) { + napi_value date, result; + size_t argc = 1; + bool is_date; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL)); + NODE_API_CALL(env, napi_is_date(env, date, &is_date)); + NODE_API_CALL(env, napi_get_boolean(env, is_date, &result)); + + return result; +} + +static napi_value getDateValue(napi_env env, napi_callback_info info) { + napi_value date, result; + size_t argc = 1; + double value; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL)); + NODE_API_CALL(env, napi_get_date_value(env, date, &value)); + NODE_API_CALL(env, napi_create_double(env, value, &result)); + + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("createDate", createDate), + DECLARE_NODE_API_PROPERTY("isDate", isDate), + DECLARE_NODE_API_PROPERTY("getDateValue", getDateValue), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_error/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_error/CMakeLists.txt new file mode 100644 index 00000000..955fd2a0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_error/CMakeLists.txt @@ -0,0 +1,6 @@ +add_node_api_module(test_error + SOURCES + test_error.c + DEFINES + "NAPI_VERSION=9" +) diff --git a/Tests/NodeApi/test/js-native-api/test_error/binding.gyp b/Tests/NodeApi/test/js-native-api/test_error/binding.gyp new file mode 100644 index 00000000..f0448028 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_error/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_error", + "sources": [ + "test_error.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_error/test.js b/Tests/NodeApi/test/js-native-api/test_error/test.js new file mode 100644 index 00000000..f6ba3799 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_error/test.js @@ -0,0 +1,148 @@ +'use strict'; + +const common = require('../../common'); +const test_error = require(`./build/${common.buildType}/test_error`); +const assert = require('assert'); +const theError = new Error('Some error'); +const theTypeError = new TypeError('Some type error'); +const theSyntaxError = new SyntaxError('Some syntax error'); +const theRangeError = new RangeError('Some type error'); +const theReferenceError = new ReferenceError('Some reference error'); +const theURIError = new URIError('Some URI error'); +const theEvalError = new EvalError('Some eval error'); + +class MyError extends Error { } +const myError = new MyError('Some MyError'); + +// Test that native error object is correctly classed +assert.strictEqual(test_error.checkError(theError), true); + +// Test that native type error object is correctly classed +assert.strictEqual(test_error.checkError(theTypeError), true); + +// Test that native syntax error object is correctly classed +assert.strictEqual(test_error.checkError(theSyntaxError), true); + +// Test that native range error object is correctly classed +assert.strictEqual(test_error.checkError(theRangeError), true); + +// Test that native reference error object is correctly classed +assert.strictEqual(test_error.checkError(theReferenceError), true); + +// Test that native URI error object is correctly classed +assert.strictEqual(test_error.checkError(theURIError), true); + +// Test that native eval error object is correctly classed +assert.strictEqual(test_error.checkError(theEvalError), true); + +// Test that class derived from native error is correctly classed +assert.strictEqual(test_error.checkError(myError), true); + +// Test that non-error object is correctly classed +assert.strictEqual(test_error.checkError({}), false); + +// Test that non-error primitive is correctly classed +assert.strictEqual(test_error.checkError('non-object'), false); + +assert.throws(() => { + test_error.throwExistingError(); +}, /^Error: existing error$/); + +assert.throws(() => { + test_error.throwError(); +}, /^Error: error$/); + +assert.throws(() => { + test_error.throwRangeError(); +}, /^RangeError: range error$/); + +assert.throws(() => { + test_error.throwTypeError(); +}, /^TypeError: type error$/); + +assert.throws(() => { + test_error.throwSyntaxError(); +}, /^SyntaxError: syntax error$/); + +[42, {}, [], Symbol('xyzzy'), true, 'ball', undefined, null, NaN] + .forEach((value) => assert.throws( + () => test_error.throwArbitrary(value), + (err) => { + assert.strictEqual(err, value); + return true; + }, + )); + +assert.throws( + () => test_error.throwErrorCode(), + { + code: 'ERR_TEST_CODE', + message: 'Error [error]', + }); + +assert.throws( + () => test_error.throwRangeErrorCode(), + { + code: 'ERR_TEST_CODE', + message: 'RangeError [range error]', + }); + +assert.throws( + () => test_error.throwTypeErrorCode(), + { + code: 'ERR_TEST_CODE', + message: 'TypeError [type error]', + }); + +assert.throws( + () => test_error.throwSyntaxErrorCode(), + { + code: 'ERR_TEST_CODE', + message: 'SyntaxError [syntax error]', + }); + +let error = test_error.createError(); +assert.ok(error instanceof Error, 'expected error to be an instance of Error'); +assert.strictEqual(error.message, 'error'); + +error = test_error.createRangeError(); +assert.ok(error instanceof RangeError, + 'expected error to be an instance of RangeError'); +assert.strictEqual(error.message, 'range error'); + +error = test_error.createTypeError(); +assert.ok(error instanceof TypeError, + 'expected error to be an instance of TypeError'); +assert.strictEqual(error.message, 'type error'); + +error = test_error.createSyntaxError(); +assert.ok(error instanceof SyntaxError, + 'expected error to be an instance of SyntaxError'); +assert.strictEqual(error.message, 'syntax error'); + +error = test_error.createErrorCode(); +assert.ok(error instanceof Error, 'expected error to be an instance of Error'); +assert.strictEqual(error.code, 'ERR_TEST_CODE'); +assert.strictEqual(error.message, 'Error [error]'); +assert.strictEqual(error.name, 'Error'); + +error = test_error.createRangeErrorCode(); +assert.ok(error instanceof RangeError, + 'expected error to be an instance of RangeError'); +assert.strictEqual(error.message, 'RangeError [range error]'); +assert.strictEqual(error.code, 'ERR_TEST_CODE'); +assert.strictEqual(error.name, 'RangeError'); + +error = test_error.createTypeErrorCode(); +assert.ok(error instanceof TypeError, + 'expected error to be an instance of TypeError'); +assert.strictEqual(error.message, 'TypeError [type error]'); +assert.strictEqual(error.code, 'ERR_TEST_CODE'); +assert.strictEqual(error.name, 'TypeError'); + +error = test_error.createSyntaxErrorCode(); +assert.ok(error instanceof SyntaxError, + 'expected error to be an instance of SyntaxError'); +assert.strictEqual(error.message, 'SyntaxError [syntax error]'); +assert.strictEqual(error.code, 'ERR_TEST_CODE'); +assert.strictEqual(error.name, 'SyntaxError'); diff --git a/Tests/NodeApi/test/js-native-api/test_error/test_error.c b/Tests/NodeApi/test/js-native-api/test_error/test_error.c new file mode 100644 index 00000000..fc4b8758 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_error/test_error.c @@ -0,0 +1,197 @@ +#define NAPI_VERSION 9 +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value checkError(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + bool r; + NODE_API_CALL(env, napi_is_error(env, args[0], &r)); + + napi_value result; + NODE_API_CALL(env, napi_get_boolean(env, r, &result)); + + return result; +} + +static napi_value throwExistingError(napi_env env, napi_callback_info info) { + napi_value message; + napi_value error; + NODE_API_CALL(env, napi_create_string_utf8( + env, "existing error", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_error(env, NULL, message, &error)); + NODE_API_CALL(env, napi_throw(env, error)); + return NULL; +} + +static napi_value throwError(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, napi_throw_error(env, NULL, "error")); + return NULL; +} + +static napi_value throwRangeError(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, napi_throw_range_error(env, NULL, "range error")); + return NULL; +} + +static napi_value throwTypeError(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, napi_throw_type_error(env, NULL, "type error")); + return NULL; +} + +static napi_value throwSyntaxError(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, node_api_throw_syntax_error(env, NULL, "syntax error")); + return NULL; +} + +static napi_value throwErrorCode(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, napi_throw_error(env, "ERR_TEST_CODE", "Error [error]")); + return NULL; +} + +static napi_value throwRangeErrorCode(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, + napi_throw_range_error(env, "ERR_TEST_CODE", "RangeError [range error]")); + return NULL; +} + +static napi_value throwTypeErrorCode(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, + napi_throw_type_error(env, "ERR_TEST_CODE", "TypeError [type error]")); + return NULL; +} + +static napi_value throwSyntaxErrorCode(napi_env env, napi_callback_info info) { + NODE_API_CALL(env, + node_api_throw_syntax_error(env, "ERR_TEST_CODE", "SyntaxError [syntax error]")); + return NULL; +} + +static napi_value createError(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + NODE_API_CALL(env, napi_create_string_utf8( + env, "error", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_error(env, NULL, message, &result)); + return result; +} + +static napi_value createRangeError(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + NODE_API_CALL(env, napi_create_string_utf8( + env, "range error", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_range_error(env, NULL, message, &result)); + return result; +} + +static napi_value createTypeError(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + NODE_API_CALL(env, napi_create_string_utf8( + env, "type error", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_type_error(env, NULL, message, &result)); + return result; +} + +static napi_value createSyntaxError(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + NODE_API_CALL(env, napi_create_string_utf8( + env, "syntax error", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, node_api_create_syntax_error(env, NULL, message, &result)); + return result; +} + +static napi_value createErrorCode(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + napi_value code; + NODE_API_CALL(env, napi_create_string_utf8( + env, "Error [error]", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_string_utf8( + env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code)); + NODE_API_CALL(env, napi_create_error(env, code, message, &result)); + return result; +} + +static napi_value createRangeErrorCode(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + napi_value code; + NODE_API_CALL(env, + napi_create_string_utf8( + env, "RangeError [range error]", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_string_utf8( + env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code)); + NODE_API_CALL(env, napi_create_range_error(env, code, message, &result)); + return result; +} + +static napi_value createTypeErrorCode(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + napi_value code; + NODE_API_CALL(env, + napi_create_string_utf8( + env, "TypeError [type error]", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_string_utf8( + env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code)); + NODE_API_CALL(env, napi_create_type_error(env, code, message, &result)); + return result; +} + +static napi_value createSyntaxErrorCode(napi_env env, napi_callback_info info) { + napi_value result; + napi_value message; + napi_value code; + NODE_API_CALL(env, + napi_create_string_utf8( + env, "SyntaxError [syntax error]", NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_string_utf8( + env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code)); + NODE_API_CALL(env, node_api_create_syntax_error(env, code, message, &result)); + return result; +} + +static napi_value throwArbitrary(napi_env env, napi_callback_info info) { + napi_value arbitrary; + size_t argc = 1; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arbitrary, NULL, NULL)); + NODE_API_CALL(env, napi_throw(env, arbitrary)); + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("checkError", checkError), + DECLARE_NODE_API_PROPERTY("throwExistingError", throwExistingError), + DECLARE_NODE_API_PROPERTY("throwError", throwError), + DECLARE_NODE_API_PROPERTY("throwRangeError", throwRangeError), + DECLARE_NODE_API_PROPERTY("throwTypeError", throwTypeError), + DECLARE_NODE_API_PROPERTY("throwSyntaxError", throwSyntaxError), + DECLARE_NODE_API_PROPERTY("throwErrorCode", throwErrorCode), + DECLARE_NODE_API_PROPERTY("throwRangeErrorCode", throwRangeErrorCode), + DECLARE_NODE_API_PROPERTY("throwTypeErrorCode", throwTypeErrorCode), + DECLARE_NODE_API_PROPERTY("throwSyntaxErrorCode", throwSyntaxErrorCode), + DECLARE_NODE_API_PROPERTY("throwArbitrary", throwArbitrary), + DECLARE_NODE_API_PROPERTY("createError", createError), + DECLARE_NODE_API_PROPERTY("createRangeError", createRangeError), + DECLARE_NODE_API_PROPERTY("createTypeError", createTypeError), + DECLARE_NODE_API_PROPERTY("createSyntaxError", createSyntaxError), + DECLARE_NODE_API_PROPERTY("createErrorCode", createErrorCode), + DECLARE_NODE_API_PROPERTY("createRangeErrorCode", createRangeErrorCode), + DECLARE_NODE_API_PROPERTY("createTypeErrorCode", createTypeErrorCode), + DECLARE_NODE_API_PROPERTY("createSyntaxErrorCode", createSyntaxErrorCode), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_exception/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_exception/CMakeLists.txt new file mode 100644 index 00000000..4d8494f9 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_exception/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_exception + SOURCES + test_exception.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_exception/binding.gyp b/Tests/NodeApi/test/js-native-api/test_exception/binding.gyp new file mode 100644 index 00000000..a453505d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_exception/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_exception", + "sources": [ + "test_exception.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_exception/test.js b/Tests/NodeApi/test/js-native-api/test_exception/test.js new file mode 100644 index 00000000..3e070fed --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_exception/test.js @@ -0,0 +1,115 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const assert = require('assert'); +const theError = new Error('Some error'); + +// The test module throws an error during Init, but in order for its exports to +// not be lost, it attaches them to the error's "bindings" property. This way, +// we can make sure that exceptions thrown during the module initialization +// phase are propagated through require() into JavaScript. +// https://github.com/nodejs/node/issues/19437 +const test_exception = (function() { + let resultingException; + try { + require(`./build/${common.buildType}/test_exception`); + } catch (anException) { + resultingException = anException; + } + assert.strictEqual(resultingException.message, 'Error during Init'); + return resultingException.binding; +})(); + +{ + const throwTheError = () => { throw theError; }; + + // Test that the native side successfully captures the exception + let returnedError = test_exception.returnException(throwTheError); + assert.strictEqual(returnedError, theError); + + // Test that the native side passes the exception through + assert.throws( + () => { test_exception.allowException(throwTheError); }, + (err) => err === theError, + ); + + // Test that the exception thrown above was marked as pending + // before it was handled on the JS side + const exception_pending = test_exception.wasPending(); + assert.strictEqual(exception_pending, true, + 'Exception not pending as expected,' + + ` .wasPending() returned ${exception_pending}`); + + // Test that the native side does not capture a non-existing exception + returnedError = test_exception.returnException(common.mustCall()); + assert.strictEqual(returnedError, undefined, + 'Returned error should be undefined when no exception is' + + ` thrown, but ${returnedError} was passed`); +} + + +{ + const throwTheError = class { constructor() { throw theError; } }; + + // Test that the native side successfully captures the exception + let returnedError = test_exception.constructReturnException(throwTheError); + assert.strictEqual(returnedError, theError); + + // Test that the native side passes the exception through + assert.throws( + () => { test_exception.constructAllowException(throwTheError); }, + (err) => err === theError, + ); + + // Test that the exception thrown above was marked as pending + // before it was handled on the JS side + const exception_pending = test_exception.wasPending(); + assert.strictEqual(exception_pending, true, + 'Exception not pending as expected,' + + ` .wasPending() returned ${exception_pending}`); + + // Test that the native side does not capture a non-existing exception + returnedError = test_exception.constructReturnException(common.mustCall()); + assert.strictEqual(returnedError, undefined, + 'Returned error should be undefined when no exception is' + + ` thrown, but ${returnedError} was passed`); +} + +{ + // Test that no exception appears that was not thrown by us + let caughtError; + try { + test_exception.allowException(common.mustCall()); + } catch (anError) { + caughtError = anError; + } + assert.strictEqual(caughtError, undefined, + 'No exception originated on the native side, but' + + ` ${caughtError} was passed`); + + // Test that the exception state remains clear when no exception is thrown + const exception_pending = test_exception.wasPending(); + assert.strictEqual(exception_pending, false, + 'Exception state did not remain clear as expected,' + + ` .wasPending() returned ${exception_pending}`); +} + +{ + // Test that no exception appears that was not thrown by us + let caughtError; + try { + test_exception.constructAllowException(common.mustCall()); + } catch (anError) { + caughtError = anError; + } + assert.strictEqual(caughtError, undefined, + 'No exception originated on the native side, but' + + ` ${caughtError} was passed`); + + // Test that the exception state remains clear when no exception is thrown + const exception_pending = test_exception.wasPending(); + assert.strictEqual(exception_pending, false, + 'Exception state did not remain clear as expected,' + + ` .wasPending() returned ${exception_pending}`); +} diff --git a/Tests/NodeApi/test/js-native-api/test_exception/testFinalizerException.js b/Tests/NodeApi/test/js-native-api/test_exception/testFinalizerException.js new file mode 100644 index 00000000..dce63624 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_exception/testFinalizerException.js @@ -0,0 +1,31 @@ +'use strict'; +if (process.argv[2] === 'child') { + const common = require('../../common'); + // Trying, catching the exception, and finding the bindings at the `Error`'s + // `binding` property is done intentionally, because we're also testing what + // happens when the add-on entry point throws. See test.js. + try { + require(`./build/${common.buildType}/test_exception`); + } catch (anException) { + anException.binding.createExternal(); + } + + // Collect garbage 10 times. At least one of those should throw the exception + // and cause the whole process to bail with it, its text printed to stderr and + // asserted by the parent process to match expectations. + let gcCount = 10; + (function gcLoop() { + global.gc(); + if (--gcCount > 0) { + setImmediate(() => gcLoop()); + } + })(); +} else { + const assert = require('assert'); + const { spawnSync } = require('child_process'); + const child = spawnSync(process.execPath, [ + '--expose-gc', __filename, 'child', + ]); + assert.strictEqual(child.signal, null); + assert.match(child.stderr.toString(), /Error during Finalize/m); +} \ No newline at end of file diff --git a/Tests/NodeApi/test/js-native-api/test_exception/test_exception.c b/Tests/NodeApi/test/js-native-api/test_exception/test_exception.c new file mode 100644 index 00000000..de1eb42a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_exception/test_exception.c @@ -0,0 +1,116 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static bool exceptionWasPending = false; +static int num = 0x23432; + +static napi_value returnException(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value global; + NODE_API_CALL(env, napi_get_global(env, &global)); + + napi_value result; + napi_status status = napi_call_function(env, global, args[0], 0, 0, &result); + if (status == napi_pending_exception) { + napi_value ex; + NODE_API_CALL(env, napi_get_and_clear_last_exception(env, &ex)); + return ex; + } + + return NULL; +} + +static napi_value constructReturnException(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value result; + napi_status status = napi_new_instance(env, args[0], 0, 0, &result); + if (status == napi_pending_exception) { + napi_value ex; + NODE_API_CALL(env, napi_get_and_clear_last_exception(env, &ex)); + return ex; + } + + return NULL; +} + +static napi_value allowException(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value global; + NODE_API_CALL(env, napi_get_global(env, &global)); + + napi_value result; + napi_call_function(env, global, args[0], 0, 0, &result); + // Ignore status and check napi_is_exception_pending() instead. + + NODE_API_CALL(env, napi_is_exception_pending(env, &exceptionWasPending)); + return NULL; +} + +static napi_value constructAllowException(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value result; + napi_new_instance(env, args[0], 0, 0, &result); + // Ignore status and check napi_is_exception_pending() instead. + + NODE_API_CALL(env, napi_is_exception_pending(env, &exceptionWasPending)); + return NULL; +} + +static napi_value wasPending(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_get_boolean(env, exceptionWasPending, &result)); + + return result; +} + +static void finalizer(napi_env env, void *data, void *hint) { + NODE_API_CALL_RETURN_VOID(env, + napi_throw_error(env, NULL, "Error during Finalize")); +} + +static napi_value createExternal(napi_env env, napi_callback_info info) { + napi_value external; + + NODE_API_CALL(env, + napi_create_external(env, &num, finalizer, NULL, &external)); + + return external; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("returnException", returnException), + DECLARE_NODE_API_PROPERTY("allowException", allowException), + DECLARE_NODE_API_PROPERTY("constructReturnException", constructReturnException), + DECLARE_NODE_API_PROPERTY("constructAllowException", constructAllowException), + DECLARE_NODE_API_PROPERTY("wasPending", wasPending), + DECLARE_NODE_API_PROPERTY("createExternal", createExternal), + }; + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + napi_value error, code, message; + NODE_API_CALL(env, napi_create_string_utf8(env, "Error during Init", + NAPI_AUTO_LENGTH, &message)); + NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &code)); + NODE_API_CALL(env, napi_create_error(env, code, message, &error)); + NODE_API_CALL(env, napi_set_named_property(env, error, "binding", exports)); + NODE_API_CALL(env, napi_throw(env, error)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_finalizer/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_finalizer/CMakeLists.txt new file mode 100644 index 00000000..ce560dad --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_finalizer/CMakeLists.txt @@ -0,0 +1,7 @@ +add_node_api_module(test_finalizer + SOURCES + test_finalizer.c + DEFINES + NAPI_EXPERIMENTAL + NODE_API_EXPERIMENTAL_NO_WARNING +) diff --git a/Tests/NodeApi/test/js-native-api/test_finalizer/binding.gyp b/Tests/NodeApi/test/js-native-api/test_finalizer/binding.gyp new file mode 100644 index 00000000..8553fd2d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_finalizer/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "test_finalizer", + "defines": [ "NAPI_EXPERIMENTAL" ], + "sources": [ + "test_finalizer.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_finalizer/test.js b/Tests/NodeApi/test/js-native-api/test_finalizer/test.js new file mode 100644 index 00000000..3edf53ce --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_finalizer/test.js @@ -0,0 +1,45 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const test_finalizer = require(`./build/${common.buildType}/test_finalizer`); +const assert = require('assert'); + +const { gcUntil } = require('../../common/gc'); + +// The goal of this test is to show that we can run "pure" finalizers in the +// current JS loop tick. Thus, we do not use gcUntil function works +// asynchronously using micro tasks. +// We use IIFE for the obj scope instead of {} to be compatible with +// non-V8 JS engines that do not support scoped variables. +(() => { + const obj = {}; + test_finalizer.addFinalizer(obj); +})(); + +for (let i = 0; i < 10; ++i) { + global.gc(); + if (test_finalizer.getFinalizerCallCount() === 1) { + break; + } +} + +assert.strictEqual(test_finalizer.getFinalizerCallCount(), 1); + +// The finalizer that access JS cannot run synchronously. They are run in the +// next JS loop tick. Thus, we must use gcUntil. +async function runAsyncTests() { + // We do not use common.mustCall() because we want to see the finalizer + // called in response to GC and not as a part of env destruction. + let js_is_called = false; + // We use IIFE for the obj scope instead of {} to be compatible with + // non-V8 JS engines that do not support scoped variables. + (() => { + const obj = {}; + test_finalizer.addFinalizerWithJS(obj, () => { js_is_called = true; }); + })(); + await gcUntil('ensure JS finalizer called', + () => (test_finalizer.getFinalizerCallCount() === 2)); + assert(js_is_called); +} +runAsyncTests(); diff --git a/Tests/NodeApi/test/js-native-api/test_finalizer/test_fatal_finalize.js b/Tests/NodeApi/test/js-native-api/test_finalizer/test_fatal_finalize.js new file mode 100644 index 00000000..6b725414 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_finalizer/test_fatal_finalize.js @@ -0,0 +1,35 @@ +"use strict"; +const common = require("../../common"); + +if (process.argv[2] === "child") { + const test_finalizer = require(`./build/${common.buildType}/test_finalizer`); + + (() => { + const obj = {}; + test_finalizer.addFinalizerFailOnJS(obj); + })(); + + // Collect garbage 10 times. At least one of those should throw the exception + // and cause the whole process to bail with it, its text printed to stderr and + // asserted by the parent process to match expectations. + let gcCount = 10; + (function gcLoop() { + global.gc(); + if (--gcCount > 0) { + setImmediate(() => gcLoop()); + } + })(); +} else { + const assert = require("assert"); + const { spawnSync } = require("child_process"); + const child = spawnSync(process.execPath, [ + "--expose-gc", + __filename, + "child", + ]); + assert(common.nodeProcessAborted(child.status, child.signal)); + assert.match( + child.stderr.toString(), + /Finalizer is calling a function that may affect GC state/ + ); +} diff --git a/Tests/NodeApi/test/js-native-api/test_finalizer/test_finalizer.c b/Tests/NodeApi/test/js-native-api/test_finalizer/test_finalizer.c new file mode 100644 index 00000000..0d829eee --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_finalizer/test_finalizer.c @@ -0,0 +1,148 @@ +#include +#include +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +typedef struct { + int32_t finalize_count; + napi_ref js_func; +} FinalizerData; + +static void finalizerOnlyCallback(node_api_basic_env env, + void* finalize_data, + void* finalize_hint) { + FinalizerData* data = (FinalizerData*)finalize_data; + int32_t count = ++data->finalize_count; + + // It is safe to access instance data + NODE_API_BASIC_CALL_RETURN_VOID(env, + napi_get_instance_data(env, (void**)&data)); + NODE_API_BASIC_ASSERT_RETURN_VOID(count == data->finalize_count, + "Expected to be the same FinalizerData"); +} + +static void finalizerCallingJSCallback(napi_env env, + void* finalize_data, + void* finalize_hint) { + napi_value js_func, undefined; + FinalizerData* data = (FinalizerData*)finalize_data; + NODE_API_CALL_RETURN_VOID( + env, napi_get_reference_value(env, data->js_func, &js_func)); + NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NODE_API_CALL_RETURN_VOID( + env, napi_call_function(env, undefined, js_func, 0, NULL, NULL)); + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_func)); + data->js_func = NULL; + ++data->finalize_count; +} + +// Schedule async finalizer to run JavaScript-touching code. +static void finalizerWithJSCallback(node_api_basic_env env, + void* finalize_data, + void* finalize_hint) { + NODE_API_BASIC_CALL_RETURN_VOID( + env, + node_api_post_finalizer( + env, finalizerCallingJSCallback, finalize_data, finalize_hint)); +} + +static void finalizerWithFailedJSCallback(node_api_basic_env basic_env, + void* finalize_data, + void* finalize_hint) { + // Intentionally cast to a napi_env to test the fatal failure. + napi_env env = (napi_env)basic_env; + napi_value obj; + FinalizerData* data = (FinalizerData*)finalize_data; + ++data->finalize_count; + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &obj)); +} + +static napi_value addFinalizer(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value argv[1] = {0}; + FinalizerData* data; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_CALL(env, + napi_add_finalizer( + env, argv[0], data, finalizerOnlyCallback, NULL, NULL)); + return NULL; +} + +// This finalizer is going to call JavaScript from finalizer and succeed. +static napi_value addFinalizerWithJS(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value argv[2] = {0}; + napi_valuetype arg_type; + FinalizerData* data; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_CALL(env, napi_typeof(env, argv[1], &arg_type)); + NODE_API_ASSERT( + env, arg_type == napi_function, "Expected function as the second arg"); + NODE_API_CALL(env, napi_create_reference(env, argv[1], 1, &data->js_func)); + NODE_API_CALL(env, + napi_add_finalizer( + env, argv[0], data, finalizerWithJSCallback, NULL, NULL)); + return NULL; +} + +// This finalizer is going to call JavaScript from finalizer and fail. +static napi_value addFinalizerFailOnJS(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value argv[1] = {0}; + FinalizerData* data; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_CALL( + env, + napi_add_finalizer( + env, argv[0], data, finalizerWithFailedJSCallback, NULL, NULL)); + return NULL; +} + +static napi_value getFinalizerCallCount(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value argv[1]; + FinalizerData* data; + napi_value result; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_CALL(env, napi_create_int32(env, data->finalize_count, &result)); + return result; +} + +static void finalizeData(napi_env env, void* data, void* hint) { + free(data); +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + FinalizerData* data = (FinalizerData*)malloc(sizeof(FinalizerData)); + NODE_API_ASSERT(env, data != NULL, "Failed to allocate memory"); + memset(data, 0, sizeof(FinalizerData)); + NODE_API_CALL(env, napi_set_instance_data(env, data, finalizeData, NULL)); + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("addFinalizer", addFinalizer), + DECLARE_NODE_API_PROPERTY("addFinalizerWithJS", addFinalizerWithJS), + DECLARE_NODE_API_PROPERTY("addFinalizerFailOnJS", addFinalizerFailOnJS), + DECLARE_NODE_API_PROPERTY("getFinalizerCallCount", + getFinalizerCallCount)}; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_function/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_function/CMakeLists.txt new file mode 100644 index 00000000..ee290680 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_function/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_function + SOURCES + test_function.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_function/binding.gyp b/Tests/NodeApi/test/js-native-api/test_function/binding.gyp new file mode 100644 index 00000000..7cd97f9d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_function/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_function", + "sources": [ + "test_function.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_function/test.js b/Tests/NodeApi/test/js-native-api/test_function/test.js new file mode 100644 index 00000000..4899fe33 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_function/test.js @@ -0,0 +1,52 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for function +const test_function = require(`./build/${common.buildType}/test_function`); + +function func1() { + return 1; +} +assert.strictEqual(test_function.TestCall(func1), 1); + +function func2() { + console.log('hello world!'); + return null; +} +assert.strictEqual(test_function.TestCall(func2), null); + +function func3(input) { + return input + 1; +} +assert.strictEqual(test_function.TestCall(func3, 1), 2); + +function func4(input) { + return func3(input); +} +assert.strictEqual(test_function.TestCall(func4, 1), 2); + +assert.strictEqual(test_function.TestName.name, 'Name'); +assert.strictEqual(test_function.TestNameShort.name, 'Name_'); + +let tracked_function = test_function.MakeTrackedFunction(common.mustCall()); +assert(!!tracked_function); +tracked_function = null; +global.gc(); + +assert.deepStrictEqual(test_function.TestCreateFunctionParameters(), { + envIsNull: 'Invalid argument', + nameIsNull: 'napi_ok', + cbIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', +}); + +assert.throws( + () => test_function.TestBadReturnExceptionPending(), + { + code: 'throwing exception', + name: 'Error', + }, +); diff --git a/Tests/NodeApi/test/js-native-api/test_function/test_function.c b/Tests/NodeApi/test/js-native-api/test_function/test_function.c new file mode 100644 index 00000000..be660034 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_function/test_function.c @@ -0,0 +1,204 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value TestCreateFunctionParameters(napi_env env, + napi_callback_info info) { + napi_status status; + napi_value result, return_value; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + status = napi_create_function(NULL, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestCreateFunctionParameters, + NULL, + &result); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + status); + + napi_create_function(env, + NULL, + NAPI_AUTO_LENGTH, + TestCreateFunctionParameters, + NULL, + &result); + + add_last_status(env, "nameIsNull", return_value); + + napi_create_function(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + NULL, + NULL, + &result); + + add_last_status(env, "cbIsNull", return_value); + + napi_create_function(env, + "TrackedFunction", + NAPI_AUTO_LENGTH, + TestCreateFunctionParameters, + NULL, + NULL); + + add_last_status(env, "resultIsNull", return_value); + + return return_value; +} + +static napi_value TestCallFunction(napi_env env, napi_callback_info info) { + size_t argc = 10; + napi_value args[10]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc > 0, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_function, + "Wrong type of arguments. Expects a function as first argument."); + + napi_value* argv = args + 1; + argc = argc - 1; + + napi_value global; + NODE_API_CALL(env, napi_get_global(env, &global)); + + napi_value result; + NODE_API_CALL(env, napi_call_function(env, global, args[0], argc, argv, &result)); + + return result; +} + +static napi_value TestFunctionName(napi_env env, napi_callback_info info) { + return NULL; +} + +static void finalize_function(napi_env env, void* data, void* hint) { + napi_ref ref = data; + + // Retrieve the JavaScript undefined value. + napi_value undefined; + NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + + // Retrieve the JavaScript function we must call. + napi_value js_function; + NODE_API_CALL_RETURN_VOID(env, napi_get_reference_value(env, ref, &js_function)); + + // Call the JavaScript function to indicate that the generated JavaScript + // function is about to be gc-ed. + NODE_API_CALL_RETURN_VOID(env, + napi_call_function(env, undefined, js_function, 0, NULL, NULL)); + + // Destroy the persistent reference to the function we just called so as to + // properly clean up. + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, ref)); +} + +static napi_value MakeTrackedFunction(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value js_finalize_cb; + napi_valuetype arg_type; + + // Retrieve and validate from the arguments the function we will use to + // indicate to JavaScript that the function we are about to create is about to + // be gc-ed. + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, &js_finalize_cb, NULL, NULL)); + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + NODE_API_CALL(env, napi_typeof(env, js_finalize_cb, &arg_type)); + NODE_API_ASSERT(env, arg_type == napi_function, "Argument must be a function"); + + // Dynamically create a function. + napi_value result; + NODE_API_CALL(env, + napi_create_function( + env, "TrackedFunction", NAPI_AUTO_LENGTH, TestFunctionName, NULL, + &result)); + + // Create a strong reference to the function we will call when the tracked + // function is about to be gc-ed. + napi_ref js_finalize_cb_ref; + NODE_API_CALL(env, + napi_create_reference(env, js_finalize_cb, 1, &js_finalize_cb_ref)); + + // Attach a finalizer to the dynamically created function and pass it the + // strong reference we created in the previous step. + NODE_API_CALL(env, + napi_wrap( + env, result, js_finalize_cb_ref, finalize_function, NULL, NULL)); + + return result; +} + +static napi_value TestBadReturnExceptionPending(napi_env env, napi_callback_info info) { + napi_throw_error(env, "throwing exception", "throwing exception"); + + // addons should only ever return a valid napi_value even if an + // exception occurs, but we have seen that the C++ wrapper + // with exceptions enabled sometimes returns an invalid value + // when an exception is thrown. Test that we ignore the return + // value then an exception is pending. We use 0xFFFFFFFF as a value + // that should never be a valid napi_value and node seems to + // crash if it is not ignored indicating that it is indeed invalid. + return (napi_value)(0xFFFFFFFFF); +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_value fn1; + NODE_API_CALL(env, napi_create_function( + env, NULL, NAPI_AUTO_LENGTH, TestCallFunction, NULL, &fn1)); + + napi_value fn2; + NODE_API_CALL(env, napi_create_function( + env, "Name", NAPI_AUTO_LENGTH, TestFunctionName, NULL, &fn2)); + + napi_value fn3; + NODE_API_CALL(env, napi_create_function( + env, "Name_extra", 5, TestFunctionName, NULL, &fn3)); + + napi_value fn4; + NODE_API_CALL(env, + napi_create_function( + env, "MakeTrackedFunction", NAPI_AUTO_LENGTH, MakeTrackedFunction, + NULL, &fn4)); + + napi_value fn5; + NODE_API_CALL(env, + napi_create_function( + env, "TestCreateFunctionParameters", NAPI_AUTO_LENGTH, + TestCreateFunctionParameters, NULL, &fn5)); + + napi_value fn6; + NODE_API_CALL(env, + napi_create_function( + env, "TestBadReturnExceptionPending", NAPI_AUTO_LENGTH, + TestBadReturnExceptionPending, NULL, &fn6)); + + NODE_API_CALL(env, napi_set_named_property(env, exports, "TestCall", fn1)); + NODE_API_CALL(env, napi_set_named_property(env, exports, "TestName", fn2)); + NODE_API_CALL(env, + napi_set_named_property(env, exports, "TestNameShort", fn3)); + NODE_API_CALL(env, + napi_set_named_property(env, exports, "MakeTrackedFunction", fn4)); + + NODE_API_CALL(env, + napi_set_named_property( + env, exports, "TestCreateFunctionParameters", fn5)); + + NODE_API_CALL(env, + napi_set_named_property( + env, exports, "TestBadReturnExceptionPending", fn6)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_general/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_general/CMakeLists.txt new file mode 100644 index 00000000..3b3532fd --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_general + SOURCES + test_general.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_general/binding.gyp b/Tests/NodeApi/test/js-native-api/test_general/binding.gyp new file mode 100644 index 00000000..71a4fb6b --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_general", + "sources": [ + "test_general.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_general/test.js b/Tests/NodeApi/test/js-native-api/test_general/test.js new file mode 100644 index 00000000..3bf87a55 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/test.js @@ -0,0 +1,97 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const test_general = require(`./build/${common.buildType}/test_general`); +const assert = require('assert'); + +const val1 = '1'; +const val2 = 1; +const val3 = 1; + +class BaseClass { +} + +class ExtendedClass extends BaseClass { +} + +const baseObject = new BaseClass(); +const extendedObject = new ExtendedClass(); + +// Test napi_strict_equals +assert.ok(test_general.testStrictEquals(val1, val1)); +assert.strictEqual(test_general.testStrictEquals(val1, val2), false); +assert.ok(test_general.testStrictEquals(val2, val3)); + +// Test napi_get_prototype +assert.strictEqual(test_general.testGetPrototype(baseObject), + Object.getPrototypeOf(baseObject)); +assert.strictEqual(test_general.testGetPrototype(extendedObject), + Object.getPrototypeOf(extendedObject)); +// Prototypes for base and extended should be different. +assert.notStrictEqual(test_general.testGetPrototype(baseObject), + test_general.testGetPrototype(extendedObject)); + +// Test version management functions +assert.strictEqual(test_general.testGetVersion(), 8); + +[ + 123, + 'test string', + function() {}, + new Object(), + true, + undefined, + Symbol(), +].forEach((val) => { + assert.strictEqual(test_general.testNapiTypeof(val), typeof val); +}); + +// Since typeof in js return object need to validate specific case +// for null +assert.strictEqual(test_general.testNapiTypeof(null), 'null'); + +// Assert that wrapping twice fails. +const x = {}; +test_general.wrap(x); +assert.throws(() => test_general.wrap(x), + { name: 'Error', message: 'Invalid argument' }); +// Clean up here, otherwise derefItemWasCalled() will be polluted. +test_general.removeWrap(x); + +// Ensure that wrapping, removing the wrap, and then wrapping again works. +const y = {}; +test_general.wrap(y); +test_general.removeWrap(y); +// Wrapping twice succeeds if a remove_wrap() separates the instances +test_general.wrap(y); +// Clean up here, otherwise derefItemWasCalled() will be polluted. +test_general.removeWrap(y); + +// Test napi_adjust_external_memory +// TODO: (vmoroz) Hermes does not implement that API. +// const adjustedValue = test_general.testAdjustExternalMemory(); +// assert.strictEqual(typeof adjustedValue, 'number'); +// assert(adjustedValue > 0); + +async function runGCTests() { + // Ensure that garbage collecting an object with a wrapped native item results + // in the finalize callback being called. + // TODO: (vmoroz) Restore after Hermes GC is fixed. + // assert.strictEqual(test_general.derefItemWasCalled(), false); + // (() => test_general.wrap({}))(); + // await common.gcUntil('deref_item() was called upon garbage collecting a ' + + // 'wrapped object.', + // () => test_general.derefItemWasCalled()); + + // Ensure that removing a wrap and garbage collecting does not fire the + // finalize callback. + let z = {}; + test_general.testFinalizeWrap(z); + test_general.removeWrap(z); + z = null; + await common.gcUntil( + 'finalize callback was not called upon garbage collection.', + () => (!test_general.finalizeWasCalled())); +} +runGCTests(); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testEnvCleanup.js b/Tests/NodeApi/test/js-native-api/test_general/testEnvCleanup.js new file mode 100644 index 00000000..ce59768b --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testEnvCleanup.js @@ -0,0 +1,57 @@ +'use strict'; + +if (process.argv[2] === 'child') { + const common = require('../../common'); + const test_general = require(`./build/${common.buildType}/test_general`); + + // The second argument to `envCleanupWrap()` is an index into the global + // static string array named `env_cleanup_finalizer_messages` on the native + // side. A reverse mapping is reproduced here for clarity. + const finalizerMessages = { + 'simple wrap': 0, + 'wrap, removeWrap': 1, + 'first wrap': 2, + 'second wrap': 3, + }; + + // We attach the three objects we will test to `module.exports` to ensure they + // will not be garbage-collected before the process exits. + + // Make sure the finalizer for a simple wrap will be called at env cleanup. + module.exports['simple wrap'] = + test_general.envCleanupWrap({}, finalizerMessages['simple wrap']); + + // Make sure that a removed wrap does not result in a call to its finalizer at + // env cleanup. + module.exports['wrap, removeWrap'] = + test_general.envCleanupWrap({}, finalizerMessages['wrap, removeWrap']); + test_general.removeWrap(module.exports['wrap, removeWrap']); + + // Make sure that only the latest attached version of a re-wrapped item's + // finalizer gets called at env cleanup. + module.exports['first wrap'] = + test_general.envCleanupWrap({}, finalizerMessages['first wrap']); + test_general.removeWrap(module.exports['first wrap']); + test_general.envCleanupWrap(module.exports['first wrap'], + finalizerMessages['second wrap']); +} else { + const assert = require('assert'); + const { spawnSync } = require('child_process'); + + const child = spawnSync(process.execPath, [__filename, 'child'], { + stdio: [ process.stdin, 'pipe', process.stderr ], + }); + + // Grab the child's output and construct an object whose keys are the rows of + // the output and whose values are `true`, so we can compare the output while + // ignoring the order in which the lines of it were produced. + assert.deepStrictEqual( + child.stdout.toString().split(/\r\n|\r|\n/g).reduce((obj, item) => + Object.assign(obj, item ? { [item]: true } : {}), {}), { + 'finalize at env cleanup for simple wrap': true, + 'finalize at env cleanup for second wrap': true, + }); + + // Ensure that the child exited successfully. + assert.strictEqual(child.status, 0); +} diff --git a/Tests/NodeApi/test/js-native-api/test_general/testFinalizer.js b/Tests/NodeApi/test/js-native-api/test_general/testFinalizer.js new file mode 100644 index 00000000..3eefe142 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testFinalizer.js @@ -0,0 +1,38 @@ +'use strict'; +// Flags: --expose-gc + +const common = require('../../common'); +const test_general = require(`./build/${common.buildType}/test_general`); +const assert = require('assert'); + +(function() { + let finalized = {}; + const callback = common.mustCall(2); + + // Add two items to be finalized and ensure the callback is called for each. + test_general.addFinalizerOnly(finalized, callback); + test_general.addFinalizerOnly(finalized, callback); + + // Ensure attached items cannot be retrieved. + assert.throws(() => test_general.unwrap(finalized), + { name: 'Error', message: 'Invalid argument' }); + + // Ensure attached items cannot be removed. + assert.throws(() => test_general.removeWrap(finalized), + { name: 'Error', message: 'Invalid argument' }); +})(); +global.gc(); + +// Add an item to an object that is already wrapped, and ensure that its +// finalizer as well as the wrap finalizer gets called. +async function testFinalizeAndWrap() { + assert.strictEqual(test_general.derefItemWasCalled(), false); + (function() { + let finalizeAndWrap = {}; + test_general.wrap(finalizeAndWrap); + test_general.addFinalizerOnly(finalizeAndWrap, common.mustCall()); + })(); + await common.gcUntil('test finalize and wrap', + () => test_general.derefItemWasCalled()); +} +testFinalizeAndWrap(); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testGlobals.js b/Tests/NodeApi/test/js-native-api/test_general/testGlobals.js new file mode 100644 index 00000000..34188e08 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testGlobals.js @@ -0,0 +1,8 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +const test_globals = require(`./build/${common.buildType}/test_general`); + +assert.strictEqual(test_globals.getUndefined(), undefined); +assert.strictEqual(test_globals.getNull(), null); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testInstanceOf.js b/Tests/NodeApi/test/js-native-api/test_general/testInstanceOf.js new file mode 100644 index 00000000..c9b98fa8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testInstanceOf.js @@ -0,0 +1,46 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Addon is referenced through the eval expression in testFile +const addon = require(`./build/${common.buildType}/test_general`); + +// We can only perform this test if we have a working Symbol.hasInstance +if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol && + typeof Symbol.hasInstance === 'symbol') { + + function compareToNative(theObject, theConstructor) { + assert.strictEqual( + addon.doInstanceOf(theObject, theConstructor), + (theObject instanceof theConstructor), + ); + } + + function MyClass() {} + Object.defineProperty(MyClass, Symbol.hasInstance, { + value: function(candidate) { + return 'mark' in candidate; + }, + }); + + function MySubClass() {} + MySubClass.prototype = new MyClass(); + + let x = new MySubClass(); + let y = new MySubClass(); + x.mark = true; + + compareToNative(x, MySubClass); + compareToNative(y, MySubClass); + compareToNative(x, MyClass); + compareToNative(y, MyClass); + + x = new MyClass(); + y = new MyClass(); + x.mark = true; + + compareToNative(x, MySubClass); + compareToNative(y, MySubClass); + compareToNative(x, MyClass); + compareToNative(y, MyClass); +} diff --git a/Tests/NodeApi/test/js-native-api/test_general/testNapiRun.js b/Tests/NodeApi/test/js-native-api/test_general/testNapiRun.js new file mode 100644 index 00000000..6d4f4662 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testNapiRun.js @@ -0,0 +1,14 @@ +'use strict'; + +const common = require('../../common'); +const assert = require('assert'); + +// `addon` is referenced through the eval expression in testFile +const addon = require(`./build/${common.buildType}/test_general`); + +const testCase = '(41.92 + 0.08);'; +const expected = 42; +const actual = addon.testNapiRun(testCase); + +assert.strictEqual(actual, expected); +assert.throws(() => addon.testNapiRun({ abc: 'def' }), /string was expected/); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testNapiStatus.js b/Tests/NodeApi/test/js-native-api/test_general/testNapiStatus.js new file mode 100644 index 00000000..5ad97a34 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testNapiStatus.js @@ -0,0 +1,8 @@ +'use strict'; + +const common = require('../../common'); +const addon = require(`./build/${common.buildType}/test_general`); +const assert = require('assert'); + +addon.createNapiError(); +assert(addon.testNapiErrorCleanup(), 'napi_status cleaned up for second call'); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof.js b/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof.js new file mode 100644 index 00000000..0b476e1e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof.js @@ -0,0 +1,121 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +const common = require('../../common'); +const addon = require(`./build/${common.buildType}/test_general`); +const assert = require('assert'); + +// The following assert functions are referenced by v8's unit tests +// See for instance deps/v8/test/mjsunit/instanceof.js +// eslint-disable-next-line no-unused-vars +function assertTrue(assertion) { + return assert.strictEqual(assertion, true); +} + +// eslint-disable-next-line no-unused-vars +function assertFalse(assertion) { + assert.strictEqual(assertion, false); +} + +// eslint-disable-next-line no-unused-vars +function assertEquals(leftHandSide, rightHandSide) { + assert.strictEqual(leftHandSide, rightHandSide); +} + +// eslint-disable-next-line no-unused-vars +function assertThrows(statement) { + assert.throws(function() { + eval(statement); + }, Error); +} + +assertTrue(addon.doInstanceOf({}, Object)); +assertTrue(addon.doInstanceOf([], Object)); + +assertFalse(addon.doInstanceOf({}, Array)); +assertTrue(addon.doInstanceOf([], Array)); + +function TestChains() { + var A = {}; + var B = {}; + var C = {}; + B.__proto__ = A; + C.__proto__ = B; + + function F() { } + F.prototype = A; + assertTrue(addon.doInstanceOf(C, F)); + assertTrue(addon.doInstanceOf(B, F)); + assertFalse(addon.doInstanceOf(A, F)); + + F.prototype = B; + assertTrue(addon.doInstanceOf(C, F)); + assertFalse(addon.doInstanceOf(B, F)); + assertFalse(addon.doInstanceOf(A, F)); + + F.prototype = C; + assertFalse(addon.doInstanceOf(C, F)); + assertFalse(addon.doInstanceOf(B, F)); + assertFalse(addon.doInstanceOf(A, F)); +} + +TestChains(); + + +function TestExceptions() { + function F() { } + var items = [ 1, new Number(42), + true, + 'string', new String('hest'), + {}, [], + F, new F(), + Object, String ]; + + var exceptions = 0; + var instanceofs = 0; + + for (var i = 0; i < items.length; i++) { + for (var j = 0; j < items.length; j++) { + try { + if (addon.doInstanceOf(items[i], items[j])) instanceofs++; + } catch (e) { + assertTrue(addon.doInstanceOf(e, TypeError)); + exceptions++; + } + } + } + assertEquals(10, instanceofs); + assertEquals(88, exceptions); + + // Make sure to throw an exception if the function prototype + // isn't a proper JavaScript object. + function G() { } + G.prototype = undefined; + assertThrows("addon.doInstanceOf({}, G)"); +} + +TestExceptions(); diff --git a/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof2.js b/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof2.js new file mode 100644 index 00000000..360b28c8 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/testV8Instanceof2.js @@ -0,0 +1,341 @@ +// Copyright 2010 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +const common = require('../../common'); +const addon = require(`./build/${common.buildType}/test_general`); +const assert = require('assert'); + +function assertTrue(assertion) { + return assert.strictEqual(assertion, true); +} + +function assertEquals(leftHandSide, rightHandSide) { + assert.strictEqual(leftHandSide, rightHandSide); +} + +var except = "exception"; + +var correct_answer_index = 0; +var correct_answers = [ + false, false, true, true, false, false, true, true, + true, false, false, true, true, false, false, true, + false, true, true, false, false, true, true, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, false, true, +except, except, true, false, except, except, true, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, true, false, except, except, + false, true, except, except, false, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, false, true, true, false, + true, true, false, false, false, true, true, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, true, false, +except, except, false, false, except, except, true, false, + false, false, except, except, false, false, except, except, + true, false, except, except, true, false, except, except, + false, true, except, except, false, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, true, true, false, + true, false, false, true, true, true, false, false, + false, true, true, false, false, true, true, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, false, true, +except, except, true, false, except, except, true, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, true, true, false, + true, false, false, true, false, true, true, false, + false, true, true, false, false, true, true, false, + true, true, false, false, false, true, true, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, true, false, +except, except, false, false, except, except, true, false, + false, false, except, except, false, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, false, false, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, false, false, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, true, true, false, false, + true, false, false, true, true, true, false, false, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, true, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, true, true, false, false, + true, false, false, true, true, true, false, false, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, true, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, true, true, false, false, + false, true, true, false, false, false, true, true, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, false, false, +except, except, true, false, except, except, true, true, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, false, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, false, false, true, true, + true, true, false, false, false, false, true, true, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, true, true, +except, except, false, false, except, except, true, true, + false, false, except, except, false, false, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, false, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, true, true, false, false, + false, true, true, false, false, false, true, true, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, false, false, +except, except, true, false, except, except, true, true, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, false, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, false, false, true, true, + true, true, false, false, false, false, true, true, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, true, true, +except, except, false, false, except, except, true, true, + false, false, except, except, false, false, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, false, false, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, false, false, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, false, false, true, true, + true, false, false, true, false, false, true, true, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, false, false, except, except, + true, false, except, except, false, false, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, true, true, false, false, + true, false, false, true, true, true, false, false, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, true, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, + false, false, true, true, true, true, false, false, + true, false, false, true, true, true, false, false, + false, true, true, false, true, true, false, false, + true, true, false, false, true, true, false, false, +except, except, true, true, except, except, true, true, +except, except, false, true, except, except, true, true, +except, except, true, false, except, except, false, false, +except, except, false, false, except, except, false, false, + false, false, except, except, true, true, except, except, + true, false, except, except, true, true, except, except, + false, true, except, except, true, true, except, except, + true, true, except, except, true, true, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except, +except, except, except, except, except, except, except, except]; + +for (var i = 0; i < 256; i++) { + Test(i & 1, i & 2, i & 4, i & 8, i & 0x10, i & 0x20, i & 0x40, i & 0x80); +} + + +function InstanceTest(x, func) { + try { + var answer = addon.doInstanceOf(x, func); + assertEquals(correct_answers[correct_answer_index], answer); + } catch (e) { + assertTrue(/prototype/.test(e)); + assertEquals(correct_answers[correct_answer_index], except); + } + correct_answer_index++; +} + + +function Test(a, b, c, d, e, f, g, h) { + var Foo = function() { } + var Bar = function() { } + + if (c) Foo.prototype = 12; + if (d) Bar.prototype = 13; + var x = a ? new Foo() : new Bar(); + var y = b ? new Foo() : new Bar(); + InstanceTest(x, Foo); + InstanceTest(y, Foo); + InstanceTest(x, Bar); + InstanceTest(y, Bar); + if (e) x.__proto__ = Bar.prototype; + if (f) y.__proto__ = Foo.prototype; + if (g) { + x.__proto__ = y; + } else { + if (h) y.__proto__ = x + } + InstanceTest(x, Foo); + InstanceTest(y, Foo); + InstanceTest(x, Bar); + InstanceTest(y, Bar); +} diff --git a/Tests/NodeApi/test/js-native-api/test_general/test_general.c b/Tests/NodeApi/test/js-native-api/test_general/test_general.c new file mode 100644 index 00000000..2e130af6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_general/test_general.c @@ -0,0 +1,315 @@ +// we define NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED here to +// validate that it can be used as a form of test itself. It is +// not related to any of the other tests +// defined in the file +#define NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED +#include +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value testStrictEquals(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + bool bool_result; + napi_value result; + NODE_API_CALL(env, napi_strict_equals(env, args[0], args[1], &bool_result)); + NODE_API_CALL(env, napi_get_boolean(env, bool_result, &result)); + + return result; +} + +static napi_value testGetPrototype(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value result; + NODE_API_CALL(env, napi_get_prototype(env, args[0], &result)); + + return result; +} + +static napi_value testGetVersion(napi_env env, napi_callback_info info) { + uint32_t version; + napi_value result; + NODE_API_CALL(env, napi_get_version(env, &version)); + NODE_API_CALL(env, napi_create_uint32(env, version, &result)); + return result; +} + +static napi_value doInstanceOf(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + bool instanceof; + NODE_API_CALL(env, napi_instanceof(env, args[0], args[1], &instanceof)); + + napi_value result; + NODE_API_CALL(env, napi_get_boolean(env, instanceof, &result)); + + return result; +} + +static napi_value getNull(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_get_null(env, &result)); + return result; +} + +static napi_value getUndefined(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_get_undefined(env, &result)); + return result; +} + +static napi_value createNapiError(napi_env env, napi_callback_info info) { + napi_value value; + NODE_API_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value)); + + double double_value; + napi_status status = napi_get_value_double(env, value, &double_value); + + NODE_API_ASSERT(env, status != napi_ok, "Failed to produce error condition"); + + const napi_extended_error_info *error_info = 0; + NODE_API_CALL(env, napi_get_last_error_info(env, &error_info)); + + NODE_API_ASSERT(env, error_info->error_code == status, + "Last error info code should match last status"); + NODE_API_ASSERT(env, error_info->error_message, + "Last error info message should not be null"); + + return NULL; +} + +static napi_value testNapiErrorCleanup(napi_env env, napi_callback_info info) { + const napi_extended_error_info *error_info = 0; + NODE_API_CALL(env, napi_get_last_error_info(env, &error_info)); + + napi_value result; + bool is_ok = error_info->error_code == napi_ok; + NODE_API_CALL(env, napi_get_boolean(env, is_ok, &result)); + + return result; +} + +static napi_value testNapiTypeof(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_valuetype argument_type; + NODE_API_CALL(env, napi_typeof(env, args[0], &argument_type)); + + napi_value result = NULL; + if (argument_type == napi_number) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "number", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_string) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "string", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_function) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "function", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_object) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "object", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_boolean) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "boolean", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_undefined) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "undefined", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_symbol) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "symbol", NAPI_AUTO_LENGTH, &result)); + } else if (argument_type == napi_null) { + NODE_API_CALL(env, napi_create_string_utf8( + env, "null", NAPI_AUTO_LENGTH, &result)); + } + return result; +} + +static bool deref_item_called = false; +static void deref_item(napi_env env, void* data, void* hint) { + (void) hint; + + NODE_API_ASSERT_RETURN_VOID(env, data == &deref_item_called, + "Finalize callback was called with the correct pointer"); + + deref_item_called = true; +} + +static napi_value deref_item_was_called(napi_env env, napi_callback_info info) { + napi_value it_was_called; + + NODE_API_CALL(env, napi_get_boolean(env, deref_item_called, &it_was_called)); + + return it_was_called; +} + +static napi_value wrap_first_arg(napi_env env, + napi_callback_info info, + napi_finalize finalizer, + void* data) { + size_t argc = 1; + napi_value to_wrap; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &to_wrap, NULL, NULL)); + NODE_API_CALL(env, napi_wrap(env, to_wrap, data, finalizer, NULL, NULL)); + + return to_wrap; +} + +static napi_value wrap(napi_env env, napi_callback_info info) { + deref_item_called = false; + return wrap_first_arg(env, info, deref_item, &deref_item_called); +} + +static napi_value unwrap(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value wrapped; + void* data; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &wrapped, NULL, NULL)); + NODE_API_CALL(env, napi_unwrap(env, wrapped, &data)); + + return NULL; +} + +static napi_value remove_wrap(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value wrapped; + void* data; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &wrapped, NULL, NULL)); + NODE_API_CALL(env, napi_remove_wrap(env, wrapped, &data)); + + return NULL; +} + +static bool finalize_called = false; +static void test_finalize(napi_env env, void* data, void* hint) { + finalize_called = true; +} + +static napi_value test_finalize_wrap(napi_env env, napi_callback_info info) { + return wrap_first_arg(env, info, test_finalize, NULL); +} + +static napi_value finalize_was_called(napi_env env, napi_callback_info info) { + napi_value it_was_called; + + NODE_API_CALL(env, napi_get_boolean(env, finalize_called, &it_was_called)); + + return it_was_called; +} + +static napi_value testAdjustExternalMemory(napi_env env, napi_callback_info info) { + napi_value result; + int64_t adjustedValue; + + NODE_API_CALL(env, napi_adjust_external_memory(env, 1, &adjustedValue)); + NODE_API_CALL(env, napi_create_double(env, (double)adjustedValue, &result)); + + return result; +} + +static napi_value testNapiRun(napi_env env, napi_callback_info info) { + napi_value script, result; + size_t argc = 1; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &script, NULL, NULL)); + + NODE_API_CALL(env, napi_run_script(env, script, &result)); + + return result; +} + +static void finalizer_only_callback(napi_env env, void* data, void* hint) { + napi_ref js_cb_ref = data; + napi_value js_cb, undefined; + NODE_API_CALL_RETURN_VOID(env, napi_get_reference_value(env, js_cb_ref, &js_cb)); + NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NODE_API_CALL_RETURN_VOID(env, + napi_call_function(env, undefined, js_cb, 0, NULL, NULL)); + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, js_cb_ref)); +} + +static napi_value add_finalizer_only(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value argv[2]; + napi_ref js_cb_ref; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_create_reference(env, argv[1], 1, &js_cb_ref)); + NODE_API_CALL(env, + napi_add_finalizer( + env, argv[0], js_cb_ref, finalizer_only_callback, NULL, NULL)); + return NULL; +} + +static const char* env_cleanup_finalizer_messages[] = { + "simple wrap", + "wrap, removeWrap", + "first wrap", + "second wrap" +}; + +static void cleanup_env_finalizer(napi_env env, void* data, void* hint) { + (void) env; + (void) hint; + + printf("finalize at env cleanup for %s\n", + env_cleanup_finalizer_messages[(uintptr_t)data]); +} + +static napi_value env_cleanup_wrap(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value argv[2]; + uint32_t value; + uintptr_t ptr_value; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + + NODE_API_CALL(env, napi_get_value_uint32(env, argv[1], &value)); + + ptr_value = value; + return wrap_first_arg(env, info, cleanup_env_finalizer, (void*)ptr_value); +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("testStrictEquals", testStrictEquals), + DECLARE_NODE_API_PROPERTY("testGetPrototype", testGetPrototype), + DECLARE_NODE_API_PROPERTY("testGetVersion", testGetVersion), + DECLARE_NODE_API_PROPERTY("testNapiRun", testNapiRun), + DECLARE_NODE_API_PROPERTY("doInstanceOf", doInstanceOf), + DECLARE_NODE_API_PROPERTY("getUndefined", getUndefined), + DECLARE_NODE_API_PROPERTY("getNull", getNull), + DECLARE_NODE_API_PROPERTY("createNapiError", createNapiError), + DECLARE_NODE_API_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup), + DECLARE_NODE_API_PROPERTY("testNapiTypeof", testNapiTypeof), + DECLARE_NODE_API_PROPERTY("wrap", wrap), + DECLARE_NODE_API_PROPERTY("envCleanupWrap", env_cleanup_wrap), + DECLARE_NODE_API_PROPERTY("unwrap", unwrap), + DECLARE_NODE_API_PROPERTY("removeWrap", remove_wrap), + DECLARE_NODE_API_PROPERTY("addFinalizerOnly", add_finalizer_only), + DECLARE_NODE_API_PROPERTY("testFinalizeWrap", test_finalize_wrap), + DECLARE_NODE_API_PROPERTY("finalizeWasCalled", finalize_was_called), + DECLARE_NODE_API_PROPERTY("derefItemWasCalled", deref_item_was_called), + DECLARE_NODE_API_PROPERTY("testAdjustExternalMemory", testAdjustExternalMemory) + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_handle_scope/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_handle_scope/CMakeLists.txt new file mode 100644 index 00000000..579119a3 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_handle_scope/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_handle_scope + SOURCES + test_handle_scope.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_handle_scope/binding.gyp b/Tests/NodeApi/test/js-native-api/test_handle_scope/binding.gyp new file mode 100644 index 00000000..dd6dd63a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_handle_scope/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_handle_scope", + "sources": [ + "test_handle_scope.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_handle_scope/test.js b/Tests/NodeApi/test/js-native-api/test_handle_scope/test.js new file mode 100644 index 00000000..46aa12f6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_handle_scope/test.js @@ -0,0 +1,19 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing handle scope api calls +const testHandleScope = + require(`./build/${common.buildType}/test_handle_scope`); + +testHandleScope.NewScope(); + +assert.ok(testHandleScope.NewScopeEscape() instanceof Object); + +testHandleScope.NewScopeEscapeTwice(); + +assert.throws( + () => { + testHandleScope.NewScopeWithException(() => { throw new RangeError(); }); + }, + RangeError); diff --git a/Tests/NodeApi/test/js-native-api/test_handle_scope/test_handle_scope.c b/Tests/NodeApi/test/js-native-api/test_handle_scope/test_handle_scope.c new file mode 100644 index 00000000..7c5eb4a4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_handle_scope/test_handle_scope.c @@ -0,0 +1,86 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" + +// these tests validate the handle scope functions in the normal +// flow. Forcing gc behavior to fully validate they are doing +// the right right thing would be quite hard so we keep it +// simple for now. + +static napi_value NewScope(napi_env env, napi_callback_info info) { + napi_handle_scope scope; + napi_value output = NULL; + + NODE_API_CALL(env, napi_open_handle_scope(env, &scope)); + NODE_API_CALL(env, napi_create_object(env, &output)); + NODE_API_CALL(env, napi_close_handle_scope(env, scope)); + return NULL; +} + +static napi_value NewScopeEscape(napi_env env, napi_callback_info info) { + napi_escapable_handle_scope scope; + napi_value output = NULL; + napi_value escapee = NULL; + + NODE_API_CALL(env, napi_open_escapable_handle_scope(env, &scope)); + NODE_API_CALL(env, napi_create_object(env, &output)); + NODE_API_CALL(env, napi_escape_handle(env, scope, output, &escapee)); + NODE_API_CALL(env, napi_close_escapable_handle_scope(env, scope)); + return escapee; +} + +static napi_value NewScopeEscapeTwice(napi_env env, napi_callback_info info) { + napi_escapable_handle_scope scope; + napi_value output = NULL; + napi_value escapee = NULL; + napi_status status; + + NODE_API_CALL(env, napi_open_escapable_handle_scope(env, &scope)); + NODE_API_CALL(env, napi_create_object(env, &output)); + NODE_API_CALL(env, napi_escape_handle(env, scope, output, &escapee)); + status = napi_escape_handle(env, scope, output, &escapee); + NODE_API_ASSERT(env, status == napi_escape_called_twice, "Escaping twice fails"); + NODE_API_CALL(env, napi_close_escapable_handle_scope(env, scope)); + return NULL; +} + +static napi_value NewScopeWithException(napi_env env, napi_callback_info info) { + napi_handle_scope scope; + size_t argc; + napi_value exception_function; + napi_status status; + napi_value output = NULL; + + NODE_API_CALL(env, napi_open_handle_scope(env, &scope)); + NODE_API_CALL(env, napi_create_object(env, &output)); + + argc = 1; + NODE_API_CALL(env, napi_get_cb_info( + env, info, &argc, &exception_function, NULL, NULL)); + + status = napi_call_function( + env, output, exception_function, 0, NULL, NULL); + NODE_API_ASSERT(env, status == napi_pending_exception, + "Function should have thrown."); + + // Closing a handle scope should still work while an exception is pending. + NODE_API_CALL(env, napi_close_handle_scope(env, scope)); + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("NewScope", NewScope), + DECLARE_NODE_API_PROPERTY("NewScopeEscape", NewScopeEscape), + DECLARE_NODE_API_PROPERTY("NewScopeEscapeTwice", NewScopeEscapeTwice), + DECLARE_NODE_API_PROPERTY("NewScopeWithException", NewScopeWithException), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_instance_data/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_instance_data/CMakeLists.txt new file mode 100644 index 00000000..feda8f59 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_instance_data/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_instance_data + SOURCES + test_instance_data.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_instance_data/binding.gyp b/Tests/NodeApi/test/js-native-api/test_instance_data/binding.gyp new file mode 100644 index 00000000..f1c77b30 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_instance_data/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_instance_data", + "sources": [ + "test_instance_data.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_instance_data/test.js b/Tests/NodeApi/test/js-native-api/test_instance_data/test.js new file mode 100644 index 00000000..043da9f1 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_instance_data/test.js @@ -0,0 +1,41 @@ +'use strict'; +// Test API calls for instance data. + +const common = require('../../common'); +const assert = require('assert'); + +if (module !== require.main) { + // When required as a module, run the tests. + const test_instance_data = + require(`./build/${common.buildType}/test_instance_data`); + + // Print to stdout when the environment deletes the instance data. This output + // is checked by the parent process. + test_instance_data.setPrintOnDelete(); + + // Test that instance data can be accessed from a binding. + assert.strictEqual(test_instance_data.increment(), 42); + + // Test that the instance data can be accessed from a finalizer. + // TODO: (vmoroz) Restore after Hermes fixes GC. + // test_instance_data.objectWithFinalizer(common.mustCall()); + // global.gc(); +} else { + // When launched as a script, run tests in either a child process or in a + // worker thread. + const requireAs = require('../../common/require-as'); + const runOptions = { stdio: ['inherit', 'pipe', 'inherit'] }; + + function checkOutput(child) { + assert.strictEqual(child.status, 0); + assert.strictEqual( + (child.stdout.toString().split(/\r\n?|\n/) || [])[0], + 'deleting addon data'); + } + + // Run tests in a child process. + checkOutput(requireAs(__filename, ['--expose-gc'], runOptions, 'child')); + + // Run tests in a worker thread in a child process. + checkOutput(requireAs(__filename, ['--expose-gc'], runOptions, 'worker')); +} diff --git a/Tests/NodeApi/test/js-native-api/test_instance_data/test_instance_data.c b/Tests/NodeApi/test/js-native-api/test_instance_data/test_instance_data.c new file mode 100644 index 00000000..bf354983 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_instance_data/test_instance_data.c @@ -0,0 +1,96 @@ +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +typedef struct { + size_t value; + bool print; + napi_ref js_cb_ref; +} AddonData; + +static napi_value Increment(napi_env env, napi_callback_info info) { + AddonData* data; + napi_value result; + + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_CALL(env, napi_create_uint32(env, ++data->value, &result)); + + return result; +} + +static void DeleteAddonData(napi_env env, void* raw_data, void* hint) { + AddonData* data = raw_data; + if (data->print) { + printf("deleting addon data\n"); + } + if (data->js_cb_ref != NULL) { + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref)); + } + free(data); +} + +static napi_value SetPrintOnDelete(napi_env env, napi_callback_info info) { + AddonData* data; + + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + data->print = true; + + return NULL; +} + +static void TestFinalizer(napi_env env, void* raw_data, void* hint) { + (void) raw_data; + (void) hint; + + AddonData* data; + NODE_API_CALL_RETURN_VOID(env, napi_get_instance_data(env, (void**)&data)); + napi_value js_cb, undefined; + NODE_API_CALL_RETURN_VOID(env, + napi_get_reference_value(env, data->js_cb_ref, &js_cb)); + NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined)); + NODE_API_CALL_RETURN_VOID(env, + napi_call_function(env, undefined, js_cb, 0, NULL, NULL)); + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref)); + data->js_cb_ref = NULL; +} + +static napi_value ObjectWithFinalizer(napi_env env, napi_callback_info info) { + AddonData* data; + napi_value result, js_cb; + size_t argc = 1; + + NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data)); + NODE_API_ASSERT(env, data->js_cb_ref == NULL, "reference must be NULL"); + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL)); + NODE_API_CALL(env, napi_create_object(env, &result)); + NODE_API_CALL(env, + napi_add_finalizer(env, result, NULL, TestFinalizer, NULL, NULL)); + NODE_API_CALL(env, napi_create_reference(env, js_cb, 1, &data->js_cb_ref)); + + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + AddonData* data = malloc(sizeof(*data)); + data->value = 41; + data->print = false; + data->js_cb_ref = NULL; + + NODE_API_CALL(env, napi_set_instance_data(env, data, DeleteAddonData, NULL)); + + napi_property_descriptor props[] = { + DECLARE_NODE_API_PROPERTY("increment", Increment), + DECLARE_NODE_API_PROPERTY("setPrintOnDelete", SetPrintOnDelete), + DECLARE_NODE_API_PROPERTY("objectWithFinalizer", ObjectWithFinalizer), + }; + + NODE_API_CALL(env, + napi_define_properties( + env, exports, sizeof(props) / sizeof(*props), props)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_new_target/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_new_target/CMakeLists.txt new file mode 100644 index 00000000..1cee2625 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_new_target/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_new_target + SOURCES + test_new_target.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_new_target/binding.gyp b/Tests/NodeApi/test/js-native-api/test_new_target/binding.gyp new file mode 100644 index 00000000..baa0e3c6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_new_target/binding.gyp @@ -0,0 +1,11 @@ +{ + 'targets': [ + { + 'target_name': 'test_new_target', + 'defines': [ 'V8_DEPRECATION_WARNINGS=1' ], + 'sources': [ + 'test_new_target.c' + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_new_target/test.js b/Tests/NodeApi/test/js-native-api/test_new_target/test.js new file mode 100644 index 00000000..06d5ef36 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_new_target/test.js @@ -0,0 +1,21 @@ +'use strict'; + +const common = require('../../common'); +const assert = require('assert'); +const binding = require(`./build/${common.buildType}/test_new_target`); + +class Class extends binding.BaseClass { + constructor() { + super(); + this.method(); + } + method() { + this.ok = true; + } +} + +assert.ok(new Class() instanceof binding.BaseClass); +assert.ok(new Class().ok); +assert.ok(binding.OrdinaryFunction()); +assert.ok( + new binding.Constructor(binding.Constructor) instanceof binding.Constructor); diff --git a/Tests/NodeApi/test/js-native-api/test_new_target/test_new_target.c b/Tests/NodeApi/test/js-native-api/test_new_target/test_new_target.c new file mode 100644 index 00000000..02ceb992 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_new_target/test_new_target.c @@ -0,0 +1,92 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value BaseClass(napi_env env, napi_callback_info info) { + napi_value newTargetArg; + NODE_API_CALL(env, napi_get_new_target(env, info, &newTargetArg)); + napi_value thisArg; + NODE_API_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &thisArg, NULL)); + napi_value undefined; + NODE_API_CALL(env, napi_get_undefined(env, &undefined)); + + // this !== new.target since we are being invoked through super() + bool result; + NODE_API_CALL(env, napi_strict_equals(env, newTargetArg, thisArg, &result)); + NODE_API_ASSERT(env, !result, "this !== new.target"); + + // new.target !== undefined because we should be called as a new expression + NODE_API_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL"); + NODE_API_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result)); + NODE_API_ASSERT(env, !result, "new.target !== undefined"); + + return thisArg; +} + +static napi_value Constructor(napi_env env, napi_callback_info info) { + bool result; + napi_value newTargetArg; + NODE_API_CALL(env, napi_get_new_target(env, info, &newTargetArg)); + size_t argc = 1; + napi_value argv; + napi_value thisArg; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisArg, NULL)); + napi_value undefined; + NODE_API_CALL(env, napi_get_undefined(env, &undefined)); + + // new.target !== undefined because we should be called as a new expression + NODE_API_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL"); + NODE_API_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result)); + NODE_API_ASSERT(env, !result, "new.target !== undefined"); + + // arguments[0] should be Constructor itself (test harness passed it) + NODE_API_CALL(env, napi_strict_equals(env, newTargetArg, argv, &result)); + NODE_API_ASSERT(env, result, "new.target === Constructor"); + + return thisArg; +} + +static napi_value OrdinaryFunction(napi_env env, napi_callback_info info) { + napi_value newTargetArg; + NODE_API_CALL(env, napi_get_new_target(env, info, &newTargetArg)); + + NODE_API_ASSERT(env, newTargetArg == NULL, "newTargetArg == NULL"); + + napi_value _true; + NODE_API_CALL(env, napi_get_boolean(env, true, &_true)); + return _true; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_value baseClass, constructor; + NODE_API_CALL( + env, + napi_define_class( + env, + "BaseClass", + NAPI_AUTO_LENGTH, + BaseClass, + NULL, + 0, + NULL, + &baseClass)); + NODE_API_CALL( + env, + napi_define_class( + env, + "Constructor", + NAPI_AUTO_LENGTH, + Constructor, + NULL, + 0, + NULL, + &constructor)); + const napi_property_descriptor desc[] = { + DECLARE_NODE_API_PROPERTY_VALUE("BaseClass", baseClass), + DECLARE_NODE_API_PROPERTY("OrdinaryFunction", OrdinaryFunction), + DECLARE_NODE_API_PROPERTY_VALUE("Constructor", constructor)}; + NODE_API_CALL(env, napi_define_properties(env, exports, 3, desc)); + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_number/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_number/CMakeLists.txt new file mode 100644 index 00000000..87946947 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/CMakeLists.txt @@ -0,0 +1,5 @@ +add_node_api_module(test_number + SOURCES + test_number.c + test_null.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_number/binding.gyp b/Tests/NodeApi/test/js-native-api/test_number/binding.gyp new file mode 100644 index 00000000..31707404 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/binding.gyp @@ -0,0 +1,11 @@ +{ + "targets": [ + { + "target_name": "test_number", + "sources": [ + "test_number.c", + "test_null.c", + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_number/test.js b/Tests/NodeApi/test/js-native-api/test_number/test.js new file mode 100644 index 00000000..6c0f0f3e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/test.js @@ -0,0 +1,134 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const test_number = require(`./build/${common.buildType}/test_number`); + + +// Testing api calls for number +function testNumber(num) { + assert.strictEqual(num, test_number.Test(num)); +} + +testNumber(0); +testNumber(-0); +testNumber(1); +testNumber(-1); +testNumber(100); +testNumber(2121); +testNumber(-1233); +testNumber(986583); +testNumber(-976675); + +/* eslint-disable no-loss-of-precision */ +testNumber( + 98765432213456789876546896323445679887645323232436587988766545658); +testNumber( + -4350987086545760976737453646576078997096876957864353245245769809); +/* eslint-enable no-loss-of-precision */ +testNumber(Number.MIN_SAFE_INTEGER); +testNumber(Number.MAX_SAFE_INTEGER); +testNumber(Number.MAX_SAFE_INTEGER + 10); + +testNumber(Number.MIN_VALUE); +testNumber(Number.MAX_VALUE); +testNumber(Number.MAX_VALUE + 10); + +testNumber(Number.POSITIVE_INFINITY); +testNumber(Number.NEGATIVE_INFINITY); +testNumber(Number.NaN); + +function testUint32(input, expected = input) { + assert.strictEqual(expected, test_number.TestUint32Truncation(input)); +} + +// Test zero +testUint32(0.0, 0); +testUint32(-0.0, 0); + +// Test overflow scenarios +testUint32(4294967295); +testUint32(4294967296, 0); +testUint32(4294967297, 1); +testUint32(17 * 4294967296 + 1, 1); +testUint32(-1, 0xffffffff); + +// Validate documented behavior when value is retrieved as 32-bit integer with +// `napi_get_value_int32` +function testInt32(input, expected = input) { + assert.strictEqual(expected, test_number.TestInt32Truncation(input)); +} + +// Test zero +testInt32(0.0, 0); +testInt32(-0.0, 0); + +// Test min/max int32 range +testInt32(-Math.pow(2, 31)); +testInt32(Math.pow(2, 31) - 1); + +// Test overflow scenarios +testInt32(4294967297, 1); +testInt32(4294967296, 0); +testInt32(4294967295, -1); +testInt32(4294967296 * 5 + 3, 3); + +// Test min/max safe integer range +testInt32(Number.MIN_SAFE_INTEGER, 1); +testInt32(Number.MAX_SAFE_INTEGER, -1); + +// Test within int64_t range (with precision loss) +testInt32(-Math.pow(2, 63) + (Math.pow(2, 9) + 1), 1024); +testInt32(Math.pow(2, 63) - (Math.pow(2, 9) + 1), -1024); + +// Test min/max double value +testInt32(-Number.MIN_VALUE, 0); +testInt32(Number.MIN_VALUE, 0); +testInt32(-Number.MAX_VALUE, 0); +testInt32(Number.MAX_VALUE, 0); + +// Test outside int64_t range +testInt32(-Math.pow(2, 63) + (Math.pow(2, 9)), 0); +testInt32(Math.pow(2, 63) - (Math.pow(2, 9)), 0); + +// Test non-finite numbers +testInt32(Number.POSITIVE_INFINITY, 0); +testInt32(Number.NEGATIVE_INFINITY, 0); +testInt32(Number.NaN, 0); + +// Validate documented behavior when value is retrieved as 64-bit integer with +// `napi_get_value_int64` +function testInt64(input, expected = input) { + assert.strictEqual(expected, test_number.TestInt64Truncation(input)); +} + +// Both V8 and ChakraCore return a sentinel value of `0x8000000000000000` when +// the conversion goes out of range, but V8 treats it as unsigned in some cases. +const RANGEERROR_POSITIVE = Math.pow(2, 63); +const RANGEERROR_NEGATIVE = -Math.pow(2, 63); + +// Test zero +testInt64(0.0, 0); +testInt64(-0.0, 0); + +// Test min/max safe integer range +testInt64(Number.MIN_SAFE_INTEGER); +testInt64(Number.MAX_SAFE_INTEGER); + +// Test within int64_t range (with precision loss) +testInt64(-Math.pow(2, 63) + (Math.pow(2, 9) + 1)); +testInt64(Math.pow(2, 63) - (Math.pow(2, 9) + 1)); + +// Test min/max double value +testInt64(-Number.MIN_VALUE, 0); +testInt64(Number.MIN_VALUE, 0); +testInt64(-Number.MAX_VALUE, RANGEERROR_NEGATIVE); +testInt64(Number.MAX_VALUE, RANGEERROR_POSITIVE); + +// Test outside int64_t range +testInt64(-Math.pow(2, 63) + (Math.pow(2, 9)), RANGEERROR_NEGATIVE); +testInt64(Math.pow(2, 63) - (Math.pow(2, 9)), RANGEERROR_POSITIVE); + +// Test non-finite numbers +testInt64(Number.POSITIVE_INFINITY, 0); +testInt64(Number.NEGATIVE_INFINITY, 0); +testInt64(Number.NaN, 0); diff --git a/Tests/NodeApi/test/js-native-api/test_number/test_null.c b/Tests/NodeApi/test/js-native-api/test_number/test_null.c new file mode 100644 index 00000000..20d479c9 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/test_null.c @@ -0,0 +1,77 @@ +#include + +#include "../common.h" + +// Unifies the way the macros declare values. +typedef double double_t; + +#define BINDING_FOR_CREATE(initial_capital, lowercase) \ + static napi_value Create##initial_capital(napi_env env, \ + napi_callback_info info) { \ + napi_value return_value, call_result; \ + lowercase##_t value = 42; \ + NODE_API_CALL(env, napi_create_object(env, &return_value)); \ + add_returned_status(env, \ + "envIsNull", \ + return_value, \ + "Invalid argument", \ + napi_invalid_arg, \ + napi_create_##lowercase(NULL, value, &call_result)); \ + napi_create_##lowercase(env, value, NULL); \ + add_last_status(env, "resultIsNull", return_value); \ + return return_value; \ + } + +#define BINDING_FOR_GET_VALUE(initial_capital, lowercase) \ + static napi_value GetValue##initial_capital(napi_env env, \ + napi_callback_info info) { \ + napi_value return_value, call_result; \ + lowercase##_t value = 42; \ + NODE_API_CALL(env, napi_create_object(env, &return_value)); \ + NODE_API_CALL(env, napi_create_##lowercase(env, value, &call_result)); \ + add_returned_status( \ + env, \ + "envIsNull", \ + return_value, \ + "Invalid argument", \ + napi_invalid_arg, \ + napi_get_value_##lowercase(NULL, call_result, &value)); \ + napi_get_value_##lowercase(env, NULL, &value); \ + add_last_status(env, "valueIsNull", return_value); \ + napi_get_value_##lowercase(env, call_result, NULL); \ + add_last_status(env, "resultIsNull", return_value); \ + return return_value; \ + } + +BINDING_FOR_CREATE(Double, double) +BINDING_FOR_CREATE(Int32, int32) +BINDING_FOR_CREATE(Uint32, uint32) +BINDING_FOR_CREATE(Int64, int64) +BINDING_FOR_GET_VALUE(Double, double) +BINDING_FOR_GET_VALUE(Int32, int32) +BINDING_FOR_GET_VALUE(Uint32, uint32) +BINDING_FOR_GET_VALUE(Int64, int64) + +void init_test_null(napi_env env, napi_value exports) { + const napi_property_descriptor test_null_props[] = { + DECLARE_NODE_API_PROPERTY("createDouble", CreateDouble), + DECLARE_NODE_API_PROPERTY("createInt32", CreateInt32), + DECLARE_NODE_API_PROPERTY("createUint32", CreateUint32), + DECLARE_NODE_API_PROPERTY("createInt64", CreateInt64), + DECLARE_NODE_API_PROPERTY("getValueDouble", GetValueDouble), + DECLARE_NODE_API_PROPERTY("getValueInt32", GetValueInt32), + DECLARE_NODE_API_PROPERTY("getValueUint32", GetValueUint32), + DECLARE_NODE_API_PROPERTY("getValueInt64", GetValueInt64), + }; + napi_value test_null; + + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null)); + NODE_API_CALL_RETURN_VOID( + env, + napi_define_properties(env, + test_null, + sizeof(test_null_props) / sizeof(*test_null_props), + test_null_props)); + NODE_API_CALL_RETURN_VOID( + env, napi_set_named_property(env, exports, "testNull", test_null)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_number/test_null.h b/Tests/NodeApi/test/js-native-api/test_number/test_null.h new file mode 100644 index 00000000..695d8971 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/test_null.h @@ -0,0 +1,8 @@ +#ifndef TEST_JS_NATIVE_API_TEST_NUMBER_TEST_NULL_H_ +#define TEST_JS_NATIVE_API_TEST_NUMBER_TEST_NULL_H_ + +#include + +void init_test_null(napi_env env, napi_value exports); + +#endif // TEST_JS_NATIVE_API_TEST_NUMBER_TEST_NULL_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_number/test_null.js b/Tests/NodeApi/test/js-native-api/test_number/test_null.js new file mode 100644 index 00000000..c09801ac --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/test_null.js @@ -0,0 +1,18 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const { testNull } = require(`./build/${common.buildType}/test_number`); + +const expectedCreateResult = { + envIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', +}; +const expectedGetValueResult = { + envIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', +}; +[ 'Double', 'Int32', 'Uint32', 'Int64' ].forEach((typeName) => { + assert.deepStrictEqual(testNull['create' + typeName](), expectedCreateResult); + assert.deepStrictEqual(testNull['getValue' + typeName](), expectedGetValueResult); +}); diff --git a/Tests/NodeApi/test/js-native-api/test_number/test_number.c b/Tests/NodeApi/test/js-native-api/test_number/test_number.c new file mode 100644 index 00000000..3b3ba29f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_number/test_number.c @@ -0,0 +1,110 @@ +#include +#include "../common.h" +#include "../entry_point.h" +#include "test_null.h" + +static napi_value Test(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects a number as first argument."); + + double input; + NODE_API_CALL(env, napi_get_value_double(env, args[0], &input)); + + napi_value output; + NODE_API_CALL(env, napi_create_double(env, input, &output)); + + return output; +} + +static napi_value TestUint32Truncation(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects a number as first argument."); + + uint32_t input; + NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &input)); + + napi_value output; + NODE_API_CALL(env, napi_create_uint32(env, input, &output)); + + return output; +} + +static napi_value TestInt32Truncation(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects a number as first argument."); + + int32_t input; + NODE_API_CALL(env, napi_get_value_int32(env, args[0], &input)); + + napi_value output; + NODE_API_CALL(env, napi_create_int32(env, input, &output)); + + return output; +} + +static napi_value TestInt64Truncation(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_number, + "Wrong type of arguments. Expects a number as first argument."); + + int64_t input; + NODE_API_CALL(env, napi_get_value_int64(env, args[0], &input)); + + napi_value output; + NODE_API_CALL(env, napi_create_int64(env, input, &output)); + + return output; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("Test", Test), + DECLARE_NODE_API_PROPERTY("TestInt32Truncation", TestInt32Truncation), + DECLARE_NODE_API_PROPERTY("TestUint32Truncation", TestUint32Truncation), + DECLARE_NODE_API_PROPERTY("TestInt64Truncation", TestInt64Truncation), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + init_test_null(env, exports); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_object/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_object/CMakeLists.txt new file mode 100644 index 00000000..e8f81166 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/CMakeLists.txt @@ -0,0 +1,10 @@ +add_node_api_module(test_object + SOURCES + test_null.c + test_object.c +) + +add_node_api_module(test_exceptions + SOURCES + test_exceptions.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_object/binding.gyp b/Tests/NodeApi/test/js-native-api/test_object/binding.gyp new file mode 100644 index 00000000..37ea4931 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/binding.gyp @@ -0,0 +1,17 @@ +{ + "targets": [ + { + "target_name": "test_object", + "sources": [ + "test_null.c", + "test_object.c" + ] + }, + { + "target_name": "test_exceptions", + "sources": [ + "test_exceptions.c", + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_object/test.js b/Tests/NodeApi/test/js-native-api/test_object/test.js new file mode 100644 index 00000000..8ca961a1 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test.js @@ -0,0 +1,393 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for objects +const test_object = require(`./build/${common.buildType}/test_object`); + + +const object = { + hello: 'world', + array: [ + 1, 94, 'str', 12.321, { test: 'obj in arr' }, + ], + newObject: { + test: 'obj in obj', + }, +}; + +assert.strictEqual(test_object.Get(object, 'hello'), 'world'); +assert.strictEqual(test_object.GetNamed(object, 'hello'), 'world'); +assert.deepStrictEqual(test_object.Get(object, 'array'), + [1, 94, 'str', 12.321, { test: 'obj in arr' }]); +assert.deepStrictEqual(test_object.Get(object, 'newObject'), + { test: 'obj in obj' }); + +assert(test_object.Has(object, 'hello')); +assert(test_object.HasNamed(object, 'hello')); +assert(test_object.Has(object, 'array')); +assert(test_object.Has(object, 'newObject')); + +const newObject = test_object.New(); +assert(test_object.Has(newObject, 'test_number')); +assert.strictEqual(newObject.test_number, 987654321); +assert.strictEqual(newObject.test_string, 'test string'); + +{ + // Verify that napi_get_property() walks the prototype chain. + function MyObject() { + this.foo = 42; + this.bar = 43; + } + + MyObject.prototype.bar = 44; + MyObject.prototype.baz = 45; + + const obj = new MyObject(); + + assert.strictEqual(test_object.Get(obj, 'foo'), 42); + assert.strictEqual(test_object.Get(obj, 'bar'), 43); + assert.strictEqual(test_object.Get(obj, 'baz'), 45); + assert.strictEqual(test_object.Get(obj, 'toString'), + Object.prototype.toString); +} + +{ + // Verify that napi_has_own_property() fails if property is not a name. + [true, false, null, undefined, {}, [], 0, 1, () => { }].forEach((value) => { + assert.throws(() => { + test_object.HasOwn({}, value); + }, /^Error: A string or symbol was expected$/); + }); +} + +{ + // Verify that napi_has_own_property() does not walk the prototype chain. + const symbol1 = Symbol(); + const symbol2 = Symbol(); + + function MyObject() { + this.foo = 42; + this.bar = 43; + this[symbol1] = 44; + } + + MyObject.prototype.bar = 45; + MyObject.prototype.baz = 46; + MyObject.prototype[symbol2] = 47; + + const obj = new MyObject(); + + assert.strictEqual(test_object.HasOwn(obj, 'foo'), true); + assert.strictEqual(test_object.HasOwn(obj, 'bar'), true); + assert.strictEqual(test_object.HasOwn(obj, symbol1), true); + assert.strictEqual(test_object.HasOwn(obj, 'baz'), false); + assert.strictEqual(test_object.HasOwn(obj, 'toString'), false); + assert.strictEqual(test_object.HasOwn(obj, symbol2), false); +} + +{ + // test_object.Inflate increases all properties by 1 + const cube = { + x: 10, + y: 10, + z: 10, + }; + + assert.deepStrictEqual(test_object.Inflate(cube), { x: 11, y: 11, z: 11 }); + assert.deepStrictEqual(test_object.Inflate(cube), { x: 12, y: 12, z: 12 }); + assert.deepStrictEqual(test_object.Inflate(cube), { x: 13, y: 13, z: 13 }); + cube.t = 13; + assert.deepStrictEqual( + test_object.Inflate(cube), { x: 14, y: 14, z: 14, t: 14 }); + + const sym1 = Symbol('1'); + const sym2 = Symbol('2'); + const sym3 = Symbol('3'); + const sym4 = Symbol('4'); + const object2 = { + [sym1]: '@@iterator', + [sym2]: sym3, + }; + + assert(test_object.Has(object2, sym1)); + assert(test_object.Has(object2, sym2)); + assert.strictEqual(test_object.Get(object2, sym1), '@@iterator'); + assert.strictEqual(test_object.Get(object2, sym2), sym3); + assert(test_object.Set(object2, 'string', 'value')); + assert(test_object.SetNamed(object2, 'named_string', 'value')); + assert(test_object.Set(object2, sym4, 123)); + assert(test_object.Has(object2, 'string')); + assert(test_object.HasNamed(object2, 'named_string')); + assert(test_object.Has(object2, sym4)); + assert.strictEqual(test_object.Get(object2, 'string'), 'value'); + assert.strictEqual(test_object.Get(object2, sym4), 123); +} + +{ + // Wrap a pointer in a JS object, then verify the pointer can be unwrapped. + const wrapper = {}; + test_object.Wrap(wrapper); + + assert(test_object.Unwrap(wrapper)); +} + +{ + // Verify that wrapping doesn't break an object's prototype chain. + const wrapper = {}; + const protoA = { protoA: true }; + Object.setPrototypeOf(wrapper, protoA); + test_object.Wrap(wrapper); + + assert(test_object.Unwrap(wrapper)); + assert(wrapper.protoA); +} + +{ + // Verify the pointer can be unwrapped after inserting in the prototype chain. + const wrapper = {}; + const protoA = { protoA: true }; + Object.setPrototypeOf(wrapper, protoA); + test_object.Wrap(wrapper); + + const protoB = { protoB: true }; + Object.setPrototypeOf(protoB, Object.getPrototypeOf(wrapper)); + Object.setPrototypeOf(wrapper, protoB); + + assert(test_object.Unwrap(wrapper)); + assert(wrapper.protoA, true); + assert(wrapper.protoB, true); +} + +{ + // Verify that objects can be type-tagged and type-tag-checked. + const obj1 = test_object.TypeTaggedInstance(0); + const obj2 = test_object.TypeTaggedInstance(1); + const obj3 = test_object.TypeTaggedInstance(2); + const obj4 = test_object.TypeTaggedInstance(3); + const external = test_object.TypeTaggedExternal(2); + const plainExternal = test_object.PlainExternal(); + + // Verify that we do not allow type tag indices greater than the largest + // available index. + assert.throws(() => test_object.TypeTaggedInstance(39), { + name: 'RangeError', + message: 'Invalid type index', + }); + assert.throws(() => test_object.TypeTaggedExternal(39), { + name: 'RangeError', + message: 'Invalid type index', + }); + + // Verify that type tags are correctly accepted. + assert.strictEqual(test_object.CheckTypeTag(0, obj1), true); + assert.strictEqual(test_object.CheckTypeTag(1, obj2), true); + assert.strictEqual(test_object.CheckTypeTag(2, obj3), true); + assert.strictEqual(test_object.CheckTypeTag(3, obj4), true); + assert.strictEqual(test_object.CheckTypeTag(2, external), true); + + // Verify that wrongly tagged objects are rejected. + assert.strictEqual(test_object.CheckTypeTag(0, obj2), false); + assert.strictEqual(test_object.CheckTypeTag(1, obj1), false); + assert.strictEqual(test_object.CheckTypeTag(0, obj3), false); + assert.strictEqual(test_object.CheckTypeTag(1, obj4), false); + assert.strictEqual(test_object.CheckTypeTag(2, obj4), false); + assert.strictEqual(test_object.CheckTypeTag(3, obj3), false); + assert.strictEqual(test_object.CheckTypeTag(4, obj3), false); + assert.strictEqual(test_object.CheckTypeTag(0, external), false); + assert.strictEqual(test_object.CheckTypeTag(1, external), false); + assert.strictEqual(test_object.CheckTypeTag(3, external), false); + assert.strictEqual(test_object.CheckTypeTag(4, external), false); + + // Verify that untagged objects are rejected. + assert.strictEqual(test_object.CheckTypeTag(0, {}), false); + assert.strictEqual(test_object.CheckTypeTag(1, {}), false); + assert.strictEqual(test_object.CheckTypeTag(0, plainExternal), false); + assert.strictEqual(test_object.CheckTypeTag(1, plainExternal), false); + assert.strictEqual(test_object.CheckTypeTag(2, plainExternal), false); + assert.strictEqual(test_object.CheckTypeTag(3, plainExternal), false); + assert.strictEqual(test_object.CheckTypeTag(4, plainExternal), false); +} + +{ + // Verify that normal and nonexistent properties can be deleted. + const sym = Symbol(); + const obj = { foo: 'bar', [sym]: 'baz' }; + + assert.strictEqual('foo' in obj, true); + assert.strictEqual(sym in obj, true); + assert.strictEqual('does_not_exist' in obj, false); + assert.strictEqual(test_object.Delete(obj, 'foo'), true); + assert.strictEqual('foo' in obj, false); + assert.strictEqual(sym in obj, true); + assert.strictEqual('does_not_exist' in obj, false); + assert.strictEqual(test_object.Delete(obj, sym), true); + assert.strictEqual('foo' in obj, false); + assert.strictEqual(sym in obj, false); + assert.strictEqual('does_not_exist' in obj, false); +} + +{ + // Verify that non-configurable properties are not deleted. + const obj = {}; + + Object.defineProperty(obj, 'foo', { configurable: false }); + assert.strictEqual(test_object.Delete(obj, 'foo'), false); + assert.strictEqual('foo' in obj, true); +} + +{ + // Verify that prototype properties are not deleted. + function Foo() { + this.foo = 'bar'; + } + + Foo.prototype.foo = 'baz'; + + const obj = new Foo(); + + assert.strictEqual(obj.foo, 'bar'); + assert.strictEqual(test_object.Delete(obj, 'foo'), true); + assert.strictEqual(obj.foo, 'baz'); + assert.strictEqual(test_object.Delete(obj, 'foo'), true); + assert.strictEqual(obj.foo, 'baz'); +} + +{ + // Verify that napi_get_property_names gets the right set of property names, + // i.e.: includes prototypes, only enumerable properties, skips symbols, + // and includes indices and converts them to strings. + + const object = { __proto__: { + inherited: 1, + } }; + + const fooSymbol = Symbol('foo'); + + object.normal = 2; + object[fooSymbol] = 3; + Object.defineProperty(object, 'unenumerable', { + value: 4, + enumerable: false, + writable: true, + configurable: true, + }); + Object.defineProperty(object, 'writable', { + value: 4, + enumerable: true, + writable: true, + configurable: false, + }); + Object.defineProperty(object, 'configurable', { + value: 4, + enumerable: true, + writable: false, + configurable: true, + }); + object[5] = 5; + + assert.deepStrictEqual(test_object.GetPropertyNames(object), + ['5', + 'normal', + 'writable', + 'configurable', + 'inherited']); + + assert.deepStrictEqual(test_object.GetSymbolNames(object), + [fooSymbol]); + + assert.deepStrictEqual(test_object.GetEnumerableWritableNames(object), + ['5', + 'normal', + 'writable', + fooSymbol, + 'inherited']); + + assert.deepStrictEqual(test_object.GetOwnWritableNames(object), + ['5', + 'normal', + 'unenumerable', + 'writable', + fooSymbol]); + + assert.deepStrictEqual(test_object.GetEnumerableConfigurableNames(object), + ['5', + 'normal', + 'configurable', + fooSymbol, + 'inherited']); + + assert.deepStrictEqual(test_object.GetOwnConfigurableNames(object), + ['5', + 'normal', + 'unenumerable', + 'configurable', + fooSymbol]); +} + +// Verify that passing NULL to napi_set_property() results in the correct +// error. +assert.deepStrictEqual(test_object.TestSetProperty(), { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + keyIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', +}); + +// Verify that passing NULL to napi_has_property() results in the correct +// error. +assert.deepStrictEqual(test_object.TestHasProperty(), { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + keyIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', +}); + +// Verify that passing NULL to napi_get_property() results in the correct +// error. +assert.deepStrictEqual(test_object.TestGetProperty(), { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + keyIsNull: 'Invalid argument', + resultIsNull: 'Invalid argument', +}); + +{ + const obj = { x: 'a', y: 'b', z: 'c' }; + + test_object.TestSeal(obj); + + assert.strictEqual(Object.isSealed(obj), true); + + assert.throws(() => { + obj.w = 'd'; + }, /(Cannot add property w, object is not extensible)|(TypeError: Cannot add new property 'w')/); + + assert.throws(() => { + delete obj.x; + }, /(Cannot delete property 'x' of #)|(TypeError: Property is not configurable)/); + + // Sealed objects allow updating existing properties, + // so this should not throw. + obj.x = 'd'; +} + +{ + const obj = { x: 10, y: 10, z: 10 }; + + test_object.TestFreeze(obj); + + assert.strictEqual(Object.isFrozen(obj), true); + + assert.throws(() => { + obj.x = 10; + }, /(Cannot assign to read only property 'x' of object '#)|(TypeError: Cannot assign to read-only property 'x')/); + + assert.throws(() => { + obj.w = 15; + }, /(Cannot add property w, object is not extensible)|(TypeError: Cannot add new property 'w')/); + + assert.throws(() => { + delete obj.x; + }, /(Cannot delete property 'x' of #)|(TypeError: Property is not configurable)/); +} diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.c b/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.c new file mode 100644 index 00000000..7474d49e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.c @@ -0,0 +1,82 @@ +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value TestExceptions(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value target = args[0]; + napi_value exception, key, value; + napi_status status; + bool is_exception_pending; + bool bool_result; + + NODE_API_CALL(env, + napi_create_string_utf8(env, "key", NAPI_AUTO_LENGTH, &key)); + NODE_API_CALL( + env, napi_create_string_utf8(env, "value", NAPI_AUTO_LENGTH, &value)); + +#define PROCEDURE(call) \ + { \ + status = (call); \ + NODE_API_ASSERT( \ + env, status == napi_pending_exception, "expect exception pending"); \ + NODE_API_CALL(env, napi_is_exception_pending(env, &is_exception_pending)); \ + NODE_API_ASSERT(env, is_exception_pending, "expect exception pending"); \ + NODE_API_CALL(env, napi_get_and_clear_last_exception(env, &exception)); \ + } + // discard the exception values. + + // properties + PROCEDURE(napi_set_property(env, target, key, value)); + PROCEDURE(napi_set_named_property(env, target, "key", value)); + PROCEDURE(napi_has_property(env, target, key, &bool_result)); + PROCEDURE(napi_has_own_property(env, target, key, &bool_result)); + PROCEDURE(napi_has_named_property(env, target, "key", &bool_result)); + PROCEDURE(napi_get_property(env, target, key, &value)); + PROCEDURE(napi_get_named_property(env, target, "key", &value)); + PROCEDURE(napi_delete_property(env, target, key, &bool_result)); + + // elements + PROCEDURE(napi_set_element(env, target, 0, value)); + PROCEDURE(napi_has_element(env, target, 0, &bool_result)); + PROCEDURE(napi_get_element(env, target, 0, &value)); + PROCEDURE(napi_delete_element(env, target, 0, &bool_result)); + + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY_VALUE("key", value), + }; + PROCEDURE(napi_define_properties( + env, target, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + PROCEDURE(napi_get_all_property_names(env, + target, + napi_key_own_only, + napi_key_enumerable, + napi_key_keep_numbers, + &value)); + PROCEDURE(napi_get_property_names(env, target, &value)); + + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("testExceptions", TestExceptions), + }; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.js b/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.js new file mode 100644 index 00000000..2d5f10ab --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_exceptions.js @@ -0,0 +1,18 @@ +'use strict'; +const common = require('../../common'); + +// Test +const { testExceptions } = require(`./build/${common.buildType}/test_exceptions`); + +function throws() { + throw new Error('foobar'); +} +testExceptions(new Proxy({}, { + get: common.mustCallAtLeast(throws, 1), + getOwnPropertyDescriptor: common.mustCallAtLeast(throws, 1), + defineProperty: common.mustCallAtLeast(throws, 1), + deleteProperty: common.mustCallAtLeast(throws, 1), + has: common.mustCallAtLeast(throws, 1), + set: common.mustCallAtLeast(throws, 1), + ownKeys: common.mustCallAtLeast(throws, 1), +})); diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_null.c b/Tests/NodeApi/test/js-native-api/test_object/test_null.c new file mode 100644 index 00000000..4fd4e95e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_null.c @@ -0,0 +1,400 @@ +#include + +#include "../common.h" +#include "test_null.h" + +static napi_value SetProperty(napi_env env, napi_callback_info info) { + napi_value return_value, object, key; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + NODE_API_CALL(env, + napi_create_string_utf8(env, "someString", NAPI_AUTO_LENGTH, &key)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_set_property(NULL, object, key, object)); + + napi_set_property(env, NULL, key, object); + add_last_status(env, "objectIsNull", return_value); + + napi_set_property(env, object, NULL, object); + add_last_status(env, "keyIsNull", return_value); + + napi_set_property(env, object, key, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value GetProperty(napi_env env, napi_callback_info info) { + napi_value return_value, object, key, prop; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + NODE_API_CALL(env, + napi_create_string_utf8(env, "someString", NAPI_AUTO_LENGTH, &key)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_property(NULL, object, key, &prop)); + + napi_get_property(env, NULL, key, &prop); + add_last_status(env, "objectIsNull", return_value); + + napi_get_property(env, object, NULL, &prop); + add_last_status(env, "keyIsNull", return_value); + + napi_get_property(env, object, key, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value TestBoolValuedPropApi(napi_env env, + napi_status (*api)(napi_env, napi_value, napi_value, bool*)) { + napi_value return_value, object, key; + bool result; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + NODE_API_CALL(env, + napi_create_string_utf8(env, "someString", NAPI_AUTO_LENGTH, &key)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + api(NULL, object, key, &result)); + + api(env, NULL, key, &result); + add_last_status(env, "objectIsNull", return_value); + + api(env, object, NULL, &result); + add_last_status(env, "keyIsNull", return_value); + + api(env, object, key, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value HasProperty(napi_env env, napi_callback_info info) { + return TestBoolValuedPropApi(env, napi_has_property); +} + +static napi_value HasOwnProperty(napi_env env, napi_callback_info info) { + return TestBoolValuedPropApi(env, napi_has_own_property); +} + +static napi_value DeleteProperty(napi_env env, napi_callback_info info) { + return TestBoolValuedPropApi(env, napi_delete_property); +} + +static napi_value SetNamedProperty(napi_env env, napi_callback_info info) { + napi_value return_value, object; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_set_named_property(NULL, object, "key", object)); + + napi_set_named_property(env, NULL, "key", object); + add_last_status(env, "objectIsNull", return_value); + + napi_set_named_property(env, object, NULL, object); + add_last_status(env, "keyIsNull", return_value); + + napi_set_named_property(env, object, "key", NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value GetNamedProperty(napi_env env, napi_callback_info info) { + napi_value return_value, object, prop; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_named_property(NULL, object, "key", &prop)); + + napi_get_named_property(env, NULL, "key", &prop); + add_last_status(env, "objectIsNull", return_value); + + napi_get_named_property(env, object, NULL, &prop); + add_last_status(env, "keyIsNull", return_value); + + napi_get_named_property(env, object, "key", NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value HasNamedProperty(napi_env env, napi_callback_info info) { + napi_value return_value, object; + bool result; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_has_named_property(NULL, object, "key", &result)); + + napi_has_named_property(env, NULL, "key", &result); + add_last_status(env, "objectIsNull", return_value); + + napi_has_named_property(env, object, NULL, &result); + add_last_status(env, "keyIsNull", return_value); + + napi_has_named_property(env, object, "key", NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value SetElement(napi_env env, napi_callback_info info) { + napi_value return_value, object; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_set_element(NULL, object, 0, object)); + + napi_set_element(env, NULL, 0, object); + add_last_status(env, "objectIsNull", return_value); + + napi_set_property(env, object, 0, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value GetElement(napi_env env, napi_callback_info info) { + napi_value return_value, object, prop; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_element(NULL, object, 0, &prop)); + + napi_get_property(env, NULL, 0, &prop); + add_last_status(env, "objectIsNull", return_value); + + napi_get_property(env, object, 0, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value TestBoolValuedElementApi(napi_env env, + napi_status (*api)(napi_env, napi_value, uint32_t, bool*)) { + napi_value return_value, object; + bool result; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + NODE_API_CALL(env, napi_create_object(env, &object)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + api(NULL, object, 0, &result)); + + api(env, NULL, 0, &result); + add_last_status(env, "objectIsNull", return_value); + + api(env, object, 0, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value HasElement(napi_env env, napi_callback_info info) { + return TestBoolValuedElementApi(env, napi_has_element); +} + +static napi_value DeleteElement(napi_env env, napi_callback_info info) { + return TestBoolValuedElementApi(env, napi_delete_element); +} + +static napi_value DefineProperties(napi_env env, napi_callback_info info) { + napi_value object, return_value; + + napi_property_descriptor desc = { + "prop", NULL, DefineProperties, NULL, NULL, NULL, napi_enumerable, NULL + }; + + NODE_API_CALL(env, napi_create_object(env, &object)); + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_define_properties(NULL, object, 1, &desc)); + + napi_define_properties(env, NULL, 1, &desc); + add_last_status(env, "objectIsNull", return_value); + + napi_define_properties(env, object, 1, NULL); + add_last_status(env, "descriptorListIsNull", return_value); + + desc.utf8name = NULL; + napi_define_properties(env, object, 1, NULL); + add_last_status(env, "utf8nameIsNull", return_value); + desc.utf8name = "prop"; + + desc.method = NULL; + napi_define_properties(env, object, 1, NULL); + add_last_status(env, "methodIsNull", return_value); + desc.method = DefineProperties; + + return return_value; +} + +static napi_value GetPropertyNames(napi_env env, napi_callback_info info) { + napi_value return_value, props; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_property_names(NULL, return_value, &props)); + + napi_get_property_names(env, NULL, &props); + add_last_status(env, "objectIsNull", return_value); + + napi_get_property_names(env, return_value, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value GetAllPropertyNames(napi_env env, napi_callback_info info) { + napi_value return_value, props; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_all_property_names(NULL, + return_value, + napi_key_own_only, + napi_key_writable, + napi_key_keep_numbers, + &props)); + + napi_get_all_property_names(env, + NULL, + napi_key_own_only, + napi_key_writable, + napi_key_keep_numbers, + &props); + add_last_status(env, "objectIsNull", return_value); + + napi_get_all_property_names(env, + return_value, + napi_key_own_only, + napi_key_writable, + napi_key_keep_numbers, + NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +static napi_value GetPrototype(napi_env env, napi_callback_info info) { + napi_value return_value, proto; + + NODE_API_CALL(env, napi_create_object(env, &return_value)); + + add_returned_status(env, + "envIsNull", + return_value, + "Invalid argument", + napi_invalid_arg, + napi_get_prototype(NULL, return_value, &proto)); + + napi_get_prototype(env, NULL, &proto); + add_last_status(env, "objectIsNull", return_value); + + napi_get_prototype(env, return_value, NULL); + add_last_status(env, "valueIsNull", return_value); + + return return_value; +} + +void init_test_null(napi_env env, napi_value exports) { + napi_value test_null; + + const napi_property_descriptor test_null_props[] = { + DECLARE_NODE_API_PROPERTY("setProperty", SetProperty), + DECLARE_NODE_API_PROPERTY("getProperty", GetProperty), + DECLARE_NODE_API_PROPERTY("hasProperty", HasProperty), + DECLARE_NODE_API_PROPERTY("hasOwnProperty", HasOwnProperty), + DECLARE_NODE_API_PROPERTY("deleteProperty", DeleteProperty), + DECLARE_NODE_API_PROPERTY("setNamedProperty", SetNamedProperty), + DECLARE_NODE_API_PROPERTY("getNamedProperty", GetNamedProperty), + DECLARE_NODE_API_PROPERTY("hasNamedProperty", HasNamedProperty), + DECLARE_NODE_API_PROPERTY("setElement", SetElement), + DECLARE_NODE_API_PROPERTY("getElement", GetElement), + DECLARE_NODE_API_PROPERTY("hasElement", HasElement), + DECLARE_NODE_API_PROPERTY("deleteElement", DeleteElement), + DECLARE_NODE_API_PROPERTY("defineProperties", DefineProperties), + DECLARE_NODE_API_PROPERTY("getPropertyNames", GetPropertyNames), + DECLARE_NODE_API_PROPERTY("getAllPropertyNames", GetAllPropertyNames), + DECLARE_NODE_API_PROPERTY("getPrototype", GetPrototype), + }; + + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null)); + NODE_API_CALL_RETURN_VOID(env, napi_define_properties( + env, test_null, sizeof(test_null_props) / sizeof(*test_null_props), + test_null_props)); + + const napi_property_descriptor test_null_set = { + "testNull", NULL, NULL, NULL, NULL, test_null, napi_enumerable, NULL + }; + + NODE_API_CALL_RETURN_VOID(env, + napi_define_properties(env, exports, 1, &test_null_set)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_null.h b/Tests/NodeApi/test/js-native-api/test_object/test_null.h new file mode 100644 index 00000000..b142570d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_null.h @@ -0,0 +1,8 @@ +#ifndef TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ +#define TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ + +#include + +void init_test_null(napi_env env, napi_value exports); + +#endif // TEST_JS_NATIVE_API_TEST_OBJECT_TEST_NULL_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_null.js b/Tests/NodeApi/test/js-native-api/test_object/test_null.js new file mode 100644 index 00000000..dcf688c5 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_null.js @@ -0,0 +1,53 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Test passing NULL to object-related N-APIs. +const { testNull } = require(`./build/${common.buildType}/test_object`); + +const expectedForProperty = { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + keyIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', +}; +assert.deepStrictEqual(testNull.setProperty(), expectedForProperty); +assert.deepStrictEqual(testNull.getProperty(), expectedForProperty); +assert.deepStrictEqual(testNull.hasProperty(), expectedForProperty); +// eslint-disable-next-line no-prototype-builtins +assert.deepStrictEqual(testNull.hasOwnProperty(), expectedForProperty); +// It's OK not to want the result of a deletion. +assert.deepStrictEqual(testNull.deleteProperty(), + Object.assign({}, + expectedForProperty, + { valueIsNull: 'napi_ok' })); +assert.deepStrictEqual(testNull.setNamedProperty(), expectedForProperty); +assert.deepStrictEqual(testNull.getNamedProperty(), expectedForProperty); +assert.deepStrictEqual(testNull.hasNamedProperty(), expectedForProperty); + +const expectedForElement = { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + valueIsNull: 'Invalid argument', +}; +assert.deepStrictEqual(testNull.setElement(), expectedForElement); +assert.deepStrictEqual(testNull.getElement(), expectedForElement); +assert.deepStrictEqual(testNull.hasElement(), expectedForElement); +// It's OK not to want the result of a deletion. +assert.deepStrictEqual(testNull.deleteElement(), + Object.assign({}, + expectedForElement, + { valueIsNull: 'napi_ok' })); + +assert.deepStrictEqual(testNull.defineProperties(), { + envIsNull: 'Invalid argument', + objectIsNull: 'Invalid argument', + descriptorListIsNull: 'Invalid argument', + utf8nameIsNull: 'Invalid argument', + methodIsNull: 'Invalid argument', +}); + +// `expectedForElement` also works for the APIs below. +assert.deepStrictEqual(testNull.getPropertyNames(), expectedForElement); +assert.deepStrictEqual(testNull.getAllPropertyNames(), expectedForElement); +assert.deepStrictEqual(testNull.getPrototype(), expectedForElement); diff --git a/Tests/NodeApi/test/js-native-api/test_object/test_object.c b/Tests/NodeApi/test/js-native-api/test_object/test_object.c new file mode 100644 index 00000000..4d53e09f --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_object/test_object.c @@ -0,0 +1,755 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" +#include "test_null.h" + +static int test_value = 3; + +static napi_value Get(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, + "Wrong type of arguments. Expects a string or symbol as second."); + + napi_value object = args[0]; + napi_value output; + NODE_API_CALL(env, napi_get_property(env, object, args[1], &output)); + + return output; +} + +static napi_value GetNamed(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + char key[256] = ""; + size_t key_length; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT(env, value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype value_type1; + NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1)); + + NODE_API_ASSERT(env, value_type1 == napi_string, + "Wrong type of arguments. Expects a string as second."); + + napi_value object = args[0]; + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[1], key, 255, &key_length)); + key[255] = 0; + NODE_API_ASSERT(env, key_length <= 255, + "Cannot accommodate keys longer than 255 bytes"); + napi_value output; + NODE_API_CALL(env, napi_get_named_property(env, object, key, &output)); + + return output; +} + +static napi_value GetPropertyNames(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT(env, value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL(env, napi_get_property_names(env, args[0], &output)); + + return output; +} + +static napi_value GetSymbolNames(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT(env, + value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL(env, + napi_get_all_property_names( + env, args[0], napi_key_include_prototypes, napi_key_skip_strings, + napi_key_numbers_to_strings, &output)); + + return output; +} + +static napi_value GetEnumerableWritableNames(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT( + env, + value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL( + env, + napi_get_all_property_names(env, + args[0], + napi_key_include_prototypes, + napi_key_enumerable | napi_key_writable, + napi_key_numbers_to_strings, + &output)); + + return output; +} + +static napi_value GetOwnWritableNames(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT( + env, + value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL(env, + napi_get_all_property_names(env, + args[0], + napi_key_own_only, + napi_key_writable, + napi_key_numbers_to_strings, + &output)); + + return output; +} + +static napi_value GetEnumerableConfigurableNames(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT( + env, + value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL( + env, + napi_get_all_property_names(env, + args[0], + napi_key_include_prototypes, + napi_key_enumerable | napi_key_configurable, + napi_key_numbers_to_strings, + &output)); + + return output; +} + +static napi_value GetOwnConfigurableNames(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT( + env, + value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value output; + NODE_API_CALL(env, + napi_get_all_property_names(env, + args[0], + napi_key_own_only, + napi_key_configurable, + napi_key_numbers_to_strings, + &output)); + + return output; +} + +static napi_value Set(napi_env env, napi_callback_info info) { + size_t argc = 3; + napi_value args[3]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 3, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, + "Wrong type of arguments. Expects a string or symbol as second."); + + NODE_API_CALL(env, napi_set_property(env, args[0], args[1], args[2])); + + napi_value valuetrue; + NODE_API_CALL(env, napi_get_boolean(env, true, &valuetrue)); + + return valuetrue; +} + +static napi_value SetNamed(napi_env env, napi_callback_info info) { + size_t argc = 3; + napi_value args[3]; + char key[256] = ""; + size_t key_length; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 3, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT(env, value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype value_type1; + NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1)); + + NODE_API_ASSERT(env, value_type1 == napi_string, + "Wrong type of arguments. Expects a string as second."); + + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[1], key, 255, &key_length)); + key[255] = 0; + NODE_API_ASSERT(env, key_length <= 255, + "Cannot accommodate keys longer than 255 bytes"); + + NODE_API_CALL(env, napi_set_named_property(env, args[0], key, args[2])); + + napi_value value_true; + NODE_API_CALL(env, napi_get_boolean(env, true, &value_true)); + + return value_true; +} + +static napi_value Has(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, + "Wrong type of arguments. Expects a string or symbol as second."); + + bool has_property; + NODE_API_CALL(env, napi_has_property(env, args[0], args[1], &has_property)); + + napi_value ret; + NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret)); + + return ret; +} + +static napi_value HasNamed(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + char key[256] = ""; + size_t key_length; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 2, "Wrong number of arguments"); + + napi_valuetype value_type0; + NODE_API_CALL(env, napi_typeof(env, args[0], &value_type0)); + + NODE_API_ASSERT(env, value_type0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype value_type1; + NODE_API_CALL(env, napi_typeof(env, args[1], &value_type1)); + + NODE_API_ASSERT(env, value_type1 == napi_string || value_type1 == napi_symbol, + "Wrong type of arguments. Expects a string as second."); + + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[1], key, 255, &key_length)); + key[255] = 0; + NODE_API_ASSERT(env, key_length <= 255, + "Cannot accommodate keys longer than 255 bytes"); + + bool has_property; + NODE_API_CALL(env, napi_has_named_property(env, args[0], key, &has_property)); + + napi_value ret; + NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret)); + + return ret; +} + +static napi_value HasOwn(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + // napi_valuetype valuetype1; + // NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + // + // NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, + // "Wrong type of arguments. Expects a string or symbol as second."); + + bool has_property; + NODE_API_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property)); + + napi_value ret; + NODE_API_CALL(env, napi_get_boolean(env, has_property, &ret)); + + return ret; +} + +static napi_value Delete(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + NODE_API_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, + "Wrong type of arguments. Expects a string or symbol as second."); + + bool result; + napi_value ret; + NODE_API_CALL(env, napi_delete_property(env, args[0], args[1], &result)); + NODE_API_CALL(env, napi_get_boolean(env, result, &ret)); + + return ret; +} + +static napi_value New(napi_env env, napi_callback_info info) { + napi_value ret; + NODE_API_CALL(env, napi_create_object(env, &ret)); + + napi_value num; + NODE_API_CALL(env, napi_create_int32(env, 987654321, &num)); + + NODE_API_CALL(env, napi_set_named_property(env, ret, "test_number", num)); + + napi_value str; + const char* str_val = "test string"; + size_t str_len = strlen(str_val); + NODE_API_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str)); + + NODE_API_CALL(env, napi_set_named_property(env, ret, "test_string", str)); + + return ret; +} + +static napi_value Inflate(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects an object as first argument."); + + napi_value obj = args[0]; + napi_value propertynames; + NODE_API_CALL(env, napi_get_property_names(env, obj, &propertynames)); + + uint32_t i, length; + NODE_API_CALL(env, napi_get_array_length(env, propertynames, &length)); + + for (i = 0; i < length; i++) { + napi_value property_str; + NODE_API_CALL(env, napi_get_element(env, propertynames, i, &property_str)); + + napi_value value; + NODE_API_CALL(env, napi_get_property(env, obj, property_str, &value)); + + double double_val; + NODE_API_CALL(env, napi_get_value_double(env, value, &double_val)); + NODE_API_CALL(env, napi_create_double(env, double_val + 1, &value)); + NODE_API_CALL(env, napi_set_property(env, obj, property_str, value)); + } + + return obj; +} + +static napi_value Wrap(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value arg; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL)); + + NODE_API_CALL(env, napi_wrap(env, arg, &test_value, NULL, NULL, NULL)); + return NULL; +} + +static napi_value Unwrap(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value arg; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL)); + + void* data; + NODE_API_CALL(env, napi_unwrap(env, arg, &data)); + + bool is_expected = (data != NULL && *(int*)data == 3); + napi_value result; + NODE_API_CALL(env, napi_get_boolean(env, is_expected, &result)); + return result; +} + +static napi_value TestSetProperty(napi_env env, + napi_callback_info info) { + napi_status status; + napi_value object, key, value; + + NODE_API_CALL(env, napi_create_object(env, &object)); + + NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key)); + + NODE_API_CALL(env, napi_create_object(env, &value)); + + status = napi_set_property(NULL, object, key, value); + + add_returned_status(env, + "envIsNull", + object, + "Invalid argument", + napi_invalid_arg, + status); + + napi_set_property(env, NULL, key, value); + + add_last_status(env, "objectIsNull", object); + + napi_set_property(env, object, NULL, value); + + add_last_status(env, "keyIsNull", object); + + napi_set_property(env, object, key, NULL); + + add_last_status(env, "valueIsNull", object); + + return object; +} + +static napi_value TestHasProperty(napi_env env, + napi_callback_info info) { + napi_status status; + napi_value object, key; + bool result; + + NODE_API_CALL(env, napi_create_object(env, &object)); + + NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key)); + + status = napi_has_property(NULL, object, key, &result); + + add_returned_status(env, + "envIsNull", + object, + "Invalid argument", + napi_invalid_arg, + status); + + napi_has_property(env, NULL, key, &result); + + add_last_status(env, "objectIsNull", object); + + napi_has_property(env, object, NULL, &result); + + add_last_status(env, "keyIsNull", object); + + napi_has_property(env, object, key, NULL); + + add_last_status(env, "resultIsNull", object); + + return object; +} + +static napi_value TestGetProperty(napi_env env, + napi_callback_info info) { + napi_status status; + napi_value object, key, result; + + NODE_API_CALL(env, napi_create_object(env, &object)); + + NODE_API_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key)); + + NODE_API_CALL(env, napi_create_object(env, &result)); + + status = napi_get_property(NULL, object, key, &result); + + add_returned_status(env, + "envIsNull", + object, + "Invalid argument", + napi_invalid_arg, + status); + + napi_get_property(env, NULL, key, &result); + + add_last_status(env, "objectIsNull", object); + + napi_get_property(env, object, NULL, &result); + + add_last_status(env, "keyIsNull", object); + + napi_get_property(env, object, key, NULL); + + add_last_status(env, "resultIsNull", object); + + return object; +} + +static napi_value TestFreeze(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value object = args[0]; + NODE_API_CALL(env, napi_object_freeze(env, object)); + + return object; +} + +static napi_value TestSeal(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value object = args[0]; + NODE_API_CALL(env, napi_object_seal(env, object)); + + return object; +} + +// We create two type tags. They are basically 128-bit UUIDs. +#define TYPE_TAG_COUNT 5 +static const napi_type_tag type_tags[TYPE_TAG_COUNT] = { + {0xdaf987b3cc62481a, 0xb745b0497f299531}, + {0xbb7936c374084d9b, 0xa9548d0762eeedb9}, + {0xa5ed9ce2e4c00c38, 0}, + {0, 0}, + {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a}, +}; +#define VALIDATE_TYPE_INDEX(env, type_index) \ + do { \ + if ((type_index) >= TYPE_TAG_COUNT) { \ + NODE_API_CALL((env), \ + napi_throw_range_error((env), \ + "NODE_API_TEST_INVALID_TYPE_INDEX", \ + "Invalid type index")); \ + } \ + } while (0) + +static napi_value +TypeTaggedInstance(napi_env env, napi_callback_info info) { + size_t argc = 1; + uint32_t type_index; + napi_value instance, which_type; + napi_type_tag tag; + + // Below we copy the tag before setting it to prevent bugs where a pointer + // to the tag (instead of the 128-bit tag value) is stored. + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &which_type, NULL, NULL)); + NODE_API_CALL(env, napi_get_value_uint32(env, which_type, &type_index)); + VALIDATE_TYPE_INDEX(env, type_index); + NODE_API_CALL(env, napi_create_object(env, &instance)); + tag = type_tags[type_index]; + NODE_API_CALL(env, napi_type_tag_object(env, instance, &tag)); + + // Since the tag passed to napi_type_tag_object() was copied to the stack, + // a type tagging implementation that uses a pointer instead of the + // tag value would end up pointing to stack memory. + // When CheckTypeTag() is called later on, it might be the case that this + // stack address has been left untouched by accident (if no subsequent + // function call has clobbered it), which means the pointer would still + // point to valid data. + // To make sure that tags are stored by value and not by reference, + // clear this copy; any implementation using a pointer would end up with + // random stack data or { 0, 0 }, but not the original tag value, and fail. + memset(&tag, 0, sizeof(tag)); + + return instance; +} + +// V8 will not allow us to construct an external with a NULL data value. +#define IN_LIEU_OF_NULL ((void*)0x1) + +static napi_value PlainExternal(napi_env env, napi_callback_info info) { + napi_value instance; + + NODE_API_CALL( + env, napi_create_external(env, IN_LIEU_OF_NULL, NULL, NULL, &instance)); + + return instance; +} + +static napi_value TypeTaggedExternal(napi_env env, napi_callback_info info) { + size_t argc = 1; + uint32_t type_index; + napi_value instance, which_type; + napi_type_tag tag; + + // See TypeTaggedInstance() for an explanation about why we copy the tag + // to the stack and why we call memset on it after the external is tagged. + + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, &which_type, NULL, NULL)); + NODE_API_CALL(env, napi_get_value_uint32(env, which_type, &type_index)); + VALIDATE_TYPE_INDEX(env, type_index); + NODE_API_CALL( + env, napi_create_external(env, IN_LIEU_OF_NULL, NULL, NULL, &instance)); + tag = type_tags[type_index]; + NODE_API_CALL(env, napi_type_tag_object(env, instance, &tag)); + + memset(&tag, 0, sizeof(tag)); + + return instance; +} + +static napi_value +CheckTypeTag(napi_env env, napi_callback_info info) { + size_t argc = 2; + bool result; + napi_value argv[2], js_result; + uint32_t type_index; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_value_uint32(env, argv[0], &type_index)); + VALIDATE_TYPE_INDEX(env, type_index); + NODE_API_CALL(env, napi_check_object_type_tag(env, + argv[1], + &type_tags[type_index], + &result)); + NODE_API_CALL(env, napi_get_boolean(env, result, &js_result)); + + return js_result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("Get", Get), + DECLARE_NODE_API_PROPERTY("GetNamed", GetNamed), + DECLARE_NODE_API_PROPERTY("GetPropertyNames", GetPropertyNames), + DECLARE_NODE_API_PROPERTY("GetSymbolNames", GetSymbolNames), + DECLARE_NODE_API_PROPERTY("GetEnumerableWritableNames", + GetEnumerableWritableNames), + DECLARE_NODE_API_PROPERTY("GetOwnWritableNames", GetOwnWritableNames), + DECLARE_NODE_API_PROPERTY("GetEnumerableConfigurableNames", + GetEnumerableConfigurableNames), + DECLARE_NODE_API_PROPERTY("GetOwnConfigurableNames", + GetOwnConfigurableNames), + DECLARE_NODE_API_PROPERTY("Set", Set), + DECLARE_NODE_API_PROPERTY("SetNamed", SetNamed), + DECLARE_NODE_API_PROPERTY("Has", Has), + DECLARE_NODE_API_PROPERTY("HasNamed", HasNamed), + DECLARE_NODE_API_PROPERTY("HasOwn", HasOwn), + DECLARE_NODE_API_PROPERTY("Delete", Delete), + DECLARE_NODE_API_PROPERTY("New", New), + DECLARE_NODE_API_PROPERTY("Inflate", Inflate), + DECLARE_NODE_API_PROPERTY("Wrap", Wrap), + DECLARE_NODE_API_PROPERTY("Unwrap", Unwrap), + DECLARE_NODE_API_PROPERTY("TestSetProperty", TestSetProperty), + DECLARE_NODE_API_PROPERTY("TestHasProperty", TestHasProperty), + DECLARE_NODE_API_PROPERTY("TypeTaggedInstance", TypeTaggedInstance), + DECLARE_NODE_API_PROPERTY("TypeTaggedExternal", TypeTaggedExternal), + DECLARE_NODE_API_PROPERTY("PlainExternal", PlainExternal), + DECLARE_NODE_API_PROPERTY("CheckTypeTag", CheckTypeTag), + DECLARE_NODE_API_PROPERTY("TestGetProperty", TestGetProperty), + DECLARE_NODE_API_PROPERTY("TestFreeze", TestFreeze), + DECLARE_NODE_API_PROPERTY("TestSeal", TestSeal), + }; + + init_test_null(env, exports); + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_promise/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_promise/CMakeLists.txt new file mode 100644 index 00000000..0e82dff9 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_promise/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_promise + SOURCES + test_promise.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_promise/binding.gyp b/Tests/NodeApi/test/js-native-api/test_promise/binding.gyp new file mode 100644 index 00000000..c2b65f5a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_promise/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_promise", + "sources": [ + "test_promise.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_promise/test.js b/Tests/NodeApi/test/js-native-api/test_promise/test.js new file mode 100644 index 00000000..695fdcc2 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_promise/test.js @@ -0,0 +1,61 @@ +'use strict'; + +const common = require('../../common'); + +// This tests the promise-related n-api calls + +const assert = require('assert'); +const test_promise = require(`./build/${common.buildType}/test_promise`); + +// A resolution +{ + const expected_result = 42; + const promise = test_promise.createPromise(); + promise.then( + common.mustCall(function(result) { + assert.strictEqual(result, expected_result); + }), + common.mustNotCall()); + test_promise.concludeCurrentPromise(expected_result, true); +} + +// A rejection +{ + const expected_result = 'It\'s not you, it\'s me.'; + const promise = test_promise.createPromise(); + promise.then( + common.mustNotCall(), + common.mustCall(function(result) { + assert.strictEqual(result, expected_result); + })); + test_promise.concludeCurrentPromise(expected_result, false); +} + +// Chaining +{ + const expected_result = 'chained answer'; + const promise = test_promise.createPromise(); + promise.then( + common.mustCall(function(result) { + assert.strictEqual(result, expected_result); + }), + common.mustNotCall()); + test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true); +} + +const promiseTypeTestPromise = test_promise.createPromise(); +assert.strictEqual(test_promise.isPromise(promiseTypeTestPromise), true); +test_promise.concludeCurrentPromise(undefined, true); + +const rejectPromise = Promise.reject(-1); +const expected_reason = -1; +assert.strictEqual(test_promise.isPromise(rejectPromise), true); +rejectPromise.catch((reason) => { + assert.strictEqual(reason, expected_reason); +}); + +assert.strictEqual(test_promise.isPromise(2.4), false); +assert.strictEqual(test_promise.isPromise('I promise!'), false); +assert.strictEqual(test_promise.isPromise(undefined), false); +assert.strictEqual(test_promise.isPromise(null), false); +assert.strictEqual(test_promise.isPromise({}), false); diff --git a/Tests/NodeApi/test/js-native-api/test_promise/test_promise.c b/Tests/NodeApi/test/js-native-api/test_promise/test_promise.c new file mode 100644 index 00000000..1f0b5507 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_promise/test_promise.c @@ -0,0 +1,64 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +napi_deferred deferred = NULL; + +static napi_value createPromise(napi_env env, napi_callback_info info) { + napi_value promise; + + // We do not overwrite an existing deferred. + if (deferred != NULL) { + return NULL; + } + + NODE_API_CALL(env, napi_create_promise(env, &deferred, &promise)); + + return promise; +} + +static napi_value +concludeCurrentPromise(napi_env env, napi_callback_info info) { + napi_value argv[2]; + size_t argc = 2; + bool resolution; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); + NODE_API_CALL(env, napi_get_value_bool(env, argv[1], &resolution)); + if (resolution) { + NODE_API_CALL(env, napi_resolve_deferred(env, deferred, argv[0])); + } else { + NODE_API_CALL(env, napi_reject_deferred(env, deferred, argv[0])); + } + + deferred = NULL; + + return NULL; +} + +static napi_value isPromise(napi_env env, napi_callback_info info) { + napi_value promise, result; + size_t argc = 1; + bool is_promise; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &promise, NULL, NULL)); + NODE_API_CALL(env, napi_is_promise(env, promise, &is_promise)); + NODE_API_CALL(env, napi_get_boolean(env, is_promise, &result)); + + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("createPromise", createPromise), + DECLARE_NODE_API_PROPERTY("concludeCurrentPromise", concludeCurrentPromise), + DECLARE_NODE_API_PROPERTY("isPromise", isPromise), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_properties/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_properties/CMakeLists.txt new file mode 100644 index 00000000..18dcbf18 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_properties/CMakeLists.txt @@ -0,0 +1,6 @@ +add_node_api_module(test_properties + SOURCES + test_properties.c + DEFINES + "NAPI_VERSION=9" +) diff --git a/Tests/NodeApi/test/js-native-api/test_properties/binding.gyp b/Tests/NodeApi/test/js-native-api/test_properties/binding.gyp new file mode 100644 index 00000000..ab9d58db --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_properties/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_properties", + "sources": [ + "test_properties.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_properties/test.js b/Tests/NodeApi/test/js-native-api/test_properties/test.js new file mode 100644 index 00000000..6e035d67 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_properties/test.js @@ -0,0 +1,69 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const readonlyErrorRE = + /^TypeError: Cannot assign to read(-| )only property '.*'( of object '#')?$/; +const getterOnlyErrorRE = + /^TypeError: Cannot (set|assign to) property .*( of #)? which has only a getter$/; + +// Testing api calls for defining properties +const test_object = require(`./build/${common.buildType}/test_properties`); + +assert.strictEqual(test_object.echo('hello'), 'hello'); + +test_object.readwriteValue = 1; +assert.strictEqual(test_object.readwriteValue, 1); +test_object.readwriteValue = 2; +assert.strictEqual(test_object.readwriteValue, 2); + +assert.throws(() => { test_object.readonlyValue = 3; }, readonlyErrorRE); + +assert.ok(test_object.hiddenValue); + +// Properties with napi_enumerable attribute should be enumerable. +const propertyNames = []; +for (const name in test_object) { + propertyNames.push(name); +} +assert.ok(propertyNames.includes('echo')); +assert.ok(propertyNames.includes('readwriteValue')); +assert.ok(propertyNames.includes('readonlyValue')); +assert.ok(!propertyNames.includes('hiddenValue')); +assert.ok(propertyNames.includes('NameKeyValue')); +assert.ok(!propertyNames.includes('readwriteAccessor1')); +assert.ok(!propertyNames.includes('readwriteAccessor2')); +assert.ok(!propertyNames.includes('readonlyAccessor1')); +assert.ok(!propertyNames.includes('readonlyAccessor2')); + +// Validate property created with symbol +const start = 'Symbol('.length; +const end = start + 'NameKeySymbol'.length; +const symbolDescription = + String(Object.getOwnPropertySymbols(test_object)[0]).slice(start, end); +assert.strictEqual(symbolDescription, 'NameKeySymbol'); + +// The napi_writable attribute should be ignored for accessors. +const readwriteAccessor1Descriptor = + Object.getOwnPropertyDescriptor(test_object, 'readwriteAccessor1'); +const readonlyAccessor1Descriptor = + Object.getOwnPropertyDescriptor(test_object, 'readonlyAccessor1'); +assert.ok(readwriteAccessor1Descriptor.get != null); +assert.ok(readwriteAccessor1Descriptor.set != null); +assert.ok(readwriteAccessor1Descriptor.value === undefined); +assert.ok(readonlyAccessor1Descriptor.get != null); +assert.ok(readonlyAccessor1Descriptor.set === undefined); +assert.ok(readonlyAccessor1Descriptor.value === undefined); +test_object.readwriteAccessor1 = 1; +assert.strictEqual(test_object.readwriteAccessor1, 1); +assert.strictEqual(test_object.readonlyAccessor1, 1); +assert.throws(() => { test_object.readonlyAccessor1 = 3; }, getterOnlyErrorRE); +test_object.readwriteAccessor2 = 2; +assert.strictEqual(test_object.readwriteAccessor2, 2); +assert.strictEqual(test_object.readonlyAccessor2, 2); +assert.throws(() => { test_object.readonlyAccessor2 = 3; }, getterOnlyErrorRE); + +assert.strictEqual(test_object.hasNamedProperty(test_object, 'echo'), true); +assert.strictEqual(test_object.hasNamedProperty(test_object, 'hiddenValue'), + true); +assert.strictEqual(test_object.hasNamedProperty(test_object, 'doesnotexist'), + false); diff --git a/Tests/NodeApi/test/js-native-api/test_properties/test_properties.c b/Tests/NodeApi/test/js-native-api/test_properties/test_properties.c new file mode 100644 index 00000000..7b8e67a9 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_properties/test_properties.c @@ -0,0 +1,113 @@ +#define NAPI_VERSION 9 +#include +#include "../common.h" +#include "../entry_point.h" + +static double value_ = 1; + +static napi_value GetValue(napi_env env, napi_callback_info info) { + size_t argc = 0; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 0, "Wrong number of arguments"); + + napi_value number; + NODE_API_CALL(env, napi_create_double(env, value_, &number)); + + return number; +} + +static napi_value SetValue(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + NODE_API_CALL(env, napi_get_value_double(env, args[0], &value_)); + + return NULL; +} + +static napi_value Echo(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + return args[0]; +} + +static napi_value HasNamedProperty(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments"); + + // Extract the name of the property to check + char buffer[128]; + size_t copied; + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[1], buffer, sizeof(buffer), &copied)); + + // do the check and create the boolean return value + bool value; + napi_value result; + NODE_API_CALL(env, napi_has_named_property(env, args[0], buffer, &value)); + NODE_API_CALL(env, napi_get_boolean(env, value, &result)); + + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_value number; + NODE_API_CALL(env, napi_create_double(env, value_, &number)); + + napi_value name_value; + NODE_API_CALL(env, + napi_create_string_utf8( + env, "NameKeyValue", NAPI_AUTO_LENGTH, &name_value)); + + napi_value symbol_description; + napi_value name_symbol; + NODE_API_CALL(env, + napi_create_string_utf8( + env, "NameKeySymbol", NAPI_AUTO_LENGTH, &symbol_description)); + NODE_API_CALL(env, + napi_create_symbol(env, symbol_description, &name_symbol)); + + napi_value name_symbol_descriptionless; + NODE_API_CALL(env, + napi_create_symbol(env, NULL, &name_symbol_descriptionless)); + + napi_value name_symbol_for; + NODE_API_CALL(env, node_api_symbol_for(env, + "NameKeySymbolFor", + NAPI_AUTO_LENGTH, + &name_symbol_for)); + + napi_property_descriptor properties[] = { + { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 }, + { "readwriteValue", 0, 0, 0, 0, number, napi_enumerable | napi_writable, 0 }, + { "readonlyValue", 0, 0, 0, 0, number, napi_enumerable, 0}, + { "hiddenValue", 0, 0, 0, 0, number, napi_default, 0}, + { NULL, name_value, 0, 0, 0, number, napi_enumerable, 0}, + { NULL, name_symbol, 0, 0, 0, number, napi_enumerable, 0}, + { NULL, name_symbol_descriptionless, 0, 0, 0, number, napi_enumerable, 0}, + { NULL, name_symbol_for, 0, 0, 0, number, napi_enumerable, 0}, + { "readwriteAccessor1", 0, 0, GetValue, SetValue, 0, napi_default, 0}, + { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0}, + { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0}, + { "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0}, + { "hasNamedProperty", 0, HasNamedProperty, 0, 0, 0, napi_default, 0 }, + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_reference/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_reference/CMakeLists.txt new file mode 100644 index 00000000..2c0dd7b5 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/CMakeLists.txt @@ -0,0 +1,11 @@ +add_node_api_module(test_reference + SOURCES + test_reference.c + DEFINES + "NAPI_VERSION=9" +) + +add_node_api_module(test_finalizer + SOURCES + test_finalizer.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_reference/binding.gyp b/Tests/NodeApi/test/js-native-api/test_reference/binding.gyp new file mode 100644 index 00000000..2f2acb3a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/binding.gyp @@ -0,0 +1,16 @@ +{ + "targets": [ + { + "target_name": "test_reference", + "sources": [ + "test_reference.c" + ] + }, + { + "target_name": "test_finalizer", + "sources": [ + "test_finalizer.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_reference/test.js b/Tests/NodeApi/test/js-native-api/test_reference/test.js new file mode 100644 index 00000000..aa5c9953 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/test.js @@ -0,0 +1,158 @@ +'use strict'; +// Flags: --expose-gc + +const { buildType } = require('../../common'); +const { gcUntil } = require('../../common/gc'); +const assert = require('assert'); + +const test_reference = require(`./build/${buildType}/test_reference`); + +// This test script uses external values with finalizer callbacks +// in order to track when values get garbage-collected. Each invocation +// of a finalizer callback increments the finalizeCount property. +assert.strictEqual(test_reference.finalizeCount, 0); + +// Run each test function in sequence, +// with an async delay and GC call between each. +async function runTests() { + (() => { + const symbol = test_reference.createSymbol('testSym'); + test_reference.createReference(symbol, 0); + assert.strictEqual(test_reference.referenceValue, symbol); + })(); + test_reference.deleteReference(); + + (() => { + const symbol = test_reference.createSymbolFor('testSymFor'); + test_reference.createReference(symbol, 0); + assert.strictEqual(test_reference.referenceValue, symbol); + })(); + test_reference.deleteReference(); + + (() => { + const symbol = test_reference.createSymbolFor('testSymFor'); + test_reference.createReference(symbol, 1); + assert.strictEqual(test_reference.referenceValue, symbol); + assert.strictEqual(test_reference.referenceValue, Symbol.for('testSymFor')); + })(); + test_reference.deleteReference(); + + (() => { + const symbol = test_reference.createSymbolForEmptyString(); + test_reference.createReference(symbol, 0); + assert.strictEqual(test_reference.referenceValue, Symbol.for('')); + })(); + test_reference.deleteReference(); + + (() => { + const symbol = test_reference.createSymbolForEmptyString(); + test_reference.createReference(symbol, 1); + assert.strictEqual(test_reference.referenceValue, symbol); + assert.strictEqual(test_reference.referenceValue, Symbol.for('')); + })(); + test_reference.deleteReference(); + + assert.throws(() => test_reference.createSymbolForIncorrectLength(), + /Invalid argument/); + + (() => { + const value = test_reference.createExternal(); + assert.strictEqual(test_reference.finalizeCount, 0); + assert.strictEqual(typeof value, 'object'); + test_reference.checkExternal(value); + })(); + await gcUntil('External value without a finalizer', + () => (test_reference.finalizeCount === 0)); + + (() => { + const value = test_reference.createExternalWithFinalize(); + assert.strictEqual(test_reference.finalizeCount, 0); + assert.strictEqual(typeof value, 'object'); + test_reference.checkExternal(value); + })(); + await gcUntil('External value with a finalizer', + () => (test_reference.finalizeCount === 1)); + + (() => { + const value = test_reference.createExternalWithFinalize(); + assert.strictEqual(test_reference.finalizeCount, 0); + test_reference.createReference(value, 0); + assert.strictEqual(test_reference.referenceValue, value); + })(); + // Value should be GC'd because there is only a weak ref + await gcUntil('Weak reference', + () => (test_reference.referenceValue === undefined && + test_reference.finalizeCount === 1)); + test_reference.deleteReference(); + + (() => { + const value = test_reference.createExternalWithFinalize(); + assert.strictEqual(test_reference.finalizeCount, 0); + test_reference.createReference(value, 1); + assert.strictEqual(test_reference.referenceValue, value); + })(); + // Value should NOT be GC'd because there is a strong ref + await gcUntil('Strong reference', + () => (test_reference.finalizeCount === 0)); + test_reference.deleteReference(); + await gcUntil('Strong reference (cont.d)', + () => (test_reference.finalizeCount === 1)); + + (() => { + const value = test_reference.createExternalWithFinalize(); + assert.strictEqual(test_reference.finalizeCount, 0); + test_reference.createReference(value, 1); + })(); + // Value should NOT be GC'd because there is a strong ref + await gcUntil('Strong reference, increment then decrement to weak reference', + () => (test_reference.finalizeCount === 0)); + assert.strictEqual(test_reference.incrementRefcount(), 2); + // Value should NOT be GC'd because there is a strong ref + await gcUntil( + 'Strong reference, increment then decrement to weak reference (cont.d-1)', + () => (test_reference.finalizeCount === 0)); + assert.strictEqual(test_reference.decrementRefcount(), 1); + // Value should NOT be GC'd because there is a strong ref + await gcUntil( + 'Strong reference, increment then decrement to weak reference (cont.d-2)', + () => (test_reference.finalizeCount === 0)); + assert.strictEqual(test_reference.decrementRefcount(), 0); + // Value should be GC'd because the ref is now weak! + await gcUntil( + 'Strong reference, increment then decrement to weak reference (cont.d-3)', + () => (test_reference.finalizeCount === 1)); + test_reference.deleteReference(); + // Value was already GC'd + await gcUntil( + 'Strong reference, increment then decrement to weak reference (cont.d-4)', + () => (test_reference.finalizeCount === 1)); +} +runTests(); + +// This test creates a napi_ref on an object that has +// been wrapped by napi_wrap and for which the finalizer +// for the wrap calls napi_delete_ref on that napi_ref. +// +// Since both the wrap and the reference use the same +// object the finalizer for the wrap and reference +// may run in the same gc and in any order. +// +// It does that to validate that napi_delete_ref can be +// called before the finalizer has been run for the +// reference (there is a finalizer behind the scenes even +// though it cannot be passed to napi_create_reference). +// +// Since the order is not guaranteed, run the +// test a number of times maximize the chance that we +// get a run with the desired order for the test. +// +// 1000 reliably recreated the problem without the fix +// required to ensure delete could be called before +// the finalizer in manual testing. +for (let i = 0; i < 1000; i++) { + (() => { + const wrapObject = new Object(); + test_reference.validateDeleteBeforeFinalize(wrapObject); + })(); + global.gc(); +} diff --git a/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.c b/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.c new file mode 100644 index 00000000..0ce671b6 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.c @@ -0,0 +1,79 @@ +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static int test_value = 1; +static int finalize_count = 0; + +static napi_value GetFinalizeCount(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_create_int32(env, finalize_count, &result)); + return result; +} +static void FinalizeExternalCallJs(napi_env env, void* data, void* hint) { + finalize_count++; + + int* actual_value = data; + NODE_API_ASSERT_RETURN_VOID( + env, + actual_value == &test_value, + "The correct pointer was passed to the finalizer"); + + napi_ref finalizer_ref = (napi_ref)hint; + napi_value js_finalizer; + napi_value recv; + NODE_API_CALL_RETURN_VOID( + env, napi_get_reference_value(env, finalizer_ref, &js_finalizer)); + NODE_API_CALL_RETURN_VOID(env, napi_get_global(env, &recv)); + NODE_API_CALL_RETURN_VOID( + env, napi_call_function(env, recv, js_finalizer, 0, NULL, NULL)); + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, finalizer_ref)); +} + +static napi_value CreateExternalWithJsFinalize(napi_env env, + napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + napi_value finalizer = args[0]; + napi_valuetype finalizer_valuetype; + NODE_API_CALL(env, napi_typeof(env, finalizer, &finalizer_valuetype)); + NODE_API_ASSERT(env, + finalizer_valuetype == napi_function, + "Wrong type of first argument"); + napi_ref finalizer_ref; + NODE_API_CALL(env, napi_create_reference(env, finalizer, 1, &finalizer_ref)); + + napi_value result; + NODE_API_CALL(env, + napi_create_external(env, + &test_value, + FinalizeExternalCallJs, + finalizer_ref, /* finalize_hint */ + &result)); + + finalize_count = 0; + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_GETTER("finalizeCount", GetFinalizeCount), + DECLARE_NODE_API_PROPERTY("createExternalWithJsFinalize", + CreateExternalWithJsFinalize), + }; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.js b/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.js new file mode 100644 index 00000000..0b973163 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/test_finalizer.js @@ -0,0 +1,24 @@ +'use strict'; +// Flags: --expose-gc --force-node-api-uncaught-exceptions-policy + +const common = require('../../common'); +const binding = require(`./build/${common.buildType}/test_finalizer`); +const assert = require('assert'); +const { gcUntil } = require('../../common/gc'); + +process.on('uncaughtException', common.mustCall((err) => { + assert.throws(() => { throw err; }, /finalizer error/); +})); + +(async function() { + (() => { + binding.createExternalWithJsFinalize( + common.mustCall(() => { + throw new Error('finalizer error'); + }) + ); + })(); + await gcUntil('External value calls finalizer', + () => (binding.finalizeCount === 1)); + +})().then(common.mustCall()); diff --git a/Tests/NodeApi/test/js-native-api/test_reference/test_reference.c b/Tests/NodeApi/test/js-native-api/test_reference/test_reference.c new file mode 100644 index 00000000..a66b8068 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference/test_reference.c @@ -0,0 +1,252 @@ +#define NAPI_VERSION 9 +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static int test_value = 1; +static int finalize_count = 0; +static napi_ref test_reference = NULL; + +static napi_value GetFinalizeCount(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, napi_create_int32(env, finalize_count, &result)); + return result; +} + +static void FinalizeExternal(napi_env env, void* data, void* hint) { + int *actual_value = data; + NODE_API_ASSERT_RETURN_VOID(env, actual_value == &test_value, + "The correct pointer was passed to the finalizer"); + finalize_count++; +} + +static napi_value CreateExternal(napi_env env, napi_callback_info info) { + int* data = &test_value; + + napi_value result; + NODE_API_CALL(env, + napi_create_external(env, + data, + NULL, /* finalize_cb */ + NULL, /* finalize_hint */ + &result)); + + finalize_count = 0; + return result; +} + +static napi_value CreateSymbol(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT( + env, argc == 1, "Expect one argument only (symbol description)"); + + napi_value result_symbol; + + NODE_API_CALL(env, napi_create_symbol(env, args[0], &result_symbol)); + return result_symbol; +} + +static napi_value CreateSymbolFor(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + + char description[256]; + size_t description_length; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT( + env, argc == 1, "Expect one argument only (symbol description)"); + + NODE_API_CALL( + env, + napi_get_value_string_utf8( + env, args[0], description, sizeof(description), &description_length)); + NODE_API_ASSERT(env, + description_length <= 255, + "Cannot accommodate descriptions longer than 255 bytes"); + + napi_value result_symbol; + + NODE_API_CALL(env, + node_api_symbol_for( + env, description, description_length, &result_symbol)); + return result_symbol; +} + +static napi_value CreateSymbolForEmptyString(napi_env env, napi_callback_info info) { + napi_value result_symbol; + NODE_API_CALL(env, node_api_symbol_for(env, NULL, 0, &result_symbol)); + return result_symbol; +} + +static napi_value CreateSymbolForIncorrectLength(napi_env env, napi_callback_info info) { + napi_value result_symbol; + NODE_API_CALL(env, node_api_symbol_for(env, NULL, 5, &result_symbol)); + return result_symbol; +} + +static napi_value +CreateExternalWithFinalize(napi_env env, napi_callback_info info) { + napi_value result; + NODE_API_CALL(env, + napi_create_external(env, + &test_value, + FinalizeExternal, + NULL, /* finalize_hint */ + &result)); + + finalize_count = 0; + return result; +} + +static napi_value CheckExternal(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value arg; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Expected one argument."); + + napi_valuetype argtype; + NODE_API_CALL(env, napi_typeof(env, arg, &argtype)); + + NODE_API_ASSERT(env, argtype == napi_external, "Expected an external value."); + + void* data; + NODE_API_CALL(env, napi_get_value_external(env, arg, &data)); + + NODE_API_ASSERT(env, data != NULL && *(int*)data == test_value, + "An external data value of 1 was expected."); + + return NULL; +} + +static napi_value CreateReference(napi_env env, napi_callback_info info) { + NODE_API_ASSERT(env, test_reference == NULL, + "The test allows only one reference at a time."); + + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 2, "Expected two arguments."); + + uint32_t initial_refcount; + NODE_API_CALL(env, napi_get_value_uint32(env, args[1], &initial_refcount)); + + NODE_API_CALL(env, + napi_create_reference(env, args[0], initial_refcount, &test_reference)); + + NODE_API_ASSERT(env, test_reference != NULL, + "A reference should have been created."); + + return NULL; +} + +static napi_value DeleteReference(napi_env env, napi_callback_info info) { + NODE_API_ASSERT(env, test_reference != NULL, + "A reference must have been created."); + + NODE_API_CALL(env, napi_delete_reference(env, test_reference)); + test_reference = NULL; + return NULL; +} + +static napi_value IncrementRefcount(napi_env env, napi_callback_info info) { + NODE_API_ASSERT(env, test_reference != NULL, + "A reference must have been created."); + + uint32_t refcount; + NODE_API_CALL(env, napi_reference_ref(env, test_reference, &refcount)); + + napi_value result; + NODE_API_CALL(env, napi_create_uint32(env, refcount, &result)); + return result; +} + +static napi_value DecrementRefcount(napi_env env, napi_callback_info info) { + NODE_API_ASSERT(env, test_reference != NULL, + "A reference must have been created."); + + uint32_t refcount; + NODE_API_CALL(env, napi_reference_unref(env, test_reference, &refcount)); + + napi_value result; + NODE_API_CALL(env, napi_create_uint32(env, refcount, &result)); + return result; +} + +static napi_value GetReferenceValue(napi_env env, napi_callback_info info) { + NODE_API_ASSERT(env, test_reference != NULL, + "A reference must have been created."); + + napi_value result; + NODE_API_CALL(env, napi_get_reference_value(env, test_reference, &result)); + return result; +} + +static void DeleteBeforeFinalizeFinalizer( + napi_env env, void* finalize_data, void* finalize_hint) { + napi_ref* ref = (napi_ref*)finalize_data; + napi_value value; + assert(napi_get_reference_value(env, *ref, &value) == napi_ok); + assert(value == NULL); + napi_delete_reference(env, *ref); + free(ref); +} + +static napi_value ValidateDeleteBeforeFinalize(napi_env env, napi_callback_info info) { + napi_value wrapObject; + size_t argc = 1; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &wrapObject, NULL, NULL)); + + napi_ref* ref_t = malloc(sizeof(napi_ref)); + NODE_API_CALL(env, + napi_wrap( + env, wrapObject, ref_t, DeleteBeforeFinalizeFinalizer, NULL, NULL)); + + // Create a reference that will be eligible for collection at the same + // time as the wrapped object by passing in the same wrapObject. + // This means that the FinalizeOrderValidation callback may be run + // before the finalizer for the newly created reference (there is a finalizer + // behind the scenes even though it cannot be passed to napi_create_reference) + // The Finalizer for the wrap (which is different than the finalizer + // for the reference) calls napi_delete_reference validating that + // napi_delete_reference can be called before the finalizer for the + // reference runs. + NODE_API_CALL(env, napi_create_reference(env, wrapObject, 0, ref_t)); + return wrapObject; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_GETTER("finalizeCount", GetFinalizeCount), + DECLARE_NODE_API_PROPERTY("createExternal", CreateExternal), + DECLARE_NODE_API_PROPERTY("createExternalWithFinalize", + CreateExternalWithFinalize), + DECLARE_NODE_API_PROPERTY("checkExternal", CheckExternal), + DECLARE_NODE_API_PROPERTY("createReference", CreateReference), + DECLARE_NODE_API_PROPERTY("createSymbol", CreateSymbol), + DECLARE_NODE_API_PROPERTY("createSymbolFor", CreateSymbolFor), + DECLARE_NODE_API_PROPERTY("createSymbolForEmptyString", + CreateSymbolForEmptyString), + DECLARE_NODE_API_PROPERTY("createSymbolForIncorrectLength", + CreateSymbolForIncorrectLength), + DECLARE_NODE_API_PROPERTY("deleteReference", DeleteReference), + DECLARE_NODE_API_PROPERTY("incrementRefcount", IncrementRefcount), + DECLARE_NODE_API_PROPERTY("decrementRefcount", DecrementRefcount), + DECLARE_NODE_API_GETTER("referenceValue", GetReferenceValue), + DECLARE_NODE_API_PROPERTY("validateDeleteBeforeFinalize", + ValidateDeleteBeforeFinalize), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_reference_double_free/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_reference_double_free/CMakeLists.txt new file mode 100644 index 00000000..3fe097a0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference_double_free/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_reference_double_free + SOURCES + test_reference_double_free.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_reference_double_free/binding.gyp b/Tests/NodeApi/test/js-native-api/test_reference_double_free/binding.gyp new file mode 100644 index 00000000..8e49ef22 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference_double_free/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_reference_double_free", + "sources": [ + "test_reference_double_free.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_reference_double_free/test.js b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test.js new file mode 100644 index 00000000..f9a465c5 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test.js @@ -0,0 +1,11 @@ +'use strict'; + +// This test makes no assertions. It tests a fix without which it will crash +// with a double free. + +const { buildType } = require('../../common'); + +const addon = require(`./build/${buildType}/test_reference_double_free`); + +{ new addon.MyObject(true); } +{ new addon.MyObject(false); } diff --git a/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_reference_double_free.c b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_reference_double_free.c new file mode 100644 index 00000000..e99667a7 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_reference_double_free.c @@ -0,0 +1,90 @@ +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static size_t g_call_count = 0; + +static void Destructor(napi_env env, void* data, void* nothing) { + napi_ref* ref = data; + NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, *ref)); + free(ref); +} + +static void NoDeleteDestructor(napi_env env, void* data, void* hint) { + napi_ref* ref = data; + size_t* call_count = hint; + + // This destructor must be called exactly once. + if ((*call_count) > 0) abort(); + *call_count = ((*call_count) + 1); + free(ref); +} + +static napi_value New(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value js_this, js_delete; + bool delete; + napi_ref* ref = malloc(sizeof(*ref)); + + NODE_API_CALL(env, + napi_get_cb_info(env, info, &argc, &js_delete, &js_this, NULL)); + NODE_API_CALL(env, napi_get_value_bool(env, js_delete, &delete)); + + if (delete) { + NODE_API_CALL(env, + napi_wrap(env, js_this, ref, Destructor, NULL, ref)); + } else { + NODE_API_CALL(env, + napi_wrap(env, js_this, ref, NoDeleteDestructor, &g_call_count, ref)); + } + NODE_API_CALL(env, napi_reference_ref(env, *ref, NULL)); + + return js_this; +} + +static void NoopDeleter(napi_env env, void* data, void* hint) {} + +// Tests that calling napi_remove_wrap and napi_delete_reference consecutively +// doesn't crash the process. +// This is analogous to the test https://github.com/nodejs/node-addon-api/blob/main/test/objectwrap_constructor_exception.cc. +// In which the Napi::ObjectWrap<> is being destructed immediately after napi_wrap. +// As Napi::ObjectWrap<> is a subclass of Napi::Reference<>, napi_remove_wrap +// in the destructor of Napi::ObjectWrap<> is called before napi_delete_reference +// in the destructor of Napi::Reference<>. +static napi_value DeleteImmediately(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value js_obj; + napi_ref ref; + napi_valuetype type; + + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &js_obj, NULL, NULL)); + + NODE_API_CALL(env, napi_typeof(env, js_obj, &type)); + NODE_API_ASSERT(env, type == napi_object, "Expected object parameter"); + + NODE_API_CALL(env, napi_wrap(env, js_obj, NULL, NoopDeleter, NULL, &ref)); + NODE_API_CALL(env, napi_remove_wrap(env, js_obj, NULL)); + NODE_API_CALL(env, napi_delete_reference(env, ref)); + + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_value myobj_ctor; + NODE_API_CALL(env, + napi_define_class( + env, "MyObject", NAPI_AUTO_LENGTH, New, NULL, 0, NULL, &myobj_ctor)); + NODE_API_CALL(env, + napi_set_named_property(env, exports, "MyObject", myobj_ctor)); + + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("deleteImmediately", DeleteImmediately), + }; + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_wrap.js b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_wrap.js new file mode 100644 index 00000000..f7f75094 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_reference_double_free/test_wrap.js @@ -0,0 +1,10 @@ +'use strict'; + +// This test makes no assertions. It tests that calling napi_remove_wrap and +// napi_delete_reference consecutively doesn't crash the process. + +const { buildType } = require('../../common'); + +const addon = require(`./build/${buildType}/test_reference_double_free`); + +addon.deleteImmediately({}); diff --git a/Tests/NodeApi/test/js-native-api/test_string/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_string/CMakeLists.txt new file mode 100644 index 00000000..5244fdba --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/CMakeLists.txt @@ -0,0 +1,7 @@ +add_node_api_module(test_string + SOURCES + test_string.c + test_null.c + DEFINES + "NAPI_VERSION=10" +) diff --git a/Tests/NodeApi/test/js-native-api/test_string/binding.gyp b/Tests/NodeApi/test/js-native-api/test_string/binding.gyp new file mode 100644 index 00000000..550e33b4 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/binding.gyp @@ -0,0 +1,14 @@ +{ + "targets": [ + { + "target_name": "test_string", + "sources": [ + "test_string.c", + "test_null.c", + ], + "defines": [ + "NAPI_VERSION=10", + ], + }, + ], +} diff --git a/Tests/NodeApi/test/js-native-api/test_string/test.js b/Tests/NodeApi/test/js-native-api/test_string/test.js new file mode 100644 index 00000000..5d03ba9d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/test.js @@ -0,0 +1,91 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for string +const test_string = require(`./build/${common.buildType}/test_string`); +// The insufficient buffer test case allocates a buffer of size 4, including +// the null terminator. +const kInsufficientIdx = 3; + +const asciiCases = [ + '', + 'hello world', + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', + '?!@#$%^&*()_+-=[]{}/.,<>\'"\\', +]; + +const latin1Cases = [ + { + str: '¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿', + utf8Length: 62, + utf8InsufficientIdx: 1, + }, + { + str: 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ', + utf8Length: 126, + utf8InsufficientIdx: 1, + }, +]; + +const unicodeCases = [ + { + str: '\u{2003}\u{2101}\u{2001}\u{202}\u{2011}', + utf8Length: 14, + utf8InsufficientIdx: 1, + }, +]; + +function testLatin1Cases(str) { + assert.strictEqual(test_string.TestLatin1(str), str); + assert.strictEqual(test_string.TestLatin1AutoLength(str), str); + assert.strictEqual(test_string.TestLatin1External(str), str); + assert.strictEqual(test_string.TestLatin1ExternalAutoLength(str), str); + assert.strictEqual(test_string.TestPropertyKeyLatin1(str), str); + assert.strictEqual(test_string.TestPropertyKeyLatin1AutoLength(str), str); + assert.strictEqual(test_string.Latin1Length(str), str.length); + + if (str !== '') { + assert.strictEqual(test_string.TestLatin1Insufficient(str), str.slice(0, kInsufficientIdx)); + } +} + +function testUnicodeCases(str, utf8Length, utf8InsufficientIdx) { + assert.strictEqual(test_string.TestUtf8(str), str); + assert.strictEqual(test_string.TestUtf16(str), str); + assert.strictEqual(test_string.TestUtf8AutoLength(str), str); + assert.strictEqual(test_string.TestUtf16AutoLength(str), str); + assert.strictEqual(test_string.TestUtf16External(str), str); + assert.strictEqual(test_string.TestUtf16ExternalAutoLength(str), str); + assert.strictEqual(test_string.TestPropertyKeyUtf8(str), str); + assert.strictEqual(test_string.TestPropertyKeyUtf8AutoLength(str), str); + assert.strictEqual(test_string.TestPropertyKeyUtf16(str), str); + assert.strictEqual(test_string.TestPropertyKeyUtf16AutoLength(str), str); + assert.strictEqual(test_string.Utf8Length(str), utf8Length); + assert.strictEqual(test_string.Utf16Length(str), str.length); + + if (str !== '') { + assert.strictEqual(test_string.TestUtf8Insufficient(str), str.slice(0, utf8InsufficientIdx)); + assert.strictEqual(test_string.TestUtf16Insufficient(str), str.slice(0, kInsufficientIdx)); + } +} + +asciiCases.forEach(testLatin1Cases); +asciiCases.forEach((str) => testUnicodeCases(str, str.length, kInsufficientIdx)); +latin1Cases.forEach((it) => testLatin1Cases(it.str)); +latin1Cases.forEach((it) => testUnicodeCases(it.str, it.utf8Length, it.utf8InsufficientIdx)); +unicodeCases.forEach((it) => testUnicodeCases(it.str, it.utf8Length, it.utf8InsufficientIdx)); + +assert.throws(() => { + test_string.TestLargeUtf8(); +}, /^Error: Invalid argument$/); + +assert.throws(() => { + test_string.TestLargeLatin1(); +}, /^Error: Invalid argument$/); + +assert.throws(() => { + test_string.TestLargeUtf16(); +}, /^Error: Invalid argument$/); + +test_string.TestMemoryCorruption(' '.repeat(64 * 1024)); diff --git a/Tests/NodeApi/test/js-native-api/test_string/test_null.c b/Tests/NodeApi/test/js-native-api/test_string/test_null.c new file mode 100644 index 00000000..84c1fc40 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/test_null.c @@ -0,0 +1,71 @@ +#include + +#include "../common.h" +#include "test_null.h" + +#define DECLARE_TEST(charset, str_arg) \ + static napi_value \ + test_create_##charset(napi_env env, napi_callback_info info) { \ + napi_value return_value, result; \ + NODE_API_CALL(env, napi_create_object(env, &return_value)); \ + \ + add_returned_status(env, \ + "envIsNull", \ + return_value, \ + "Invalid argument", \ + napi_invalid_arg, \ + napi_create_string_##charset(NULL, \ + (str_arg), \ + NAPI_AUTO_LENGTH, \ + &result)); \ + \ + napi_create_string_##charset(env, NULL, NAPI_AUTO_LENGTH, &result); \ + add_last_status(env, "stringIsNullNonZeroLength", return_value); \ + \ + napi_create_string_##charset(env, NULL, 0, &result); \ + add_last_status(env, "stringIsNullZeroLength", return_value); \ + \ + napi_create_string_##charset(env, (str_arg), NAPI_AUTO_LENGTH, NULL); \ + add_last_status(env, "resultIsNull", return_value); \ + \ + return return_value; \ + } + +static const char16_t something[] = { + (char16_t)'s', + (char16_t)'o', + (char16_t)'m', + (char16_t)'e', + (char16_t)'t', + (char16_t)'h', + (char16_t)'i', + (char16_t)'n', + (char16_t)'g', + (char16_t)'\0' +}; + +DECLARE_TEST(utf8, "something") +DECLARE_TEST(latin1, "something") +DECLARE_TEST(utf16, something) + +void init_test_null(napi_env env, napi_value exports) { + napi_value test_null; + + const napi_property_descriptor test_null_props[] = { + DECLARE_NODE_API_PROPERTY("test_create_utf8", test_create_utf8), + DECLARE_NODE_API_PROPERTY("test_create_latin1", test_create_latin1), + DECLARE_NODE_API_PROPERTY("test_create_utf16", test_create_utf16), + }; + + NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null)); + NODE_API_CALL_RETURN_VOID(env, napi_define_properties( + env, test_null, sizeof(test_null_props) / sizeof(*test_null_props), + test_null_props)); + + const napi_property_descriptor test_null_set = { + "testNull", NULL, NULL, NULL, NULL, test_null, napi_enumerable, NULL + }; + + NODE_API_CALL_RETURN_VOID(env, + napi_define_properties(env, exports, 1, &test_null_set)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_string/test_null.h b/Tests/NodeApi/test/js-native-api/test_string/test_null.h new file mode 100644 index 00000000..95be6359 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/test_null.h @@ -0,0 +1,8 @@ +#ifndef TEST_JS_NATIVE_API_TEST_STRING_TEST_NULL_H_ +#define TEST_JS_NATIVE_API_TEST_STRING_TEST_NULL_H_ + +#include + +void init_test_null(napi_env env, napi_value exports); + +#endif // TEST_JS_NATIVE_API_TEST_STRING_TEST_NULL_H_ diff --git a/Tests/NodeApi/test/js-native-api/test_string/test_null.js b/Tests/NodeApi/test/js-native-api/test_string/test_null.js new file mode 100644 index 00000000..71963009 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/test_null.js @@ -0,0 +1,17 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Test passing NULL to object-related N-APIs. +const { testNull } = require(`./build/${common.buildType}/test_string`); + +const expectedResult = { + envIsNull: 'Invalid argument', + stringIsNullNonZeroLength: 'Invalid argument', + stringIsNullZeroLength: 'napi_ok', + resultIsNull: 'Invalid argument', +}; + +assert.deepStrictEqual(expectedResult, testNull.test_create_latin1()); +assert.deepStrictEqual(expectedResult, testNull.test_create_utf8()); +assert.deepStrictEqual(expectedResult, testNull.test_create_utf16()); diff --git a/Tests/NodeApi/test/js-native-api/test_string/test_string.c b/Tests/NodeApi/test/js-native-api/test_string/test_string.c new file mode 100644 index 00000000..c6874dc7 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_string/test_string.c @@ -0,0 +1,498 @@ +#include +#include // INT_MAX +#include +#include +#include "../common.h" +#include "../entry_point.h" +#include "test_null.h" + +enum length_type { actual_length, auto_length }; + +static napi_status validate_and_retrieve_single_string_arg( + napi_env env, napi_callback_info info, napi_value* arg) { + size_t argc = 1; + NODE_API_CHECK_STATUS(napi_get_cb_info(env, info, &argc, arg, NULL, NULL)); + + NODE_API_ASSERT_STATUS(env, argc >= 1, "Wrong number of arguments"); + + napi_valuetype valuetype; + NODE_API_CHECK_STATUS(napi_typeof(env, *arg, &valuetype)); + + NODE_API_ASSERT_STATUS(env, + valuetype == napi_string, + "Wrong type of argment. Expects a string."); + + return napi_ok; +} + +// These help us factor out code that is common between the bindings. +typedef napi_status (*OneByteCreateAPI)(napi_env, + const char*, + size_t, + napi_value*); +typedef napi_status (*OneByteGetAPI)( + napi_env, napi_value, char*, size_t, size_t*); +typedef napi_status (*TwoByteCreateAPI)(napi_env, + const char16_t*, + size_t, + napi_value*); +typedef napi_status (*TwoByteGetAPI)( + napi_env, napi_value, char16_t*, size_t, size_t*); + +// Test passing back the one-byte string we got from JS. +static napi_value TestOneByteImpl(napi_env env, + napi_callback_info info, + OneByteGetAPI get_api, + OneByteCreateAPI create_api, + enum length_type length_mode) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + char buffer[128]; + size_t buffer_size = 128; + size_t copied; + + NODE_API_CALL(env, get_api(env, args[0], buffer, buffer_size, &copied)); + + napi_value output; + if (length_mode == auto_length) { + copied = NAPI_AUTO_LENGTH; + } + NODE_API_CALL(env, create_api(env, buffer, copied, &output)); + + return output; +} + +// Test passing back the two-byte string we got from JS. +static napi_value TestTwoByteImpl(napi_env env, + napi_callback_info info, + TwoByteGetAPI get_api, + TwoByteCreateAPI create_api, + enum length_type length_mode) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + char16_t buffer[128]; + size_t buffer_size = 128; + size_t copied; + + NODE_API_CALL(env, get_api(env, args[0], buffer, buffer_size, &copied)); + + napi_value output; + if (length_mode == auto_length) { + copied = NAPI_AUTO_LENGTH; + } + NODE_API_CALL(env, create_api(env, buffer, copied, &output)); + + return output; +} + +static void free_string(node_api_basic_env env, void* data, void* hint) { + free(data); +} + +static napi_status create_external_latin1(napi_env env, + const char* string, + size_t length, + napi_value* result) { + napi_status status; + // Initialize to true, because that is the value we don't want. + bool copied = true; + char* string_copy; + const size_t actual_length = + (length == NAPI_AUTO_LENGTH ? strlen(string) : length); + const size_t length_bytes = (actual_length + 1) * sizeof(*string_copy); + string_copy = malloc(length_bytes); + memcpy(string_copy, string, length_bytes); + string_copy[actual_length] = 0; + + status = node_api_create_external_string_latin1( + env, string_copy, length, free_string, NULL, result, &copied); + // We do not want the string to be copied. + if (copied) { + return napi_generic_failure; + } + if (status != napi_ok) { + free(string_copy); + return status; + } + return napi_ok; +} + +// strlen for char16_t. Needed in case we're copying a string of length +// NAPI_AUTO_LENGTH. +static size_t strlen16(const char16_t* string) { + for (const char16_t* iter = string;; iter++) { + if (*iter == 0) { + return iter - string; + } + } + // We should never get here. + abort(); +} + +static napi_status create_external_utf16(napi_env env, + const char16_t* string, + size_t length, + napi_value* result) { + napi_status status; + // Initialize to true, because that is the value we don't want. + bool copied = true; + char16_t* string_copy; + const size_t actual_length = + (length == NAPI_AUTO_LENGTH ? strlen16(string) : length); + const size_t length_bytes = (actual_length + 1) * sizeof(*string_copy); + string_copy = malloc(length_bytes); + memcpy(string_copy, string, length_bytes); + string_copy[actual_length] = 0; + + status = node_api_create_external_string_utf16( + env, string_copy, length, free_string, NULL, result, &copied); + if (status != napi_ok) { + free(string_copy); + return status; + } + + return napi_ok; +} + +static napi_value TestLatin1(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + napi_create_string_latin1, + actual_length); +} + +static napi_value TestUtf8(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_utf8, + napi_create_string_utf8, + actual_length); +} + +static napi_value TestUtf16(napi_env env, napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + napi_create_string_utf16, + actual_length); +} + +static napi_value TestLatin1AutoLength(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + napi_create_string_latin1, + auto_length); +} + +static napi_value TestUtf8AutoLength(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_utf8, + napi_create_string_utf8, + auto_length); +} + +static napi_value TestUtf16AutoLength(napi_env env, napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + napi_create_string_utf16, + auto_length); +} + +static napi_value TestLatin1External(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + create_external_latin1, + actual_length); +} + +static napi_value TestUtf16External(napi_env env, napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + create_external_utf16, + actual_length); +} + +static napi_value TestLatin1ExternalAutoLength(napi_env env, + napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + create_external_latin1, + auto_length); +} + +static napi_value TestUtf16ExternalAutoLength(napi_env env, + napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + create_external_utf16, + auto_length); +} + +static napi_value TestLatin1Insufficient(napi_env env, + napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + char buffer[4]; + size_t buffer_size = 4; + size_t copied; + + NODE_API_CALL( + env, + napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied)); + + napi_value output; + NODE_API_CALL(env, napi_create_string_latin1(env, buffer, copied, &output)); + + return output; +} + +static napi_value TestUtf8Insufficient(napi_env env, napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + char buffer[4]; + size_t buffer_size = 4; + size_t copied; + + NODE_API_CALL( + env, + napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied)); + + napi_value output; + NODE_API_CALL(env, napi_create_string_utf8(env, buffer, copied, &output)); + + return output; +} + +static napi_value TestUtf16Insufficient(napi_env env, napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + char16_t buffer[4]; + size_t buffer_size = 4; + size_t copied; + + NODE_API_CALL( + env, + napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied)); + + napi_value output; + NODE_API_CALL(env, napi_create_string_utf16(env, buffer, copied, &output)); + + return output; +} + +static napi_value TestPropertyKeyLatin1(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + node_api_create_property_key_latin1, + actual_length); +} + +static napi_value TestPropertyKeyLatin1AutoLength(napi_env env, + napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_latin1, + node_api_create_property_key_latin1, + auto_length); +} + +static napi_value TestPropertyKeyUtf8(napi_env env, napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_utf8, + node_api_create_property_key_utf8, + actual_length); +} + +static napi_value TestPropertyKeyUtf8AutoLength(napi_env env, + napi_callback_info info) { + return TestOneByteImpl(env, + info, + napi_get_value_string_utf8, + node_api_create_property_key_utf8, + auto_length); +} + +static napi_value TestPropertyKeyUtf16(napi_env env, napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + node_api_create_property_key_utf16, + actual_length); +} + +static napi_value TestPropertyKeyUtf16AutoLength(napi_env env, + napi_callback_info info) { + return TestTwoByteImpl(env, + info, + napi_get_value_string_utf16, + node_api_create_property_key_utf16, + auto_length); +} + +static napi_value Latin1Length(napi_env env, napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + size_t length; + NODE_API_CALL(env, + napi_get_value_string_latin1(env, args[0], NULL, 0, &length)); + + napi_value output; + NODE_API_CALL(env, napi_create_uint32(env, (uint32_t)length, &output)); + + return output; +} + +static napi_value Utf16Length(napi_env env, napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + size_t length; + NODE_API_CALL(env, + napi_get_value_string_utf16(env, args[0], NULL, 0, &length)); + + napi_value output; + NODE_API_CALL(env, napi_create_uint32(env, (uint32_t)length, &output)); + + return output; +} + +static napi_value Utf8Length(napi_env env, napi_callback_info info) { + napi_value args[1]; + NODE_API_CALL(env, validate_and_retrieve_single_string_arg(env, info, args)); + + size_t length; + NODE_API_CALL(env, + napi_get_value_string_utf8(env, args[0], NULL, 0, &length)); + + napi_value output; + NODE_API_CALL(env, napi_create_uint32(env, (uint32_t)length, &output)); + + return output; +} + +static napi_value TestLargeUtf8(napi_env env, napi_callback_info info) { + napi_value output; + if (SIZE_MAX > INT_MAX) { + NODE_API_CALL( + env, napi_create_string_utf8(env, "", ((size_t)INT_MAX) + 1, &output)); + } else { + // just throw the expected error as there is nothing to test + // in this case since we can't overflow + NODE_API_CALL(env, napi_throw_error(env, NULL, "Invalid argument")); + } + + return output; +} + +static napi_value TestLargeLatin1(napi_env env, napi_callback_info info) { + napi_value output; + if (SIZE_MAX > INT_MAX) { + NODE_API_CALL( + env, + napi_create_string_latin1(env, "", ((size_t)INT_MAX) + 1, &output)); + } else { + // just throw the expected error as there is nothing to test + // in this case since we can't overflow + NODE_API_CALL(env, napi_throw_error(env, NULL, "Invalid argument")); + } + + return output; +} + +static napi_value TestLargeUtf16(napi_env env, napi_callback_info info) { + napi_value output; + if (SIZE_MAX > INT_MAX) { + NODE_API_CALL( + env, + napi_create_string_utf16( + env, ((const char16_t*)""), ((size_t)INT_MAX) + 1, &output)); + } else { + // just throw the expected error as there is nothing to test + // in this case since we can't overflow + NODE_API_CALL(env, napi_throw_error(env, NULL, "Invalid argument")); + } + + return output; +} + +static napi_value TestMemoryCorruption(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + char buf[10] = {0}; + NODE_API_CALL(env, napi_get_value_string_utf8(env, args[0], buf, 0, NULL)); + + char zero[10] = {0}; + if (memcmp(buf, zero, sizeof(buf)) != 0) { + NODE_API_CALL(env, napi_throw_error(env, NULL, "Buffer overwritten")); + } + + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("TestLatin1", TestLatin1), + DECLARE_NODE_API_PROPERTY("TestLatin1AutoLength", TestLatin1AutoLength), + DECLARE_NODE_API_PROPERTY("TestLatin1External", TestLatin1External), + DECLARE_NODE_API_PROPERTY("TestLatin1ExternalAutoLength", + TestLatin1ExternalAutoLength), + DECLARE_NODE_API_PROPERTY("TestLatin1Insufficient", + TestLatin1Insufficient), + DECLARE_NODE_API_PROPERTY("TestUtf8", TestUtf8), + DECLARE_NODE_API_PROPERTY("TestUtf8AutoLength", TestUtf8AutoLength), + DECLARE_NODE_API_PROPERTY("TestUtf8Insufficient", TestUtf8Insufficient), + DECLARE_NODE_API_PROPERTY("TestUtf16", TestUtf16), + DECLARE_NODE_API_PROPERTY("TestUtf16AutoLength", TestUtf16AutoLength), + DECLARE_NODE_API_PROPERTY("TestUtf16External", TestUtf16External), + DECLARE_NODE_API_PROPERTY("TestUtf16ExternalAutoLength", + TestUtf16ExternalAutoLength), + DECLARE_NODE_API_PROPERTY("TestUtf16Insufficient", TestUtf16Insufficient), + DECLARE_NODE_API_PROPERTY("Latin1Length", Latin1Length), + DECLARE_NODE_API_PROPERTY("Utf16Length", Utf16Length), + DECLARE_NODE_API_PROPERTY("Utf8Length", Utf8Length), + DECLARE_NODE_API_PROPERTY("TestLargeUtf8", TestLargeUtf8), + DECLARE_NODE_API_PROPERTY("TestLargeLatin1", TestLargeLatin1), + DECLARE_NODE_API_PROPERTY("TestLargeUtf16", TestLargeUtf16), + DECLARE_NODE_API_PROPERTY("TestMemoryCorruption", TestMemoryCorruption), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyLatin1", TestPropertyKeyLatin1), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyLatin1AutoLength", + TestPropertyKeyLatin1AutoLength), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyUtf8", TestPropertyKeyUtf8), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyUtf8AutoLength", + TestPropertyKeyUtf8AutoLength), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyUtf16", TestPropertyKeyUtf16), + DECLARE_NODE_API_PROPERTY("TestPropertyKeyUtf16AutoLength", + TestPropertyKeyUtf16AutoLength), + }; + + init_test_null(env, exports); + + NODE_API_CALL( + env, + napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_symbol/CMakeLists.txt new file mode 100644 index 00000000..7e937424 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_symbol + SOURCES + test_symbol.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/binding.gyp b/Tests/NodeApi/test/js-native-api/test_symbol/binding.gyp new file mode 100644 index 00000000..6a5a7cad --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_symbol", + "sources": [ + "test_symbol.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/test1.js b/Tests/NodeApi/test/js-native-api/test_symbol/test1.js new file mode 100644 index 00000000..3a28437a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/test1.js @@ -0,0 +1,19 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for symbol +const test_symbol = require(`./build/${common.buildType}/test_symbol`); + +const sym = test_symbol.New('test'); +assert.strictEqual(sym.toString(), 'Symbol(test)'); + +const myObj = {}; +const fooSym = test_symbol.New('foo'); +const otherSym = test_symbol.New('bar'); +myObj.foo = 'bar'; +myObj[fooSym] = 'baz'; +myObj[otherSym] = 'bing'; +assert.strictEqual(myObj.foo, 'bar'); +assert.strictEqual(myObj[fooSym], 'baz'); +assert.strictEqual(myObj[otherSym], 'bing'); diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/test2.js b/Tests/NodeApi/test/js-native-api/test_symbol/test2.js new file mode 100644 index 00000000..026f2c68 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/test2.js @@ -0,0 +1,17 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for symbol +const test_symbol = require(`./build/${common.buildType}/test_symbol`); + +const fooSym = test_symbol.New('foo'); +assert.strictEqual(fooSym.toString(), 'Symbol(foo)'); + +const myObj = {}; +myObj.foo = 'bar'; +myObj[fooSym] = 'baz'; + +assert.deepStrictEqual(Object.keys(myObj), ['foo']); +assert.deepStrictEqual(Object.getOwnPropertyNames(myObj), ['foo']); +assert.deepStrictEqual(Object.getOwnPropertySymbols(myObj), [fooSym]); diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/test3.js b/Tests/NodeApi/test/js-native-api/test_symbol/test3.js new file mode 100644 index 00000000..186c561e --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/test3.js @@ -0,0 +1,19 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for symbol +const test_symbol = require(`./build/${common.buildType}/test_symbol`); + +assert.notStrictEqual(test_symbol.New(), test_symbol.New()); +assert.notStrictEqual(test_symbol.New('foo'), test_symbol.New('foo')); +assert.notStrictEqual(test_symbol.New('foo'), test_symbol.New('bar')); + +const foo1 = test_symbol.New('foo'); +const foo2 = test_symbol.New('foo'); +const object = { + [foo1]: 1, + [foo2]: 2, +}; +assert.strictEqual(object[foo1], 1); +assert.strictEqual(object[foo2], 2); diff --git a/Tests/NodeApi/test/js-native-api/test_symbol/test_symbol.c b/Tests/NodeApi/test/js-native-api/test_symbol/test_symbol.c new file mode 100644 index 00000000..58fcb85a --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_symbol/test_symbol.c @@ -0,0 +1,38 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value New(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + napi_value description = NULL; + if (argc >= 1) { + napi_valuetype valuetype; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype)); + + NODE_API_ASSERT(env, valuetype == napi_string, + "Wrong type of arguments. Expects a string."); + + description = args[0]; + } + + napi_value symbol; + NODE_API_CALL(env, napi_create_symbol(env, description, &symbol)); + + return symbol; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("New", New), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/js-native-api/test_typedarray/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_typedarray/CMakeLists.txt new file mode 100644 index 00000000..093e92d0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_typedarray/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_typedarray + SOURCES + test_typedarray.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_typedarray/binding.gyp b/Tests/NodeApi/test/js-native-api/test_typedarray/binding.gyp new file mode 100644 index 00000000..a5ae5741 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_typedarray/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_typedarray", + "sources": [ + "test_typedarray.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_typedarray/test.js b/Tests/NodeApi/test/js-native-api/test_typedarray/test.js new file mode 100644 index 00000000..673bb5ce --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_typedarray/test.js @@ -0,0 +1,109 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); + +// Testing api calls for arrays +const test_typedarray = require(`./build/${common.buildType}/test_typedarray`); + +const byteArray = new Uint8Array(3); +byteArray[0] = 0; +byteArray[1] = 1; +byteArray[2] = 2; +assert.strictEqual(byteArray.length, 3); + +const doubleArray = new Float64Array(3); +doubleArray[0] = 0.0; +doubleArray[1] = 1.1; +doubleArray[2] = 2.2; +assert.strictEqual(doubleArray.length, 3); + +const byteResult = test_typedarray.Multiply(byteArray, 3); +assert.ok(byteResult instanceof Uint8Array); +assert.strictEqual(byteResult.length, 3); +assert.strictEqual(byteResult[0], 0); +assert.strictEqual(byteResult[1], 3); +assert.strictEqual(byteResult[2], 6); + +const doubleResult = test_typedarray.Multiply(doubleArray, -3); +assert.ok(doubleResult instanceof Float64Array); +assert.strictEqual(doubleResult.length, 3); +assert.strictEqual(doubleResult[0], -0); +assert.strictEqual(Math.round(10 * doubleResult[1]) / 10, -3.3); +assert.strictEqual(Math.round(10 * doubleResult[2]) / 10, -6.6); + +const externalResult = test_typedarray.External(); +assert.ok(externalResult instanceof Int8Array); +assert.strictEqual(externalResult.length, 3); +assert.strictEqual(externalResult[0], 0); +assert.strictEqual(externalResult[1], 1); +assert.strictEqual(externalResult[2], 2); + +// Validate creation of all kinds of TypedArrays +const buffer = new ArrayBuffer(128); +const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, + Uint16Array, Int32Array, Uint32Array, Float32Array, + Float64Array, BigInt64Array, BigUint64Array ]; + +arrayTypes.forEach((currentType) => { + const template = Reflect.construct(currentType, buffer); + const theArray = test_typedarray.CreateTypedArray(template, buffer); + + assert.ok(theArray instanceof currentType, + 'Type of new array should match that of the template. ' + + `Expected type: ${currentType.name}, ` + + `actual type: ${template.constructor.name}`); + assert.notStrictEqual(theArray, template); + assert.strictEqual(theArray.buffer, buffer); +}); + +arrayTypes.forEach((currentType) => { + const template = Reflect.construct(currentType, buffer); + assert.throws(() => { + test_typedarray.CreateTypedArray(template, buffer, 0, 136); + }, RangeError); +}); + +const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array, + Float32Array, Float64Array, + BigInt64Array, BigUint64Array ]; +nonByteArrayTypes.forEach((currentType) => { + const template = Reflect.construct(currentType, buffer); + assert.throws(() => { + test_typedarray.CreateTypedArray(template, buffer, + currentType.BYTES_PER_ELEMENT + 1, 1); + console.log(`start of offset ${currentType}`); + }, RangeError); +}); + +// Test detaching +arrayTypes.forEach((currentType) => { + const buffer = Reflect.construct(currentType, [8]); + assert.strictEqual(buffer.length, 8); + assert.ok(!test_typedarray.IsDetached(buffer.buffer)); + test_typedarray.Detach(buffer); + assert.ok(test_typedarray.IsDetached(buffer.buffer)); + assert.strictEqual(buffer.length, 0); +}); +{ + const buffer = test_typedarray.External(); + assert.ok(externalResult instanceof Int8Array); + assert.strictEqual(externalResult.length, 3); + assert.strictEqual(externalResult.byteLength, 3); + assert.ok(!test_typedarray.IsDetached(buffer.buffer)); + test_typedarray.Detach(buffer); + assert.ok(test_typedarray.IsDetached(buffer.buffer)); + assert.ok(externalResult instanceof Int8Array); + assert.strictEqual(buffer.length, 0); + assert.strictEqual(buffer.byteLength, 0); +} + +{ + const buffer = new ArrayBuffer(128); + assert.ok(!test_typedarray.IsDetached(buffer)); +} + +{ + const buffer = test_typedarray.NullArrayBuffer(); + assert.ok(buffer instanceof ArrayBuffer); + assert.ok(test_typedarray.IsDetached(buffer)); +} diff --git a/Tests/NodeApi/test/js-native-api/test_typedarray/test_typedarray.c b/Tests/NodeApi/test/js-native-api/test_typedarray/test_typedarray.c new file mode 100644 index 00000000..8aac9b52 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_typedarray/test_typedarray.c @@ -0,0 +1,249 @@ +#include +#include +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value Multiply(napi_env env, napi_callback_info info) { + size_t argc = 2; + napi_value args[2]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 2, "Wrong number of arguments"); + + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects a typed array as first argument."); + + napi_value input_array = args[0]; + bool is_typedarray; + NODE_API_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray)); + + NODE_API_ASSERT(env, is_typedarray, + "Wrong type of arguments. Expects a typed array as first argument."); + + napi_valuetype valuetype1; + NODE_API_CALL(env, napi_typeof(env, args[1], &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_number, + "Wrong type of arguments. Expects a number as second argument."); + + double multiplier; + NODE_API_CALL(env, napi_get_value_double(env, args[1], &multiplier)); + + napi_typedarray_type type; + napi_value input_buffer; + size_t byte_offset; + size_t i, length; + NODE_API_CALL(env, napi_get_typedarray_info( + env, input_array, &type, &length, NULL, &input_buffer, &byte_offset)); + + void* data; + size_t byte_length; + NODE_API_CALL(env, napi_get_arraybuffer_info( + env, input_buffer, &data, &byte_length)); + + napi_value output_buffer; + void* output_ptr = NULL; + NODE_API_CALL(env, napi_create_arraybuffer( + env, byte_length, &output_ptr, &output_buffer)); + + napi_value output_array; + NODE_API_CALL(env, napi_create_typedarray( + env, type, length, output_buffer, byte_offset, &output_array)); + + if (type == napi_uint8_array) { + uint8_t* input_bytes = (uint8_t*)(data) + byte_offset; + uint8_t* output_bytes = (uint8_t*)(output_ptr); + for (i = 0; i < length; i++) { + output_bytes[i] = (uint8_t)(input_bytes[i] * multiplier); + } + } else if (type == napi_float64_array) { + double* input_doubles = (double*)((uint8_t*)(data) + byte_offset); + double* output_doubles = (double*)(output_ptr); + for (i = 0; i < length; i++) { + output_doubles[i] = input_doubles[i] * multiplier; + } + } else { + napi_throw_error(env, NULL, + "Typed array was of a type not expected by test."); + return NULL; + } + + return output_array; +} + +static void FinalizeCallback(node_api_basic_env env, + void* finalize_data, + void* finalize_hint) +{ + free(finalize_data); +} + +static napi_value External(napi_env env, napi_callback_info info) { + const uint8_t nElem = 3; + int8_t* externalData = malloc(nElem*sizeof(int8_t)); + externalData[0] = 0; + externalData[1] = 1; + externalData[2] = 2; + + napi_value output_buffer; + NODE_API_CALL(env, napi_create_external_arraybuffer( + env, + externalData, + nElem*sizeof(int8_t), + FinalizeCallback, + NULL, // finalize_hint + &output_buffer)); + + napi_value output_array; + NODE_API_CALL(env, napi_create_typedarray(env, + napi_int8_array, + nElem, + output_buffer, + 0, + &output_array)); + + return output_array; +} + + +static napi_value NullArrayBuffer(napi_env env, napi_callback_info info) { + static void* data = NULL; + napi_value arraybuffer; + NODE_API_CALL(env, + napi_create_external_arraybuffer(env, data, 0, NULL, NULL, &arraybuffer)); + return arraybuffer; +} + +static napi_value CreateTypedArray(napi_env env, napi_callback_info info) { + size_t argc = 4; + napi_value args[4]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 2 || argc == 4, "Wrong number of arguments"); + + napi_value input_array = args[0]; + napi_valuetype valuetype0; + NODE_API_CALL(env, napi_typeof(env, input_array, &valuetype0)); + + NODE_API_ASSERT(env, valuetype0 == napi_object, + "Wrong type of arguments. Expects a typed array as first argument."); + + bool is_typedarray; + NODE_API_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray)); + + NODE_API_ASSERT(env, is_typedarray, + "Wrong type of arguments. Expects a typed array as first argument."); + + napi_valuetype valuetype1; + napi_value input_buffer = args[1]; + NODE_API_CALL(env, napi_typeof(env, input_buffer, &valuetype1)); + + NODE_API_ASSERT(env, valuetype1 == napi_object, + "Wrong type of arguments. Expects an array buffer as second argument."); + + bool is_arraybuffer; + NODE_API_CALL(env, napi_is_arraybuffer(env, input_buffer, &is_arraybuffer)); + + NODE_API_ASSERT(env, is_arraybuffer, + "Wrong type of arguments. Expects an array buffer as second argument."); + + napi_typedarray_type type; + napi_value in_array_buffer; + size_t byte_offset; + size_t length; + NODE_API_CALL(env, napi_get_typedarray_info( + env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset)); + + if (argc == 4) { + napi_valuetype valuetype2; + NODE_API_CALL(env, napi_typeof(env, args[2], &valuetype2)); + + NODE_API_ASSERT(env, valuetype2 == napi_number, + "Wrong type of arguments. Expects a number as third argument."); + + uint32_t uint32_length; + NODE_API_CALL(env, napi_get_value_uint32(env, args[2], &uint32_length)); + length = uint32_length; + + napi_valuetype valuetype3; + NODE_API_CALL(env, napi_typeof(env, args[3], &valuetype3)); + + NODE_API_ASSERT(env, valuetype3 == napi_number, + "Wrong type of arguments. Expects a number as third argument."); + + uint32_t uint32_byte_offset; + NODE_API_CALL(env, napi_get_value_uint32(env, args[3], &uint32_byte_offset)); + byte_offset = uint32_byte_offset; + } + + napi_value output_array; + NODE_API_CALL(env, napi_create_typedarray( + env, type, length, input_buffer, byte_offset, &output_array)); + + return output_array; +} + +static napi_value Detach(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments."); + + bool is_typedarray; + NODE_API_CALL(env, napi_is_typedarray(env, args[0], &is_typedarray)); + NODE_API_ASSERT( + env, is_typedarray, + "Wrong type of arguments. Expects a typedarray as first argument."); + + napi_value arraybuffer; + NODE_API_CALL(env, + napi_get_typedarray_info( + env, args[0], NULL, NULL, NULL, &arraybuffer, NULL)); + NODE_API_CALL(env, napi_detach_arraybuffer(env, arraybuffer)); + + return NULL; +} + +static napi_value IsDetached(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments."); + + napi_value array_buffer = args[0]; + bool is_arraybuffer; + NODE_API_CALL(env, napi_is_arraybuffer(env, array_buffer, &is_arraybuffer)); + NODE_API_ASSERT(env, is_arraybuffer, + "Wrong type of arguments. Expects an array buffer as first argument."); + + bool is_detached; + NODE_API_CALL(env, + napi_is_detached_arraybuffer(env, array_buffer, &is_detached)); + + napi_value result; + NODE_API_CALL(env, napi_get_boolean(env, is_detached, &result)); + + return result; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("Multiply", Multiply), + DECLARE_NODE_API_PROPERTY("External", External), + DECLARE_NODE_API_PROPERTY("NullArrayBuffer", NullArrayBuffer), + DECLARE_NODE_API_PROPERTY("CreateTypedArray", CreateTypedArray), + DECLARE_NODE_API_PROPERTY("Detach", Detach), + DECLARE_NODE_API_PROPERTY("IsDetached", IsDetached), + }; + + NODE_API_CALL(env, napi_define_properties( + env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/NodeApi/test/package.json b/Tests/NodeApi/test/package.json new file mode 100644 index 00000000..21023796 --- /dev/null +++ b/Tests/NodeApi/test/package.json @@ -0,0 +1,14 @@ +{ + "name": "hermes-node-api-test-packages", + "private": true, + "scripts": { + "postinstall": "tar -c -f node_modules.tar node_modules & npx hasha -a sha1 node_modules.tar > node_modules.sha1" + }, + "devDependencies": { + "@babel/cli": "^7.28.0", + "@babel/core": "^7.28.0", + "@babel/runtime": "^7.28.2", + "@react-native/babel-preset": "^0.80.2", + "hasha-cli": "^6.0.0" + } +} diff --git a/Tests/NodeApi/test/yarn.lock b/Tests/NodeApi/test/yarn.lock new file mode 100644 index 00000000..b5fb0864 --- /dev/null +++ b/Tests/NodeApi/test/yarn.lock @@ -0,0 +1,1326 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@ampproject/remapping@^2.2.0": + version "2.3.0" + resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.3.0.tgz#ed441b6fa600072520ce18b43d2c8cc8caecc7f4" + integrity sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw== + dependencies: + "@jridgewell/gen-mapping" "^0.3.5" + "@jridgewell/trace-mapping" "^0.3.24" + +"@babel/cli@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/cli/-/cli-7.28.0.tgz#26959456cbedff569a2c3ac909e8a268ca6cb7e2" + integrity sha512-CYrZG7FagtE8ReKDBfItxnrEBf2khq2eTMnPuqO8UVN0wzhp1eMX1wfda8b1a32l2aqYLwRRIOGNovm8FVzmMw== + dependencies: + "@jridgewell/trace-mapping" "^0.3.28" + commander "^6.2.0" + convert-source-map "^2.0.0" + fs-readdir-recursive "^1.1.0" + glob "^7.2.0" + make-dir "^2.1.0" + slash "^2.0.0" + optionalDependencies: + "@nicolo-ribaudo/chokidar-2" "2.1.8-no-fsevents.3" + chokidar "^3.6.0" + +"@babel/code-frame@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be" + integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg== + dependencies: + "@babel/helper-validator-identifier" "^7.27.1" + js-tokens "^4.0.0" + picocolors "^1.1.1" + +"@babel/compat-data@^7.27.2", "@babel/compat-data@^7.27.7": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.28.0.tgz#9fc6fd58c2a6a15243cd13983224968392070790" + integrity sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw== + +"@babel/core@^7.25.2", "@babel/core@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.28.0.tgz#55dad808d5bf3445a108eefc88ea3fdf034749a4" + integrity sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ== + dependencies: + "@ampproject/remapping" "^2.2.0" + "@babel/code-frame" "^7.27.1" + "@babel/generator" "^7.28.0" + "@babel/helper-compilation-targets" "^7.27.2" + "@babel/helper-module-transforms" "^7.27.3" + "@babel/helpers" "^7.27.6" + "@babel/parser" "^7.28.0" + "@babel/template" "^7.27.2" + "@babel/traverse" "^7.28.0" + "@babel/types" "^7.28.0" + convert-source-map "^2.0.0" + debug "^4.1.0" + gensync "^1.0.0-beta.2" + json5 "^2.2.3" + semver "^6.3.1" + +"@babel/generator@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.28.0.tgz#9cc2f7bd6eb054d77dc66c2664148a0c5118acd2" + integrity sha512-lJjzvrbEeWrhB4P3QBsH7tey117PjLZnDbLiQEKjQ/fNJTjuq4HSqgFA+UNSwZT8D7dxxbnuSBMsa1lrWzKlQg== + dependencies: + "@babel/parser" "^7.28.0" + "@babel/types" "^7.28.0" + "@jridgewell/gen-mapping" "^0.3.12" + "@jridgewell/trace-mapping" "^0.3.28" + jsesc "^3.0.2" + +"@babel/helper-annotate-as-pure@^7.27.1", "@babel/helper-annotate-as-pure@^7.27.3": + version "7.27.3" + resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz#f31fd86b915fc4daf1f3ac6976c59be7084ed9c5" + integrity sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg== + dependencies: + "@babel/types" "^7.27.3" + +"@babel/helper-compilation-targets@^7.27.1", "@babel/helper-compilation-targets@^7.27.2": + version "7.27.2" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz#46a0f6efab808d51d29ce96858dd10ce8732733d" + integrity sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ== + dependencies: + "@babel/compat-data" "^7.27.2" + "@babel/helper-validator-option" "^7.27.1" + browserslist "^4.24.0" + lru-cache "^5.1.1" + semver "^6.3.1" + +"@babel/helper-create-class-features-plugin@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.27.1.tgz#5bee4262a6ea5ddc852d0806199eb17ca3de9281" + integrity sha512-QwGAmuvM17btKU5VqXfb+Giw4JcN0hjuufz3DYnpeVDvZLAObloM77bhMXiqry3Iio+Ai4phVRDwl6WU10+r5A== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.1" + "@babel/helper-member-expression-to-functions" "^7.27.1" + "@babel/helper-optimise-call-expression" "^7.27.1" + "@babel/helper-replace-supers" "^7.27.1" + "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1" + "@babel/traverse" "^7.27.1" + semver "^6.3.1" + +"@babel/helper-create-regexp-features-plugin@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.27.1.tgz#05b0882d97ba1d4d03519e4bce615d70afa18c53" + integrity sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.1" + regexpu-core "^6.2.0" + semver "^6.3.1" + +"@babel/helper-define-polyfill-provider@^0.6.5": + version "0.6.5" + resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.5.tgz#742ccf1cb003c07b48859fc9fa2c1bbe40e5f753" + integrity sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg== + dependencies: + "@babel/helper-compilation-targets" "^7.27.2" + "@babel/helper-plugin-utils" "^7.27.1" + debug "^4.4.1" + lodash.debounce "^4.0.8" + resolve "^1.22.10" + +"@babel/helper-globals@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz#b9430df2aa4e17bc28665eadeae8aa1d985e6674" + integrity sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw== + +"@babel/helper-member-expression-to-functions@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.27.1.tgz#ea1211276be93e798ce19037da6f06fbb994fa44" + integrity sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA== + dependencies: + "@babel/traverse" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/helper-module-imports@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz#7ef769a323e2655e126673bb6d2d6913bbead204" + integrity sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w== + dependencies: + "@babel/traverse" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/helper-module-transforms@^7.27.1", "@babel/helper-module-transforms@^7.27.3": + version "7.27.3" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.27.3.tgz#db0bbcfba5802f9ef7870705a7ef8788508ede02" + integrity sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg== + dependencies: + "@babel/helper-module-imports" "^7.27.1" + "@babel/helper-validator-identifier" "^7.27.1" + "@babel/traverse" "^7.27.3" + +"@babel/helper-optimise-call-expression@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz#c65221b61a643f3e62705e5dd2b5f115e35f9200" + integrity sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw== + dependencies: + "@babel/types" "^7.27.1" + +"@babel/helper-plugin-utils@^7.27.1", "@babel/helper-plugin-utils@^7.8.0": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz#ddb2f876534ff8013e6c2b299bf4d39b3c51d44c" + integrity sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw== + +"@babel/helper-remap-async-to-generator@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz#4601d5c7ce2eb2aea58328d43725523fcd362ce6" + integrity sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.1" + "@babel/helper-wrap-function" "^7.27.1" + "@babel/traverse" "^7.27.1" + +"@babel/helper-replace-supers@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz#b1ed2d634ce3bdb730e4b52de30f8cccfd692bc0" + integrity sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA== + dependencies: + "@babel/helper-member-expression-to-functions" "^7.27.1" + "@babel/helper-optimise-call-expression" "^7.27.1" + "@babel/traverse" "^7.27.1" + +"@babel/helper-skip-transparent-expression-wrappers@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz#62bb91b3abba8c7f1fec0252d9dbea11b3ee7a56" + integrity sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg== + dependencies: + "@babel/traverse" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/helper-string-parser@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz#54da796097ab19ce67ed9f88b47bb2ec49367687" + integrity sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA== + +"@babel/helper-validator-identifier@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz#a7054dcc145a967dd4dc8fee845a57c1316c9df8" + integrity sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow== + +"@babel/helper-validator-option@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz#fa52f5b1e7db1ab049445b421c4471303897702f" + integrity sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg== + +"@babel/helper-wrap-function@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.27.1.tgz#b88285009c31427af318d4fe37651cd62a142409" + integrity sha512-NFJK2sHUvrjo8wAU/nQTWU890/zB2jj0qBcCbZbbf+005cAsv6tMjXz31fBign6M5ov1o0Bllu+9nbqkfsjjJQ== + dependencies: + "@babel/template" "^7.27.1" + "@babel/traverse" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/helpers@^7.27.6": + version "7.28.2" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.28.2.tgz#80f0918fecbfebea9af856c419763230040ee850" + integrity sha512-/V9771t+EgXz62aCcyofnQhGM8DQACbRhvzKFsXKC9QM+5MadF8ZmIm0crDMaz3+o0h0zXfJnd4EhbYbxsrcFw== + dependencies: + "@babel/template" "^7.27.2" + "@babel/types" "^7.28.2" + +"@babel/parser@^7.27.2", "@babel/parser@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.28.0.tgz#979829fbab51a29e13901e5a80713dbcb840825e" + integrity sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g== + dependencies: + "@babel/types" "^7.28.0" + +"@babel/plugin-proposal-export-default-from@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-default-from/-/plugin-proposal-export-default-from-7.27.1.tgz#59b050b0e5fdc366162ab01af4fcbac06ea40919" + integrity sha512-hjlsMBl1aJc5lp8MoCDEZCiYzlgdRAShOjAfRw6X+GlpLpUPU7c3XNLsKFZbQk/1cRzBlJ7CXg3xJAJMrFa1Uw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-syntax-dynamic-import@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3" + integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-export-default-from@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-export-default-from/-/plugin-syntax-export-default-from-7.27.1.tgz#8efed172e79ab657c7fa4d599224798212fb7e18" + integrity sha512-eBC/3KSekshx19+N40MzjWqJd7KTEdOoLesAfa4IDFI8eRz5a47i5Oszus6zG/cwIXN63YhgLOMSSNJx49sENg== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-syntax-flow@^7.12.1", "@babel/plugin-syntax-flow@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.27.1.tgz#6c83cf0d7d635b716827284b7ecd5aead9237662" + integrity sha512-p9OkPbZ5G7UT1MofwYFigGebnrzGJacoBSQM0/6bi/PUMVE+qlWDD/OalvQKbwgQzU6dl0xAv6r4X7Jme0RYxA== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-syntax-jsx@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz#2f9beb5eff30fa507c5532d107daac7b888fa34c" + integrity sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9" + integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-optional-chaining@^7.8.3": + version "7.8.3" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a" + integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-typescript@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz#5147d29066a793450f220c63fa3a9431b7e6dd18" + integrity sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-arrow-functions@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz#6e2061067ba3ab0266d834a9f94811196f2aba9a" + integrity sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-async-generator-functions@^7.25.4": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.28.0.tgz#1276e6c7285ab2cd1eccb0bc7356b7a69ff842c2" + integrity sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-remap-async-to-generator" "^7.27.1" + "@babel/traverse" "^7.28.0" + +"@babel/plugin-transform-async-to-generator@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.27.1.tgz#9a93893b9379b39466c74474f55af03de78c66e7" + integrity sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA== + dependencies: + "@babel/helper-module-imports" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-remap-async-to-generator" "^7.27.1" + +"@babel/plugin-transform-block-scoping@^7.25.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.0.tgz#e7c50cbacc18034f210b93defa89638666099451" + integrity sha512-gKKnwjpdx5sER/wl0WN0efUBFzF/56YZO0RJrSYP4CljXnP31ByY7fol89AzomdlLNzI36AvOTmYHsnZTCkq8Q== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-class-properties@^7.25.4": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.27.1.tgz#dd40a6a370dfd49d32362ae206ddaf2bb082a925" + integrity sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA== + dependencies: + "@babel/helper-create-class-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-classes@^7.25.4": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.0.tgz#12fa46cffc32a6e084011b650539e880add8a0f8" + integrity sha512-IjM1IoJNw72AZFlj33Cu8X0q2XK/6AaVC3jQu+cgQ5lThWD5ajnuUAml80dqRmOhmPkTH8uAwnpMu9Rvj0LTRA== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.3" + "@babel/helper-compilation-targets" "^7.27.2" + "@babel/helper-globals" "^7.28.0" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-replace-supers" "^7.27.1" + "@babel/traverse" "^7.28.0" + +"@babel/plugin-transform-computed-properties@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.27.1.tgz#81662e78bf5e734a97982c2b7f0a793288ef3caa" + integrity sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/template" "^7.27.1" + +"@babel/plugin-transform-destructuring@^7.24.8", "@babel/plugin-transform-destructuring@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.0.tgz#0f156588f69c596089b7d5b06f5af83d9aa7f97a" + integrity sha512-v1nrSMBiKcodhsyJ4Gf+Z0U/yawmJDBOTpEB3mcQY52r9RIyPneGyAS/yM6seP/8I+mWI3elOMtT5dB8GJVs+A== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/traverse" "^7.28.0" + +"@babel/plugin-transform-flow-strip-types@^7.25.2": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.27.1.tgz#5def3e1e7730f008d683144fb79b724f92c5cdf9" + integrity sha512-G5eDKsu50udECw7DL2AcsysXiQyB7Nfg521t2OAJ4tbfTJ27doHLeF/vlI1NZGlLdbb/v+ibvtL1YBQqYOwJGg== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/plugin-syntax-flow" "^7.27.1" + +"@babel/plugin-transform-for-of@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz#bc24f7080e9ff721b63a70ac7b2564ca15b6c40a" + integrity sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1" + +"@babel/plugin-transform-function-name@^7.25.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz#4d0bf307720e4dce6d7c30fcb1fd6ca77bdeb3a7" + integrity sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ== + dependencies: + "@babel/helper-compilation-targets" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/traverse" "^7.27.1" + +"@babel/plugin-transform-literals@^7.25.2": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz#baaefa4d10a1d4206f9dcdda50d7d5827bb70b24" + integrity sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-logical-assignment-operators@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.27.1.tgz#890cb20e0270e0e5bebe3f025b434841c32d5baa" + integrity sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-modules-commonjs@^7.24.8": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz#8e44ed37c2787ecc23bdc367f49977476614e832" + integrity sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw== + dependencies: + "@babel/helper-module-transforms" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-named-capturing-groups-regex@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.27.1.tgz#f32b8f7818d8fc0cc46ee20a8ef75f071af976e1" + integrity sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng== + dependencies: + "@babel/helper-create-regexp-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-nullish-coalescing-operator@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.27.1.tgz#4f9d3153bf6782d73dd42785a9d22d03197bc91d" + integrity sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-numeric-separator@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.27.1.tgz#614e0b15cc800e5997dadd9bd6ea524ed6c819c6" + integrity sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-object-rest-spread@^7.24.7": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.0.tgz#d23021857ffd7cd809f54d624299b8086402ed8d" + integrity sha512-9VNGikXxzu5eCiQjdE4IZn8sb9q7Xsk5EXLDBKUYg1e/Tve8/05+KJEtcxGxAgCY5t/BpKQM+JEL/yT4tvgiUA== + dependencies: + "@babel/helper-compilation-targets" "^7.27.2" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/plugin-transform-destructuring" "^7.28.0" + "@babel/plugin-transform-parameters" "^7.27.7" + "@babel/traverse" "^7.28.0" + +"@babel/plugin-transform-optional-catch-binding@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.27.1.tgz#84c7341ebde35ccd36b137e9e45866825072a30c" + integrity sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-optional-chaining@^7.24.8": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.27.1.tgz#874ce3c4f06b7780592e946026eb76a32830454f" + integrity sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1" + +"@babel/plugin-transform-parameters@^7.24.7", "@babel/plugin-transform-parameters@^7.27.7": + version "7.27.7" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz#1fd2febb7c74e7d21cf3b05f7aebc907940af53a" + integrity sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-private-methods@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.27.1.tgz#fdacbab1c5ed81ec70dfdbb8b213d65da148b6af" + integrity sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA== + dependencies: + "@babel/helper-create-class-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-private-property-in-object@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.27.1.tgz#4dbbef283b5b2f01a21e81e299f76e35f900fb11" + integrity sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.1" + "@babel/helper-create-class-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-react-display-name@^7.24.7": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz#6f20a7295fea7df42eb42fed8f896813f5b934de" + integrity sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-react-jsx-self@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz#af678d8506acf52c577cac73ff7fe6615c85fc92" + integrity sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-react-jsx-source@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz#dcfe2c24094bb757bf73960374e7c55e434f19f0" + integrity sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-react-jsx@^7.25.2": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz#1023bc94b78b0a2d68c82b5e96aed573bcfb9db0" + integrity sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.1" + "@babel/helper-module-imports" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/plugin-syntax-jsx" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/plugin-transform-regenerator@^7.24.7": + version "7.28.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.28.1.tgz#bde80603442ff4bb4e910bc8b35485295d556ab1" + integrity sha512-P0QiV/taaa3kXpLY+sXla5zec4E+4t4Aqc9ggHlfZ7a2cp8/x/Gv08jfwEtn9gnnYIMvHx6aoOZ8XJL8eU71Dg== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-runtime@^7.24.7": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.28.0.tgz#462e79008cc7bdac03e4c5e1765b9de2bcd31c21" + integrity sha512-dGopk9nZrtCs2+nfIem25UuHyt5moSJamArzIoh9/vezUQPmYDOzjaHDCkAzuGJibCIkPup8rMT2+wYB6S73cA== + dependencies: + "@babel/helper-module-imports" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + babel-plugin-polyfill-corejs2 "^0.4.14" + babel-plugin-polyfill-corejs3 "^0.13.0" + babel-plugin-polyfill-regenerator "^0.6.5" + semver "^6.3.1" + +"@babel/plugin-transform-shorthand-properties@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz#532abdacdec87bfee1e0ef8e2fcdee543fe32b90" + integrity sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-spread@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.27.1.tgz#1a264d5fc12750918f50e3fe3e24e437178abb08" + integrity sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1" + +"@babel/plugin-transform-sticky-regex@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz#18984935d9d2296843a491d78a014939f7dcd280" + integrity sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g== + dependencies: + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/plugin-transform-typescript@^7.25.2": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.0.tgz#796cbd249ab56c18168b49e3e1d341b72af04a6b" + integrity sha512-4AEiDEBPIZvLQaWlc9liCavE0xRM0dNca41WtBeM3jgFptfUOSG9z0uteLhq6+3rq+WB6jIvUwKDTpXEHPJ2Vg== + dependencies: + "@babel/helper-annotate-as-pure" "^7.27.3" + "@babel/helper-create-class-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1" + "@babel/plugin-syntax-typescript" "^7.27.1" + +"@babel/plugin-transform-unicode-regex@^7.24.7": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz#25948f5c395db15f609028e370667ed8bae9af97" + integrity sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw== + dependencies: + "@babel/helper-create-regexp-features-plugin" "^7.27.1" + "@babel/helper-plugin-utils" "^7.27.1" + +"@babel/runtime@^7.28.2": + version "7.28.2" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.28.2.tgz#2ae5a9d51cc583bd1f5673b3bb70d6d819682473" + integrity sha512-KHp2IflsnGywDjBWDkR9iEqiWSpc8GIi0lgTT3mOElT0PP1tG26P4tmFI2YvAdzgq9RGyoHZQEIEdZy6Ec5xCA== + +"@babel/template@^7.25.0", "@babel/template@^7.27.1", "@babel/template@^7.27.2": + version "7.27.2" + resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.27.2.tgz#fa78ceed3c4e7b63ebf6cb39e5852fca45f6809d" + integrity sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw== + dependencies: + "@babel/code-frame" "^7.27.1" + "@babel/parser" "^7.27.2" + "@babel/types" "^7.27.1" + +"@babel/traverse@^7.25.3", "@babel/traverse@^7.27.1", "@babel/traverse@^7.27.3", "@babel/traverse@^7.28.0": + version "7.28.0" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.28.0.tgz#518aa113359b062042379e333db18380b537e34b" + integrity sha512-mGe7UK5wWyh0bKRfupsUchrQGqvDbZDbKJw+kcRGSmdHVYrv+ltd0pnpDTVpiTqnaBru9iEvA8pz8W46v0Amwg== + dependencies: + "@babel/code-frame" "^7.27.1" + "@babel/generator" "^7.28.0" + "@babel/helper-globals" "^7.28.0" + "@babel/parser" "^7.28.0" + "@babel/template" "^7.27.2" + "@babel/types" "^7.28.0" + debug "^4.3.1" + +"@babel/types@^7.27.1", "@babel/types@^7.27.3", "@babel/types@^7.28.0", "@babel/types@^7.28.2": + version "7.28.2" + resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.28.2.tgz#da9db0856a9a88e0a13b019881d7513588cf712b" + integrity sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ== + dependencies: + "@babel/helper-string-parser" "^7.27.1" + "@babel/helper-validator-identifier" "^7.27.1" + +"@jridgewell/gen-mapping@^0.3.12", "@jridgewell/gen-mapping@^0.3.5": + version "0.3.12" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.12.tgz#2234ce26c62889f03db3d7fea43c1932ab3e927b" + integrity sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg== + dependencies: + "@jridgewell/sourcemap-codec" "^1.5.0" + "@jridgewell/trace-mapping" "^0.3.24" + +"@jridgewell/resolve-uri@^3.1.0": + version "3.1.2" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6" + integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== + +"@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.5.0": + version "1.5.4" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.4.tgz#7358043433b2e5da569aa02cbc4c121da3af27d7" + integrity sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw== + +"@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.28": + version "0.3.29" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.29.tgz#a58d31eaadaf92c6695680b2e1d464a9b8fbf7fc" + integrity sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ== + dependencies: + "@jridgewell/resolve-uri" "^3.1.0" + "@jridgewell/sourcemap-codec" "^1.4.14" + +"@nicolo-ribaudo/chokidar-2@2.1.8-no-fsevents.3": + version "2.1.8-no-fsevents.3" + resolved "https://registry.yarnpkg.com/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.3.tgz#323d72dd25103d0c4fbdce89dadf574a787b1f9b" + integrity sha512-s88O1aVtXftvp5bCPB7WnmXc5IwOZZ7YPuwNPt+GtOOXpPvad1LfbmjYv+qII7zP6RU2QGnqve27dnLycEnyEQ== + +"@react-native/babel-plugin-codegen@0.80.2": + version "0.80.2" + resolved "https://registry.yarnpkg.com/@react-native/babel-plugin-codegen/-/babel-plugin-codegen-0.80.2.tgz#14964a7c7058e25df60b41b4dd6b8a3714a33440" + integrity sha512-q0XzdrdDebPwt5tEi2MSo90kpEcs4e3ZZskrbxda081DEjHhgm3bbIxAiW3BxY6adOf/eXxgOhKEGWTfG2me6g== + dependencies: + "@babel/traverse" "^7.25.3" + "@react-native/codegen" "0.80.2" + +"@react-native/babel-preset@^0.80.2": + version "0.80.2" + resolved "https://registry.yarnpkg.com/@react-native/babel-preset/-/babel-preset-0.80.2.tgz#8c5ba82a37c044c22cf92e613eb8be01310782e5" + integrity sha512-vLtS8YJV0nAnOZ8kVJBaXzHlwvoMXpYB4/NBR1BuAesE+WTiAkXpDFnKSkXBHoS03d/5HYNVcW8VRaB2f0Jmtw== + dependencies: + "@babel/core" "^7.25.2" + "@babel/plugin-proposal-export-default-from" "^7.24.7" + "@babel/plugin-syntax-dynamic-import" "^7.8.3" + "@babel/plugin-syntax-export-default-from" "^7.24.7" + "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3" + "@babel/plugin-syntax-optional-chaining" "^7.8.3" + "@babel/plugin-transform-arrow-functions" "^7.24.7" + "@babel/plugin-transform-async-generator-functions" "^7.25.4" + "@babel/plugin-transform-async-to-generator" "^7.24.7" + "@babel/plugin-transform-block-scoping" "^7.25.0" + "@babel/plugin-transform-class-properties" "^7.25.4" + "@babel/plugin-transform-classes" "^7.25.4" + "@babel/plugin-transform-computed-properties" "^7.24.7" + "@babel/plugin-transform-destructuring" "^7.24.8" + "@babel/plugin-transform-flow-strip-types" "^7.25.2" + "@babel/plugin-transform-for-of" "^7.24.7" + "@babel/plugin-transform-function-name" "^7.25.1" + "@babel/plugin-transform-literals" "^7.25.2" + "@babel/plugin-transform-logical-assignment-operators" "^7.24.7" + "@babel/plugin-transform-modules-commonjs" "^7.24.8" + "@babel/plugin-transform-named-capturing-groups-regex" "^7.24.7" + "@babel/plugin-transform-nullish-coalescing-operator" "^7.24.7" + "@babel/plugin-transform-numeric-separator" "^7.24.7" + "@babel/plugin-transform-object-rest-spread" "^7.24.7" + "@babel/plugin-transform-optional-catch-binding" "^7.24.7" + "@babel/plugin-transform-optional-chaining" "^7.24.8" + "@babel/plugin-transform-parameters" "^7.24.7" + "@babel/plugin-transform-private-methods" "^7.24.7" + "@babel/plugin-transform-private-property-in-object" "^7.24.7" + "@babel/plugin-transform-react-display-name" "^7.24.7" + "@babel/plugin-transform-react-jsx" "^7.25.2" + "@babel/plugin-transform-react-jsx-self" "^7.24.7" + "@babel/plugin-transform-react-jsx-source" "^7.24.7" + "@babel/plugin-transform-regenerator" "^7.24.7" + "@babel/plugin-transform-runtime" "^7.24.7" + "@babel/plugin-transform-shorthand-properties" "^7.24.7" + "@babel/plugin-transform-spread" "^7.24.7" + "@babel/plugin-transform-sticky-regex" "^7.24.7" + "@babel/plugin-transform-typescript" "^7.25.2" + "@babel/plugin-transform-unicode-regex" "^7.24.7" + "@babel/template" "^7.25.0" + "@react-native/babel-plugin-codegen" "0.80.2" + babel-plugin-syntax-hermes-parser "0.28.1" + babel-plugin-transform-flow-enums "^0.0.2" + react-refresh "^0.14.0" + +"@react-native/codegen@0.80.2": + version "0.80.2" + resolved "https://registry.yarnpkg.com/@react-native/codegen/-/codegen-0.80.2.tgz#2e5dc975400d41b84c7393d73cfe32f47b12d82e" + integrity sha512-eYad9ex9/RS6oFbbpu6LxsczktbhfJbJlTvtRlcWLJjJbFTeNr5Q7CgBT2/m5VtpxnJ/0YdmZ9vdazsJ2yp9kw== + dependencies: + glob "^7.1.1" + hermes-parser "0.28.1" + invariant "^2.2.4" + nullthrows "^1.1.1" + yargs "^17.6.2" + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-styles@^4.0.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +babel-plugin-polyfill-corejs2@^0.4.14: + version "0.4.14" + resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.14.tgz#8101b82b769c568835611542488d463395c2ef8f" + integrity sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg== + dependencies: + "@babel/compat-data" "^7.27.7" + "@babel/helper-define-polyfill-provider" "^0.6.5" + semver "^6.3.1" + +babel-plugin-polyfill-corejs3@^0.13.0: + version "0.13.0" + resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz#bb7f6aeef7addff17f7602a08a6d19a128c30164" + integrity sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A== + dependencies: + "@babel/helper-define-polyfill-provider" "^0.6.5" + core-js-compat "^3.43.0" + +babel-plugin-polyfill-regenerator@^0.6.5: + version "0.6.5" + resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.5.tgz#32752e38ab6f6767b92650347bf26a31b16ae8c5" + integrity sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg== + dependencies: + "@babel/helper-define-polyfill-provider" "^0.6.5" + +babel-plugin-syntax-hermes-parser@0.28.1: + version "0.28.1" + resolved "https://registry.yarnpkg.com/babel-plugin-syntax-hermes-parser/-/babel-plugin-syntax-hermes-parser-0.28.1.tgz#9e80a774ddb8038307a62316486669c668fb3568" + integrity sha512-meT17DOuUElMNsL5LZN56d+KBp22hb0EfxWfuPUeoSi54e40v1W4C2V36P75FpsH9fVEfDKpw5Nnkahc8haSsQ== + dependencies: + hermes-parser "0.28.1" + +babel-plugin-transform-flow-enums@^0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/babel-plugin-transform-flow-enums/-/babel-plugin-transform-flow-enums-0.0.2.tgz#d1d0cc9bdc799c850ca110d0ddc9f21b9ec3ef25" + integrity sha512-g4aaCrDDOsWjbm0PUUeVnkcVd6AKJsVc/MbnPhEotEpkeJQP6b8nzewohQi7+QS8UyPehOhGWn0nOwjvWpmMvQ== + dependencies: + "@babel/plugin-syntax-flow" "^7.12.1" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +binary-extensions@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz#f6e14a97858d327252200242d4ccfe522c445522" + integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw== + +brace-expansion@^1.1.7: + version "1.1.12" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.12.tgz#ab9b454466e5a8cc3a187beaad580412a9c5b843" + integrity sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +braces@~3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" + integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== + dependencies: + fill-range "^7.1.1" + +browserslist@^4.24.0, browserslist@^4.25.1: + version "4.25.1" + resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.25.1.tgz#ba9e8e6f298a1d86f829c9b975e07948967bb111" + integrity sha512-KGj0KoOMXLpSNkkEI6Z6mShmQy0bc1I+T7K9N81k4WWMrfz+6fQ6es80B/YLAeRoKvjYE1YSHHOW1qe9xIVzHw== + dependencies: + caniuse-lite "^1.0.30001726" + electron-to-chromium "^1.5.173" + node-releases "^2.0.19" + update-browserslist-db "^1.1.3" + +caniuse-lite@^1.0.30001726: + version "1.0.30001727" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001727.tgz#22e9706422ad37aa50556af8c10e40e2d93a8b85" + integrity sha512-pB68nIHmbN6L/4C6MH1DokyR3bYqFwjaSs/sWDHGj4CTcFtQUQMuJftVwWkXq7mNWOybD3KhUv3oWHoGxgP14Q== + +chokidar@^3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b" + integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +cliui@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +commander@^6.2.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" + integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== + +convert-source-map@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a" + integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== + +core-js-compat@^3.43.0: + version "3.44.0" + resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.44.0.tgz#62b9165b97e4cbdb8bca16b14818e67428b4a0f8" + integrity sha512-JepmAj2zfl6ogy34qfWtcE7nHKAJnKsQFRn++scjVS2bZFllwptzw61BZcZFYBPpUznLfAvh0LGhxKppk04ClA== + dependencies: + browserslist "^4.25.1" + +debug@^4.1.0, debug@^4.3.1, debug@^4.4.1: + version "4.4.1" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.1.tgz#e5a8bc6cbc4c6cd3e64308b0693a3d4fa550189b" + integrity sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ== + dependencies: + ms "^2.1.3" + +electron-to-chromium@^1.5.173: + version "1.5.192" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.192.tgz#6dfc57a41846a57b18f9c0121821a6df1e165cc1" + integrity sha512-rP8Ez0w7UNw/9j5eSXCe10o1g/8B1P5SM90PCCMVkIRQn2R0LEHWz4Eh9RnxkniuDe1W0cTSOB3MLlkTGDcuCg== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +escalade@^3.1.1, escalade@^3.2.0: + version "3.2.0" + resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5" + integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== + +fill-range@^7.1.1: + version "7.1.1" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" + integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== + dependencies: + to-regex-range "^5.0.1" + +fs-readdir-recursive@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz#e32fc030a2ccee44a6b5371308da54be0b397d27" + integrity sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA== + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== + +fsevents@~2.3.2: + version "2.3.3" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== + +function-bind@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== + +gensync@^1.0.0-beta.2: + version "1.0.0-beta.2" + resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== + +get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob@^7.1.1, glob@^7.2.0: + version "7.2.3" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.1.1" + once "^1.3.0" + path-is-absolute "^1.0.0" + +hasha-cli@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/hasha-cli/-/hasha-cli-6.0.0.tgz#f39fb9fae2a9cfaab6755b690c22e26d67e107ce" + integrity sha512-T5NbVb/ksS9aFTcWijOoQnsqLPBGfdjw+ii4QVKWKaCWTYsxBtbuXlsQBy+igndxLDjESjrlK7l+hSO67aIL3Q== + dependencies: + hasha "^6.0.0" + meow "^12.1.1" + +hasha@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/hasha/-/hasha-6.0.0.tgz#bdf1231ae40b406121c09c13705e5b38c1bb607c" + integrity sha512-MLydoyGp9QJcjlhE5lsLHXYpWayjjWqkavzju2ZWD2tYa1CgmML1K1gWAu22BLFa2eZ0OfvJ/DlfoVjaD54U2Q== + dependencies: + is-stream "^3.0.0" + type-fest "^4.7.1" + +hasown@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== + dependencies: + function-bind "^1.1.2" + +hermes-estree@0.28.1: + version "0.28.1" + resolved "https://registry.yarnpkg.com/hermes-estree/-/hermes-estree-0.28.1.tgz#631e6db146b06e62fc1c630939acf4a3c77d1b24" + integrity sha512-w3nxl/RGM7LBae0v8LH2o36+8VqwOZGv9rX1wyoWT6YaKZLqpJZ0YQ5P0LVr3tuRpf7vCx0iIG4i/VmBJejxTQ== + +hermes-parser@0.28.1: + version "0.28.1" + resolved "https://registry.yarnpkg.com/hermes-parser/-/hermes-parser-0.28.1.tgz#17b9e6377f334b6870a1f6da2e123fdcd0b605ac" + integrity sha512-nf8o+hE8g7UJWParnccljHumE9Vlq8F7MqIdeahl+4x0tvCUJYRrT0L7h0MMg/X9YJmkNwsfbaNNrzPtFXOscg== + dependencies: + hermes-estree "0.28.1" + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2: + version "2.0.4" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +invariant@^2.2.4: + version "2.2.4" + resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6" + integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA== + dependencies: + loose-envify "^1.0.0" + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-core-module@^2.16.0: + version "2.16.1" + resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.16.1.tgz#2a98801a849f43e2add644fbb6bc6229b19a4ef4" + integrity sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w== + dependencies: + hasown "^2.0.2" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-glob@^4.0.1, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-stream@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-3.0.0.tgz#e6bfd7aa6bef69f4f472ce9bb681e3e57b4319ac" + integrity sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA== + +"js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +jsesc@^3.0.2: + version "3.1.0" + resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.1.0.tgz#74d335a234f67ed19907fdadfac7ccf9d409825d" + integrity sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA== + +jsesc@~3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e" + integrity sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g== + +json5@^2.2.3: + version "2.2.3" + resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" + integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== + +lodash.debounce@^4.0.8: + version "4.0.8" + resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af" + integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow== + +loose-envify@^1.0.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf" + integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q== + dependencies: + js-tokens "^3.0.0 || ^4.0.0" + +lru-cache@^5.1.1: + version "5.1.1" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920" + integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== + dependencies: + yallist "^3.0.2" + +make-dir@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5" + integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA== + dependencies: + pify "^4.0.1" + semver "^5.6.0" + +meow@^12.1.1: + version "12.1.1" + resolved "https://registry.yarnpkg.com/meow/-/meow-12.1.1.tgz#e558dddbab12477b69b2e9a2728c327f191bace6" + integrity sha512-BhXM0Au22RwUneMPwSCnyhTOizdWoIEPU9sp0Aqa1PnDMR5Wv2FGXYDjuzJEIX+Eo2Rb8xuYe5jrnm5QowQFkw== + +minimatch@^3.1.1: + version "3.1.2" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +ms@^2.1.3: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +node-releases@^2.0.19: + version "2.0.19" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.19.tgz#9e445a52950951ec4d177d843af370b411caf314" + integrity sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw== + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +nullthrows@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/nullthrows/-/nullthrows-1.1.1.tgz#7818258843856ae971eae4208ad7d7eb19a431b1" + integrity sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw== + +once@^1.3.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== + +path-parse@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +picocolors@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b" + integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA== + +picomatch@^2.0.4, picomatch@^2.2.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pify@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231" + integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g== + +react-refresh@^0.14.0: + version "0.14.2" + resolved "https://registry.yarnpkg.com/react-refresh/-/react-refresh-0.14.2.tgz#3833da01ce32da470f1f936b9d477da5c7028bf9" + integrity sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA== + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +regenerate-unicode-properties@^10.2.0: + version "10.2.0" + resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz#626e39df8c372338ea9b8028d1f99dc3fd9c3db0" + integrity sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA== + dependencies: + regenerate "^1.4.2" + +regenerate@^1.4.2: + version "1.4.2" + resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a" + integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A== + +regexpu-core@^6.2.0: + version "6.2.0" + resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-6.2.0.tgz#0e5190d79e542bf294955dccabae04d3c7d53826" + integrity sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA== + dependencies: + regenerate "^1.4.2" + regenerate-unicode-properties "^10.2.0" + regjsgen "^0.8.0" + regjsparser "^0.12.0" + unicode-match-property-ecmascript "^2.0.0" + unicode-match-property-value-ecmascript "^2.1.0" + +regjsgen@^0.8.0: + version "0.8.0" + resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.8.0.tgz#df23ff26e0c5b300a6470cad160a9d090c3a37ab" + integrity sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q== + +regjsparser@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.12.0.tgz#0e846df6c6530586429377de56e0475583b088dc" + integrity sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ== + dependencies: + jsesc "~3.0.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +resolve@^1.22.10: + version "1.22.10" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.10.tgz#b663e83ffb09bbf2386944736baae803029b8b39" + integrity sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w== + dependencies: + is-core-module "^2.16.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +semver@^5.6.0: + version "5.7.2" + resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8" + integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g== + +semver@^6.3.1: + version "6.3.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== + +slash@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44" + integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A== + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +type-fest@^4.7.1: + version "4.41.0" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-4.41.0.tgz#6ae1c8e5731273c2bf1f58ad39cbae2c91a46c58" + integrity sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA== + +unicode-canonical-property-names-ecmascript@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz#cb3173fe47ca743e228216e4a3ddc4c84d628cc2" + integrity sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg== + +unicode-match-property-ecmascript@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3" + integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q== + dependencies: + unicode-canonical-property-names-ecmascript "^2.0.0" + unicode-property-aliases-ecmascript "^2.0.0" + +unicode-match-property-value-ecmascript@^2.1.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz#a0401aee72714598f739b68b104e4fe3a0cb3c71" + integrity sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg== + +unicode-property-aliases-ecmascript@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz#43d41e3be698bd493ef911077c9b131f827e8ccd" + integrity sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w== + +update-browserslist-db@^1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz#348377dd245216f9e7060ff50b15a1b740b75420" + integrity sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw== + dependencies: + escalade "^3.2.0" + picocolors "^1.1.1" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yallist@^3.0.2: + version "3.1.1" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd" + integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs@^17.6.2: + version "17.7.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" diff --git a/Tests/NodeApi/test_basics.cpp b/Tests/NodeApi/test_basics.cpp new file mode 100644 index 00000000..ea00acc8 --- /dev/null +++ b/Tests/NodeApi/test_basics.cpp @@ -0,0 +1,80 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +#include + +#include +#include +#include "child_process.h" +#include "test_main.h" + +namespace fs = std::filesystem; + +namespace node_api_tests { + +class BasicsTest : public TestFixtureBase { + protected: + void SetUp() override { basics_js_dir_ = js_root_dir_ / "basics"; } + + ProcessResult RunScript(std::string_view script_filename) noexcept { + return SpawnSync(node_lite_path_.string(), + {(basics_js_dir_ / script_filename).string()}); + } + + bool StringContains(std::string_view str, std::string_view substr) { + return str.find(substr) != std::string::npos; + } + + private: + fs::path basics_js_dir_; +}; + +TEST_F(BasicsTest, TestHello) { + ProcessResult result = RunScript("hello.js"); + ASSERT_TRUE(StringContains(result.std_output, "Hello")); +} + +TEST_F(BasicsTest, TestThrowString) { + ProcessResult result = RunScript("throw_string.js"); + ASSERT_TRUE(StringContains(result.std_error, "Script failed")); +} + +TEST_F(BasicsTest, TestAsyncResolved) { + ProcessResult result = RunScript("async_resolved.js"); + ASSERT_TRUE(StringContains(result.std_output, "test async calling")); + ASSERT_TRUE( + StringContains(result.std_output, "Expected: test async resolved")); +} + +TEST_F(BasicsTest, TestAsyncRejected) { + ProcessResult result = RunScript("async_rejected.js"); + ASSERT_TRUE(StringContains(result.std_output, "test async calling")); + ASSERT_TRUE( + StringContains(result.std_error, "Expected: test async rejected")); +} + +TEST_F(BasicsTest, TestMustCallSuccess) { + ProcessResult result = RunScript("mustcall_success.js"); + ASSERT_TRUE(result.status == 0); +} + +TEST_F(BasicsTest, TestMustCallFailure) { + ProcessResult result = RunScript("mustcall_failure.js"); + ASSERT_TRUE(result.status != 0); + ASSERT_TRUE( + StringContains(result.std_error, "Mismatched noop function calls")); +} + +TEST_F(BasicsTest, TestMustNotCallSuccess) { + ProcessResult result = RunScript("mustnotcall_success.js"); + ASSERT_TRUE(result.status == 0); +} + +TEST_F(BasicsTest, TestMustNotCallFailure) { + ProcessResult result = RunScript("mustnotcall_failure.js"); + ASSERT_TRUE(result.status != 0); + ASSERT_TRUE( + StringContains(result.std_error, "Function should not have been called")); +} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/test_main.cpp b/Tests/NodeApi/test_main.cpp new file mode 100644 index 00000000..b13cd5d3 --- /dev/null +++ b/Tests/NodeApi/test_main.cpp @@ -0,0 +1,201 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. +#include "test_main.h" + +#include +#include + +#include +#include +#include +#include +#include +#include "child_process.h" +#include "string_utils.h" + +namespace fs = std::filesystem; + +namespace node_api_tests { + +/*static*/ std::filesystem::path TestFixtureBase::node_lite_path_; +/*static*/ std::filesystem::path TestFixtureBase::js_root_dir_; + +std::filesystem::path ResolveNodeLitePath(const std::filesystem::path& exePath); + +/*static*/ void TestFixtureBase::InitializeGlobals( + const char* test_exe_path) noexcept { + fs::path exePath = fs::canonical(test_exe_path); + + fs::path nodeLitePath = + ResolveNodeLitePath(fs::path(test_exe_path)); + if (!fs::exists(nodeLitePath)) { + std::cerr << "Error: Cannot find node_lite executable at " + << nodeLitePath << std::endl; + exit(1); + } + TestFixtureBase::node_lite_path_ = nodeLitePath; + + fs::path testRootPath = exePath.parent_path(); + fs::path rootJsPath = testRootPath / "test"; + if (!fs::exists(rootJsPath)) { + testRootPath = testRootPath.parent_path(); + rootJsPath = testRootPath / "test"; + } + if (!fs::exists(rootJsPath)) { + std::cerr << "Error: Cannot find test directory." << std::endl; + exit(1); + } + TestFixtureBase::js_root_dir_ = rootJsPath; +} + +// Forward declaration +int EvaluateJSFile(int argc, char** argv); + +struct NodeApiTestFixture : TestFixtureBase { + explicit NodeApiTestFixture(fs::path testProcess, fs::path jsFilePath) + : m_testProcess(std::move(testProcess)), + m_jsFilePath(std::move(jsFilePath)) {} + static void SetUpTestSuite() {} + static void TearDownTestSuite() {} + void SetUp() override {} + void TearDown() override {} + + void TestBody() override { + ProcessResult result = + SpawnSync(m_testProcess.string(), {m_jsFilePath.string()}); + if (result.status == 0) { + return; + } + if (!result.std_error.empty()) { + std::stringstream errorStream(result.std_error); + std::vector errorLines; + std::string line; + while (std::getline(errorStream, line)) { + if (!line.empty() && line[line.size() - 1] == '\r') { + line.erase(line.size() - 1, std::string::npos); + } + errorLines.push_back(line); + } + if (errorLines.size() >= 3) { + std::string file = errorLines[0].find("file:") == 0 + ? errorLines[0].substr(std::size("file:") - 1) + : ""; + int line = errorLines[1].find("line:") == 0 + ? std::stoi(errorLines[1].substr(std::size("line:") - 1)) + : 0; + std::string message = errorLines[2]; + std::stringstream details; + for (size_t i = 3; i < errorLines.size(); i++) { + details << errorLines[i] << std::endl; + } + GTEST_MESSAGE_AT_(file.c_str(), + line, + message.c_str(), + ::testing::TestPartResult::kFatalFailure) + << details.str(); + return; + } + } + ASSERT_EQ(result.status, 0); + } + + static void RegisterNodeApiTests(); + + private: + fs::path m_testProcess; + fs::path m_jsFilePath; +}; + +std::string SanitizeName(const std::string& name) { + return ReplaceAll(ReplaceAll(name, "-", "_"), ".", "_"); +} + +#ifdef NODE_API_TESTS_HAVE_NATIVE_MODULES +const std::unordered_set& GetEnabledNativeModuleFolders() { + static const std::unordered_set modules = []() { + std::unordered_set result; +#ifdef NODE_API_AVAILABLE_NATIVE_TESTS + std::stringstream stream(NODE_API_AVAILABLE_NATIVE_TESTS); + std::string entry; + while (std::getline(stream, entry, ',')) { + if (!entry.empty()) { + result.insert(entry); + } + } +#endif + return result; + }(); + return modules; +} +#endif + +std::filesystem::path ResolveNodeLitePath(const std::filesystem::path& exePath) { + fs::path nodeLitePath = exePath; + nodeLitePath.replace_filename("node_lite"); +#if defined(_WIN32) + nodeLitePath += ".exe"; +#endif + return nodeLitePath; +} + +} // namespace node_api_tests + +namespace node_api_tests { + +void NodeApiTestFixture::RegisterNodeApiTests() { + for (const fs::directory_entry& dir_entry : + fs::recursive_directory_iterator(js_root_dir_)) { + if (!dir_entry.is_regular_file() || + dir_entry.path().extension() != ".js") { + continue; + } + + fs::path jsFilePath = dir_entry.path(); + fs::path suitePath = jsFilePath.parent_path().parent_path(); + std::string suiteFolder = suitePath.filename().string(); + + bool includeTest = false; + if (suiteFolder == "basics") { + includeTest = true; + } else if (suiteFolder == "js-native-api") { +#ifdef NODE_API_TESTS_HAVE_NATIVE_MODULES + std::string moduleName = jsFilePath.parent_path().filename().string(); + if (GetEnabledNativeModuleFolders().count(moduleName) == 0) { + continue; + } + includeTest = true; +#else + includeTest = false; +#endif + } + + if (!includeTest) { + continue; + } + + std::string testSuiteName = SanitizeName(suiteFolder); + std::string testName = + SanitizeName(jsFilePath.parent_path().filename().string() + "_" + + jsFilePath.filename().string()); + + ::testing::RegisterTest( + testSuiteName.c_str(), + testName.c_str(), + nullptr, + nullptr, + jsFilePath.string().c_str(), + 1, + [jsFilePath]() { + return new NodeApiTestFixture(node_lite_path_, jsFilePath); + }); + } +} + +} // namespace node_api_tests + +int main(int argc, char** argv) { + node_api_tests::TestFixtureBase::InitializeGlobals(argv[0]); + ::testing::InitGoogleTest(&argc, argv); + node_api_tests::NodeApiTestFixture::RegisterNodeApiTests(); + return RUN_ALL_TESTS(); +} diff --git a/Tests/NodeApi/test_main.h b/Tests/NodeApi/test_main.h new file mode 100644 index 00000000..e0f34c32 --- /dev/null +++ b/Tests/NodeApi/test_main.h @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#ifndef NODE_API_TEST_TEST_MAIN_H +#define NODE_API_TEST_TEST_MAIN_H + +#include +#include + +namespace node_api_tests { + +class TestFixtureBase : public ::testing::Test { + public: + static void InitializeGlobals(const char* test_exe_path) noexcept; + + protected: + static std::filesystem::path node_lite_path_; + static std::filesystem::path js_root_dir_; +}; + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_TEST_MAIN_H \ No newline at end of file From 230134e1a9ca9b441a2d16be1ef9b9db9214271c Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 12 Oct 2025 01:19:17 -0700 Subject: [PATCH 003/174] =?UTF-8?q?Android=20tests=20now=20pass.=20StdoutL?= =?UTF-8?q?ogger=20was=20holding=20on=20to=20destroyed=20mutex=20handles?= =?UTF-8?q?=20during=20instrumentation,=20causing=20crashes,=20and=20now?= =?UTF-8?q?=20route=20console=20output=20through=20the=20new=20NodeLiteRun?= =?UTF-8?q?time::Callbacks.=20On=20Android=20we=20forward=20stdout/stderr?= =?UTF-8?q?=20to=20logcat=20via=20callbacks=20to=20work=20around=20this=20?= =?UTF-8?q?for=20now.=20Added=20Android-specific=20shims=20(node=5Flite=5F?= =?UTF-8?q?android.cpp,=20child=5Fprocess=5Fandroid.cpp)=20so=20native=20m?= =?UTF-8?q?odule=20loading=20uses=20dlopen=20and=20JS=20=20child=5Fprocess?= =?UTF-8?q?.spawnSync=20safely=20reports=20=E2=80=9Cunsupported=E2=80=9D.?= =?UTF-8?q?=20Extended=20the=20Node=E2=80=91API=20harness=20to=20allow=20i?= =?UTF-8?q?n-process=20execution:=20RunNodeLiteScript=20captures=20output,?= =?UTF-8?q?=20SetNodeApiTestEnvironment=20lets=20the=20JNI=20layer=20provi?= =?UTF-8?q?de=20a=20base=20directory=20and=20asset=20manager,=20and=20the?= =?UTF-8?q?=20GTest=20registration=20path=20uses=20that=20configuration=20?= =?UTF-8?q?instead=20of=20shelling=20out=20to=20the=20node=5Flite=20execut?= =?UTF-8?q?able?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Tests/NodeApi/CMakeLists.txt | 20 +- Tests/NodeApi/node_lite.cpp | 420 ++++++++++++------ Tests/NodeApi/node_lite.h | 143 +++--- Tests/NodeApi/node_lite_jsruntimehost.cpp | 78 +++- Tests/NodeApi/test_basics.cpp | 28 +- Tests/NodeApi/test_main.cpp | 331 ++++++-------- Tests/NodeApi/test_main.h | 44 +- Tests/UnitTests/Android/app/build.gradle | 20 + .../com/jsruntimehost/unittests/Main.java | 10 +- .../com/jsruntimehost/unittests/Native.java | 1 + .../Android/app/src/main/cpp/CMakeLists.txt | 34 +- .../Android/app/src/main/cpp/JNI.cpp | 49 +- Tests/UnitTests/Shared/Shared.cpp | 173 ++++++++ Tests/UnitTests/Shared/Shared.h | 9 +- Tests/package-lock.json | 6 + 15 files changed, 951 insertions(+), 415 deletions(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 48c5b5a8..1c4ce785 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -20,7 +20,10 @@ function(node_api_copy_test_sources TARGET_NAME) ) endfunction() -if(APPLE) +if(ANDROID) + set(NODE_LITE_PLATFORM_SRC node_lite_android.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_android.cpp) +elseif(APPLE) set(NODE_LITE_PLATFORM_SRC node_lite_mac.cpp) set(NODE_LITE_CHILD_PROCESS_SRC child_process_mac.cpp) elseif(WIN32) @@ -68,13 +71,14 @@ target_link_libraries(node_lite node_api_copy_test_sources(node_lite) add_executable(NodeApiTests - ${NODE_LITE_CHILD_PROCESS_SRC} - child_process.h - string_utils.cpp - string_utils.h - test_basics.cpp - test_main.cpp - test_main.h + ${NODE_LITE_CHILD_PROCESS_SRC} + child_process.h + string_utils.cpp + string_utils.h + test_basics.cpp + test_main.cpp + main.cpp + test_main.h ) target_include_directories(NodeApiTests diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 5401d39c..d82f3bb2 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -1,29 +1,50 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -#include "node_lite.h" -#include "js_runtime_api.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "child_process.h" +#include "node_lite.h" +#include "js_runtime_api.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "child_process.h" namespace fs = std::filesystem; namespace node_api_tests { -namespace { - -NodeApiRef MakeNodeApiRef(napi_env env, napi_value value) { - napi_ref ref{}; - NODE_LITE_CALL(napi_create_reference(env, value, 1, &ref)); - return NodeApiRef(ref, NodeApiRefDeleter(env)); +namespace { + +std::mutex& ErrorHandlerMutex() { + static std::mutex mutex; + return mutex; +} + +void DefaultFatalErrorHandler(const NodeLiteFatalErrorInfo& info) { + if (!info.message.empty()) { + std::cerr << info.message; + if (!info.details.empty()) { + std::cerr << '\n' << info.details; + } + std::cerr << std::endl; + } else if (!info.details.empty()) { + std::cerr << info.details << std::endl; + } + std::exit(info.exit_code); +} + +NodeApiRef MakeNodeApiRef(napi_env env, napi_value value) { + napi_ref ref{}; + NODE_LITE_CALL(napi_create_reference(env, value, 1, &ref)); + return NodeApiRef(ref, NodeApiRefDeleter(env)); } template @@ -270,32 +291,39 @@ std::string NodeLiteModule::ReadModuleFileText(napi_env env) { } std::string jsFilePath = args[1]; - std::unique_ptr runtime = NodeLiteRuntime::Create( - std::move(taskRunner), js_root.string(), std::move(args)); + std::unique_ptr runtime = NodeLiteRuntime::Create( + std::move(taskRunner), + js_root.string(), + std::move(args), + NodeLiteRuntime::Callbacks{}); runtime->RunTestScript(jsFilePath); } /*static*/ std::unique_ptr NodeLiteRuntime::Create( - std::shared_ptr task_runner, - std::string js_root, - std::vector args) { - std::unique_ptr runtime = - std::make_unique(PrivateTag{}, - std::move(task_runner), - std::move(js_root), - std::move(args)); - runtime->Initialize(); - return runtime; -} - -NodeLiteRuntime::NodeLiteRuntime( - PrivateTag, - std::shared_ptr task_runner, - std::string js_root, - std::vector args) - : task_runner_(std::move(task_runner)), - js_root_(std::move(js_root)), - args_(std::move(args)) {} + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks) { + std::unique_ptr runtime = + std::make_unique(PrivateTag{}, + std::move(task_runner), + std::move(js_root), + std::move(args), + std::move(callbacks)); + runtime->Initialize(); + return std::unique_ptr(runtime.release()); +} + +NodeLiteRuntime::NodeLiteRuntime( + PrivateTag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks) + : task_runner_(std::move(task_runner)), + js_root_(std::move(js_root)), + args_(std::move(args)), + callbacks_(std::move(callbacks)) {} void NodeLiteRuntime::Initialize() { env_holder_ = @@ -554,9 +582,9 @@ void NodeLiteRuntime::DefineBuiltInModules() { } } -void NodeLiteRuntime::DefineGlobalFunctions() { - NodeApiHandleScope scope{env_}; - napi_value global = NodeApi::GetGlobal(env_); +void NodeLiteRuntime::DefineGlobalFunctions() { + NodeApiHandleScope scope{env_}; + napi_value global = NodeApi::GetGlobal(env_); // Add global.global NodeApi::SetProperty(env_, global, "global", global); @@ -680,27 +708,46 @@ void NodeLiteRuntime::DefineGlobalFunctions() { NodeApi::SetProperty(env_, global, "console", console_obj); // console.log() - NodeApi::SetMethod( - env_, console_obj, "log", [](napi_env env, span args) { - NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); - std::string message = NodeApi::ToStdString(env, args[0]); - std::cout << message << std::endl; - return nullptr; - }); + NodeApi::SetMethod( + env_, + console_obj, + "log", + [this](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + EmitConsoleOutput(message, false); + return nullptr; + }); // console.error() NodeApi::SetMethod( env_, console_obj, "error", - [](napi_env env, span args) -> napi_value { - NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); - std::string message = NodeApi::ToStdString(env, args[0]); - std::cerr << message << std::endl; - return nullptr; - }); - } -} + [this](napi_env env, span args) -> napi_value { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + EmitConsoleOutput(message, true); + return nullptr; + }); + } +} + +void NodeLiteRuntime::EmitConsoleOutput(const std::string& message, + bool is_error) { + const auto& callback = is_error ? callbacks_.stderr_callback + : callbacks_.stdout_callback; + if (callback) { + callback(message); + return; + } + + if (is_error) { + std::cerr << message << std::endl; + } else { + std::cout << message << std::endl; + } +} std::string NodeLiteRuntime::ProcessStack(std::string const& stack, std::string const& assertMethod) { @@ -863,27 +910,55 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { return *this; } -//============================================================================= -// NodeLiteErrorHandler implementation -//============================================================================= - -/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnNodeApiFailed( - napi_env env, napi_status error_code) { - const char* errorMessage = "An exception is pending"; - if (NodeApi::IsExceptionPending(env)) { - error_code = napi_pending_exception; +//============================================================================= +// NodeLiteErrorHandler implementation +//============================================================================= + +/*static*/ NodeLiteErrorHandler::Handler NodeLiteErrorHandler::SetHandler( + Handler handler) noexcept { + std::lock_guard lock{ErrorHandlerMutex()}; + Handler previous = GetHandler(); + if (handler) { + GetHandler() = std::move(handler); + } else { + GetHandler() = DefaultFatalErrorHandler; + } + return previous; +} + +/*static*/ NodeLiteErrorHandler::Handler& NodeLiteErrorHandler::GetHandler() + noexcept { + static Handler handler = DefaultFatalErrorHandler; + return handler; +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::HandleFatalError( + NodeLiteFatalErrorInfo info) { + Handler handler_copy; + { + std::lock_guard lock{ErrorHandlerMutex()}; + handler_copy = GetHandler(); + } + handler_copy(info); + std::terminate(); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnNodeApiFailed( + napi_env env, napi_status error_code) { + const char* errorMessage = "An exception is pending"; + if (NodeApi::IsExceptionPending(env)) { + error_code = napi_pending_exception; } else { const napi_extended_error_info* error_info{}; napi_status status = napi_get_last_error_info(env, &error_info); if (status != napi_ok) { - NodeLiteErrorHandler::ExitWithMessage("", [&](std::ostream& os) { - os << "Failed to get last error info: " << status; - }); - } - errorMessage = error_info->error_message; - } - throw NodeLiteException(error_code, errorMessage); -} + NodeLiteErrorHandler::ExitWithMessage( + "", [&](std::ostream& os) { os << "Failed to get last error info: " << status; }); + } + errorMessage = error_info->error_message; + } + throw NodeLiteException(error_code, errorMessage); +} /*static*/ [[noreturn]] void NodeLiteErrorHandler::OnAssertFailed( napi_env env, char const* expr, char const* message) { @@ -912,17 +987,17 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { } std::string message = NodeApi::GetPropertyString(env, error, "message"); std::string stack = NodeApi::GetPropertyString(env, error, "stack"); - ExitWithMessage("JavaScript error", [&](std::ostream& os) { - os << "Exception: " << name << '\n' - << " Message: " << message << '\n' - << "Callstack: " << '\n' - << stack; - }); - } else { - std::string message = NodeApi::CoerceToString(env, error); - ExitWithMessage("JavaScript error", - [&](std::ostream& os) { os << " Message: " << message; }); - } + ExitWithMessage("JavaScript error", [&](std::ostream& os) { + os << "Exception: " << name << '\n' + << " Message: " << message << '\n' + << "Callstack: " << '\n' + << stack; + }); + } else { + std::string message = NodeApi::CoerceToString(env, error); + ExitWithMessage("JavaScript error", + [&](std::ostream& os) { os << " Message: " << message; }); + } } /*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSAssertError( @@ -946,38 +1021,37 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { << " Actual: " << actual << '\n'; } - ExitWithMessage("JavaScript assertion error", [&](std::ostream& os) { - os << "Exception: " << "AssertionError" << '\n' - << " Method: " << method_name << '\n' - << " Message: " << message << '\n' - << error_details.str(/*a filler for formatting*/) - << "Callstack: " << '\n' - << error_stack; - }); -} - -/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( - const std::string& message, - std::function get_error_details) noexcept { - std::ostringstream details_stream; - get_error_details(details_stream); - std::string details = details_stream.str(); - if (!message.empty()) { - std::cerr << message; - } - if (!details.empty()) { - if (!message.empty()) { - std::cerr << "\n"; - } - std::cerr << details; - } - std::cerr << std::endl; - exit(1); -} - -//============================================================================= -// NodeApi implementation -//============================================================================= + ExitWithMessage("JavaScript assertion error", [&](std::ostream& os) { + os << "Exception: " + << "AssertionError" << '\n' + << " Method: " << method_name << '\n' + << " Message: " << message << '\n' + << error_details.str(/*a filler for formatting*/) + << "Callstack: " << '\n' + << error_stack; + }); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( + const std::string& message, + std::function get_error_details, + int exit_code) noexcept { + std::ostringstream details_stream; + if (get_error_details) { + get_error_details(details_stream); + } + std::string details = details_stream.str(); + + HandleFatalError(NodeLiteFatalErrorInfo{ + .message = message, + .details = details, + .exit_code = exit_code, + }); +} + +//============================================================================= +// NodeApi implementation +//============================================================================= /*static*/ bool NodeApi::IsExceptionPending(napi_env env) { bool result{}; @@ -1236,11 +1310,11 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { return result; } -/*static*/ napi_value NodeApi::CreateFunction(napi_env env, - std::string_view name, - NodeApiCallback cb) { - napi_value result{}; - NODE_LITE_CALL(napi_create_function( +/*static*/ napi_value NodeApi::CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb) { + napi_value result{}; + NODE_LITE_CALL(napi_create_function( env, name.data(), name.size(), @@ -1257,12 +1331,98 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { // TODO: (vmoroz) Find a way to delete it on close. new NodeApiCallback(std::move(cb)), &result)); - return result; -} - -} // namespace node_api_tests - -int main(int argc, char* argv[]) { - node_api_tests::NodeLiteRuntime::Run( + return result; +} + +ProcessResult RunNodeLiteScript(const std::filesystem::path& js_root, + const std::filesystem::path& script_path, + NodeLiteRuntime::Callbacks callbacks) { + ProcessResult result{}; + std::ostringstream stdout_stream; + std::ostringstream stderr_stream; + + NodeLiteRuntime::Callbacks effective_callbacks; + auto stdout_cb = callbacks.stdout_callback; + auto stderr_cb = callbacks.stderr_callback; + effective_callbacks.stdout_callback = + [stdout_cb, &stdout_stream](const std::string& message) { + if (stdout_cb) { + stdout_cb(message); + } + stdout_stream << message << '\n'; + }; + effective_callbacks.stderr_callback = + [stderr_cb, &stderr_stream](const std::string& message) { + if (stderr_cb) { + stderr_cb(message); + } + stderr_stream << message << '\n'; + }; + + auto fatal_handler = [&result](const NodeLiteFatalErrorInfo& info) { + result.status = info.exit_code; + if (!info.message.empty()) { + result.std_error = info.message; + } + if (!info.details.empty()) { + if (!result.std_error.empty()) { + result.std_error += '\n'; + } + result.std_error += info.details; + } + throw NodeLiteFatalError(info); + }; + + NodeLiteErrorHandler::Handler previous_handler = + NodeLiteErrorHandler::SetHandler(fatal_handler); + + try { + auto task_runner = std::make_shared(); + std::vector args{"node_lite", script_path.string()}; + auto runtime = NodeLiteRuntime::Create(std::move(task_runner), + js_root.string(), + std::move(args), + std::move(effective_callbacks)); + runtime->RunTestScript(script_path.string()); + result.status = 0; + } catch (const NodeLiteFatalError&) { + // Fatal error captured in result + } catch (const std::exception& e) { + NodeLiteErrorHandler::SetHandler(previous_handler); + result.status = -1; + result.std_error = e.what(); + return result; + } catch (...) { + NodeLiteErrorHandler::SetHandler(previous_handler); + result.status = -1; + result.std_error = "Unknown error"; + return result; + } + + NodeLiteErrorHandler::SetHandler(previous_handler); + + result.std_output = stdout_stream.str(); + if (!result.std_output.empty() && result.std_output.back() == '\n') { + result.std_output.pop_back(); + } + + std::string stderr_logs = stderr_stream.str(); + if (!stderr_logs.empty() && stderr_logs.back() == '\n') { + stderr_logs.pop_back(); + } + if (!stderr_logs.empty()) { + if (!result.std_error.empty()) { + result.std_error += '\n'; + } + result.std_error += stderr_logs; + } + + return result; +} + +} // namespace node_api_tests + +int main(int argc, char* argv[]) { + node_api_tests::NodeLiteRuntime::Run( std::vector(argv, argv + argc)); } diff --git a/Tests/NodeApi/node_lite.h b/Tests/NodeApi/node_lite.h index 5b9044dd..e8bba7e2 100644 --- a/Tests/NodeApi/node_lite.h +++ b/Tests/NodeApi/node_lite.h @@ -13,11 +13,12 @@ #include #include #include -#include -#include -#include -#include "compat.h" -#include "string_utils.h" +#include +#include +#include +#include "child_process.h" +#include "compat.h" +#include "string_utils.h" #define NAPI_EXPERIMENTAL #include "js_runtime_api.h" @@ -87,10 +88,31 @@ class NodeLiteException : public std::runtime_error { napi_status error_status_; }; -class NodeLiteErrorHandler { - public: - [[noreturn]] static void OnNodeApiFailed(napi_env env, - napi_status error_status); +struct NodeLiteFatalErrorInfo { + std::string message; + std::string details; + int exit_code{1}; +}; + +class NodeLiteFatalError : public std::runtime_error { + public: + explicit NodeLiteFatalError(NodeLiteFatalErrorInfo info) + : std::runtime_error{info.message.c_str()}, info_{std::move(info)} {} + + const NodeLiteFatalErrorInfo& info() const noexcept { return info_; } + + private: + NodeLiteFatalErrorInfo info_; +}; + +class NodeLiteErrorHandler { + public: + using Handler = std::function; + + static Handler SetHandler(Handler handler) noexcept; + + [[noreturn]] static void OnNodeApiFailed(napi_env env, + napi_status error_status); [[noreturn]] static void OnAssertFailed(napi_env env, char const* expr, @@ -99,16 +121,21 @@ class NodeLiteErrorHandler { [[noreturn]] static void ExitWithJSError(napi_env env, napi_value error) noexcept; - [[noreturn]] static void ExitWithJSAssertError(napi_env env, - napi_value error) noexcept; - - [[noreturn]] static void ExitWithMessage( - const std::string& message, - std::function get_error_details = nullptr) noexcept; -}; - -// Define NodeApiRef "smart pointer" for napi_ref as unique_ptr with a custom -// deleter. + [[noreturn]] static void ExitWithJSAssertError(napi_env env, + napi_value error) noexcept; + + [[noreturn]] static void ExitWithMessage( + const std::string& message, + std::function get_error_details = nullptr, + int exit_code = 1) noexcept; + + private: + static Handler& GetHandler() noexcept; + [[noreturn]] static void HandleFatalError(NodeLiteFatalErrorInfo info); +}; + +// Define NodeApiRef "smart pointer" for napi_ref as unique_ptr with a custom +// deleter. class NodeApiRefDeleter { public: NodeApiRefDeleter() noexcept; @@ -183,21 +210,28 @@ class NodeLiteModule { }; // The Node.js-like runtime that is enough to run Node-API tests. -class NodeLiteRuntime { - struct PrivateTag {}; - - public: - static std::unique_ptr Create( - std::shared_ptr task_runner, - std::string js_root, - std::vector args); - - explicit NodeLiteRuntime(PrivateTag tag, - std::shared_ptr task_runner, - std::string js_root, - std::vector args); - - static void Run(std::vector args); +class NodeLiteRuntime { + struct PrivateTag {}; + + public: + struct Callbacks { + std::function stdout_callback{}; + std::function stderr_callback{}; + }; + + static std::unique_ptr Create( + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks); + + explicit NodeLiteRuntime(PrivateTag tag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks); + + static void Run(std::vector args); NodeLiteModule& ResolveModule(const std::string& parent_module_path, const std::string& module_path); @@ -222,15 +256,17 @@ class NodeLiteRuntime { private: void Initialize(); - void DefineGlobalFunctions(); - void DefineBuiltInModules(); - - private: - std::shared_ptr task_runner_; - std::string js_root_; - std::vector args_; - std::unique_ptr env_holder_; - napi_env env_{}; + void DefineGlobalFunctions(); + void DefineBuiltInModules(); + void EmitConsoleOutput(const std::string& message, bool is_error); + + private: + std::shared_ptr task_runner_; + std::string js_root_; + std::vector args_; + Callbacks callbacks_{}; + std::unique_ptr env_holder_; + napi_env env_{}; std::unordered_map> registered_modules_; std::unordered_map node_js_modules_; @@ -355,11 +391,16 @@ class NodeApi { napi_value func, span args); - static napi_value CreateFunction(napi_env env, - std::string_view name, - NodeApiCallback cb); -}; - -} // namespace node_api_tests - -#endif // !NODE_API_TEST_NODE_LITE_H \ No newline at end of file + static napi_value CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb); +}; + +ProcessResult RunNodeLiteScript( + const std::filesystem::path& js_root, + const std::filesystem::path& script_path, + NodeLiteRuntime::Callbacks callbacks = NodeLiteRuntime::Callbacks{}); + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_NODE_LITE_H diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index 6833672e..3e47e621 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -4,6 +4,8 @@ #include #include +#include +#include #include #if defined(__APPLE__) @@ -12,6 +14,7 @@ #elif defined(__ANDROID__) #include #include "js_native_api_v8.h" +#include #endif namespace node_api_tests { @@ -28,12 +31,20 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { context_ = JSGlobalContextCreateInGroup(nullptr, nullptr); env_ = Napi::Attach(context_); #elif defined(__ANDROID__) - // TODO: Implement a dedicated V8 environment for Android Node-API tests. - // For now we surface a clear failure so we remember to provide a proper - // implementation before enabling Android execution. - (void)onUnhandledError_; - throw std::runtime_error( - "Android Node-API tests are not yet implemented for node_lite."); + V8Platform::EnsureInitialized(); + + allocator_.reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator()); + v8::Isolate::CreateParams create_params; + create_params.array_buffer_allocator = allocator_.get(); + isolate_ = v8::Isolate::New(create_params); + + v8::Locker locker(isolate_); + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + v8::Local context = v8::Context::New(isolate_); + context_.Reset(isolate_, context); + v8::Context::Scope context_scope(context); + env_ = Napi::Attach(context); #else (void)onUnhandledError_; throw std::runtime_error( @@ -65,6 +76,37 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { JSGlobalContextRelease(context_); context_ = nullptr; } +#elif defined(__ANDROID__) + if (env_ != nullptr && isolate_ != nullptr) { + v8::Locker locker(isolate_); + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + v8::Local context = context_.Get(isolate_); + v8::Context::Scope context_scope(context); + + if (onUnhandledError_) { + bool hasPending = false; + if (napi_is_exception_pending(env_, &hasPending) == napi_ok && hasPending) { + napi_value error{}; + if (napi_get_and_clear_last_exception(env_, &error) == napi_ok) { + onUnhandledError_(env_, error); + } + } + } + + Napi::Env napiEnv{env_}; + Napi::Detach(napiEnv); + env_ = nullptr; + } + + context_.Reset(); + + if (isolate_ != nullptr) { + isolate_->Dispose(); + isolate_ = nullptr; + } + + allocator_.reset(); #endif } @@ -73,11 +115,35 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { private: #if defined(__APPLE__) JSGlobalContextRef context_{}; +#elif defined(__ANDROID__) + class V8Platform { + public: + static void EnsureInitialized() { + std::call_once(init_flag_, []() { + platform_ = v8::platform::NewDefaultPlatform(); + v8::V8::InitializePlatform(platform_.get()); + v8::V8::Initialize(); + }); + } + + private: + static std::once_flag init_flag_; + static std::unique_ptr platform_; + }; + + v8::Isolate* isolate_{nullptr}; + v8::Global context_; + std::unique_ptr allocator_{}; #endif napi_env env_{}; std::function onUnhandledError_{}; }; +#if defined(__ANDROID__) +std::once_flag JsRuntimeHostEnvHolder::V8Platform::init_flag_{}; +std::unique_ptr JsRuntimeHostEnvHolder::V8Platform::platform_{}; +#endif + } // namespace std::unique_ptr CreateEnvHolder( diff --git a/Tests/NodeApi/test_basics.cpp b/Tests/NodeApi/test_basics.cpp index ea00acc8..45d00a26 100644 --- a/Tests/NodeApi/test_basics.cpp +++ b/Tests/NodeApi/test_basics.cpp @@ -12,14 +12,26 @@ namespace fs = std::filesystem; namespace node_api_tests { -class BasicsTest : public TestFixtureBase { - protected: - void SetUp() override { basics_js_dir_ = js_root_dir_ / "basics"; } - - ProcessResult RunScript(std::string_view script_filename) noexcept { - return SpawnSync(node_lite_path_.string(), - {(basics_js_dir_ / script_filename).string()}); - } +class BasicsTest : public TestFixtureBase { + protected: + void SetUp() override { + const auto& config = Config(); + ASSERT_FALSE(config.js_root.empty()) + << "Node-API test root directory is not configured."; + basics_js_dir_ = config.js_root / "basics"; + } + + ProcessResult RunScript(std::string_view script_filename) noexcept { + const auto& config = Config(); + if (config.run_script) { + return config.run_script(basics_js_dir_ / fs::path{script_filename}); + } + + ProcessResult fallback{}; + fallback.status = 1; + fallback.std_error = "Node-API test runner is not configured."; + return fallback; + } bool StringContains(std::string_view str, std::string_view substr) { return str.find(substr) != std::string::npos; diff --git a/Tests/NodeApi/test_main.cpp b/Tests/NodeApi/test_main.cpp index b13cd5d3..93803cb8 100644 --- a/Tests/NodeApi/test_main.cpp +++ b/Tests/NodeApi/test_main.cpp @@ -1,201 +1,164 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. -#include "test_main.h" - -#include -#include - +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +#include "test_main.h" + +#include +#include + #include +#include #include #include -#include -#include -#include "child_process.h" -#include "string_utils.h" - -namespace fs = std::filesystem; - -namespace node_api_tests { - -/*static*/ std::filesystem::path TestFixtureBase::node_lite_path_; -/*static*/ std::filesystem::path TestFixtureBase::js_root_dir_; - -std::filesystem::path ResolveNodeLitePath(const std::filesystem::path& exePath); - -/*static*/ void TestFixtureBase::InitializeGlobals( - const char* test_exe_path) noexcept { - fs::path exePath = fs::canonical(test_exe_path); - - fs::path nodeLitePath = - ResolveNodeLitePath(fs::path(test_exe_path)); - if (!fs::exists(nodeLitePath)) { - std::cerr << "Error: Cannot find node_lite executable at " - << nodeLitePath << std::endl; - exit(1); - } - TestFixtureBase::node_lite_path_ = nodeLitePath; - - fs::path testRootPath = exePath.parent_path(); - fs::path rootJsPath = testRootPath / "test"; - if (!fs::exists(rootJsPath)) { - testRootPath = testRootPath.parent_path(); - rootJsPath = testRootPath / "test"; - } - if (!fs::exists(rootJsPath)) { - std::cerr << "Error: Cannot find test directory." << std::endl; - exit(1); - } - TestFixtureBase::js_root_dir_ = rootJsPath; -} - -// Forward declaration -int EvaluateJSFile(int argc, char** argv); - -struct NodeApiTestFixture : TestFixtureBase { - explicit NodeApiTestFixture(fs::path testProcess, fs::path jsFilePath) - : m_testProcess(std::move(testProcess)), - m_jsFilePath(std::move(jsFilePath)) {} - static void SetUpTestSuite() {} - static void TearDownTestSuite() {} - void SetUp() override {} - void TearDown() override {} - - void TestBody() override { - ProcessResult result = - SpawnSync(m_testProcess.string(), {m_jsFilePath.string()}); - if (result.status == 0) { - return; - } - if (!result.std_error.empty()) { - std::stringstream errorStream(result.std_error); - std::vector errorLines; - std::string line; - while (std::getline(errorStream, line)) { - if (!line.empty() && line[line.size() - 1] == '\r') { - line.erase(line.size() - 1, std::string::npos); - } - errorLines.push_back(line); - } - if (errorLines.size() >= 3) { - std::string file = errorLines[0].find("file:") == 0 - ? errorLines[0].substr(std::size("file:") - 1) - : ""; - int line = errorLines[1].find("line:") == 0 - ? std::stoi(errorLines[1].substr(std::size("line:") - 1)) - : 0; - std::string message = errorLines[2]; - std::stringstream details; - for (size_t i = 3; i < errorLines.size(); i++) { - details << errorLines[i] << std::endl; - } - GTEST_MESSAGE_AT_(file.c_str(), - line, - message.c_str(), - ::testing::TestPartResult::kFatalFailure) - << details.str(); - return; - } - } - ASSERT_EQ(result.status, 0); - } - - static void RegisterNodeApiTests(); - - private: - fs::path m_testProcess; - fs::path m_jsFilePath; -}; - +#include +#include +#include "string_utils.h" + +namespace fs = std::filesystem; + +namespace node_api_tests { + +namespace { + +NodeApiTestConfig g_test_config{}; +bool g_test_config_initialized = false; + +const NodeApiTestConfig& RequireConfig() noexcept { + if (!g_test_config_initialized) { + std::cerr << "[NodeApiTests] configuration not initialized." << std::endl; + std::abort(); + } + return g_test_config; +} + std::string SanitizeName(const std::string& name) { return ReplaceAll(ReplaceAll(name, "-", "_"), ".", "_"); } -#ifdef NODE_API_TESTS_HAVE_NATIVE_MODULES -const std::unordered_set& GetEnabledNativeModuleFolders() { - static const std::unordered_set modules = []() { - std::unordered_set result; -#ifdef NODE_API_AVAILABLE_NATIVE_TESTS - std::stringstream stream(NODE_API_AVAILABLE_NATIVE_TESTS); - std::string entry; - while (std::getline(stream, entry, ',')) { - if (!entry.empty()) { - result.insert(entry); - } - } -#endif - return result; - }(); - return modules; +} // namespace + +void InitializeNodeApiTests(const NodeApiTestConfig& config) noexcept { + g_test_config = config; + g_test_config_initialized = true; } -#endif - -std::filesystem::path ResolveNodeLitePath(const std::filesystem::path& exePath) { - fs::path nodeLitePath = exePath; - nodeLitePath.replace_filename("node_lite"); -#if defined(_WIN32) - nodeLitePath += ".exe"; -#endif - return nodeLitePath; -} - -} // namespace node_api_tests - -namespace node_api_tests { - -void NodeApiTestFixture::RegisterNodeApiTests() { - for (const fs::directory_entry& dir_entry : - fs::recursive_directory_iterator(js_root_dir_)) { - if (!dir_entry.is_regular_file() || - dir_entry.path().extension() != ".js") { - continue; + +const NodeApiTestConfig& GetNodeApiTestConfig() noexcept { + return RequireConfig(); +} + +const NodeApiTestConfig& TestFixtureBase::Config() noexcept { + return RequireConfig(); +} + +class NodeApiTestFixture : public TestFixtureBase { + public: + explicit NodeApiTestFixture(fs::path jsFilePath) + : m_jsFilePath(std::move(jsFilePath)) {} + + void TestBody() override { + const auto& config = Config(); + ASSERT_TRUE(static_cast(config.run_script)) + << "Node-API test runner is not configured."; + + ProcessResult result = config.run_script(m_jsFilePath); + if (result.status == 0) { + return; } - fs::path jsFilePath = dir_entry.path(); - fs::path suitePath = jsFilePath.parent_path().parent_path(); - std::string suiteFolder = suitePath.filename().string(); - - bool includeTest = false; - if (suiteFolder == "basics") { - includeTest = true; - } else if (suiteFolder == "js-native-api") { -#ifdef NODE_API_TESTS_HAVE_NATIVE_MODULES - std::string moduleName = jsFilePath.parent_path().filename().string(); - if (GetEnabledNativeModuleFolders().count(moduleName) == 0) { - continue; + if (!result.std_error.empty()) { + std::stringstream errorStream(result.std_error); + std::vector errorLines; + std::string line; + while (std::getline(errorStream, line)) { + if (!line.empty() && line.back() == '\r') { + line.pop_back(); + } + errorLines.push_back(line); + } + if (errorLines.size() >= 3) { + std::string file = errorLines[0].rfind("file:", 0) == 0 + ? errorLines[0].substr(5) + : ""; + int lineNumber = errorLines[1].rfind("line:", 0) == 0 + ? std::stoi(errorLines[1].substr(5)) + : 0; + std::string message = errorLines[2]; + std::stringstream details; + for (size_t i = 3; i < errorLines.size(); ++i) { + details << errorLines[i] << std::endl; + } + GTEST_MESSAGE_AT_(file.c_str(), + lineNumber, + message.c_str(), + ::testing::TestPartResult::kFatalFailure) + << details.str(); + return; } - includeTest = true; -#else - includeTest = false; -#endif } - if (!includeTest) { - continue; + ASSERT_EQ(result.status, 0); + } + + static void Register() { + const auto& config = Config(); + const fs::path& js_root = config.js_root; + if (js_root.empty()) { + std::cerr << "[NodeApiTests] JS root directory not configured." << std::endl; + std::abort(); } - std::string testSuiteName = SanitizeName(suiteFolder); - std::string testName = - SanitizeName(jsFilePath.parent_path().filename().string() + "_" + - jsFilePath.filename().string()); - - ::testing::RegisterTest( - testSuiteName.c_str(), - testName.c_str(), - nullptr, - nullptr, - jsFilePath.string().c_str(), - 1, - [jsFilePath]() { - return new NodeApiTestFixture(node_lite_path_, jsFilePath); - }); + for (const fs::directory_entry& dir_entry : + fs::recursive_directory_iterator(js_root)) { + if (!dir_entry.is_regular_file() || + dir_entry.path().extension() != ".js") { + continue; + } + + fs::path jsFilePath = dir_entry.path(); + fs::path suitePath = jsFilePath.parent_path().parent_path(); + std::string suiteFolder = suitePath.filename().string(); + + bool includeTest = false; + if (suiteFolder == "basics") { + includeTest = true; + } else if (suiteFolder == "js-native-api") { + if (config.enabled_native_suites.empty()) { + continue; + } + std::string moduleName = jsFilePath.parent_path().filename().string(); + includeTest = + config.enabled_native_suites.find(moduleName) != + config.enabled_native_suites.end(); + } else { + continue; + } + + if (!includeTest) { + continue; + } + + std::string testSuiteName = SanitizeName(suiteFolder); + std::string testName = SanitizeName( + jsFilePath.parent_path().filename().string() + "_" + + jsFilePath.filename().string()); + + ::testing::RegisterTest( + testSuiteName.c_str(), + testName.c_str(), + nullptr, + nullptr, + jsFilePath.string().c_str(), + 1, + [jsFilePath]() { return new NodeApiTestFixture(jsFilePath); }); + } } + + private: + fs::path m_jsFilePath; +}; + +void RegisterNodeApiTests() { + NodeApiTestFixture::Register(); } - -} // namespace node_api_tests - -int main(int argc, char** argv) { - node_api_tests::TestFixtureBase::InitializeGlobals(argv[0]); - ::testing::InitGoogleTest(&argc, argv); - node_api_tests::NodeApiTestFixture::RegisterNodeApiTests(); - return RUN_ALL_TESTS(); -} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/test_main.h b/Tests/NodeApi/test_main.h index e0f34c32..a4fe4532 100644 --- a/Tests/NodeApi/test_main.h +++ b/Tests/NodeApi/test_main.h @@ -4,20 +4,30 @@ #ifndef NODE_API_TEST_TEST_MAIN_H #define NODE_API_TEST_TEST_MAIN_H -#include -#include - -namespace node_api_tests { - -class TestFixtureBase : public ::testing::Test { - public: - static void InitializeGlobals(const char* test_exe_path) noexcept; - - protected: - static std::filesystem::path node_lite_path_; - static std::filesystem::path js_root_dir_; -}; - -} // namespace node_api_tests - -#endif // !NODE_API_TEST_TEST_MAIN_H \ No newline at end of file +#include +#include +#include +#include + +#include "child_process.h" + +namespace node_api_tests { + +struct NodeApiTestConfig { + std::filesystem::path js_root; + std::function run_script; + std::unordered_set enabled_native_suites; +}; + +void InitializeNodeApiTests(const NodeApiTestConfig& config) noexcept; +const NodeApiTestConfig& GetNodeApiTestConfig() noexcept; +void RegisterNodeApiTests(); + +class TestFixtureBase : public ::testing::Test { + protected: + static const NodeApiTestConfig& Config() noexcept; +}; + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_TEST_MAIN_H diff --git a/Tests/UnitTests/Android/app/build.gradle b/Tests/UnitTests/Android/app/build.gradle index c6137034..e9d7dcdd 100644 --- a/Tests/UnitTests/Android/app/build.gradle +++ b/Tests/UnitTests/Android/app/build.gradle @@ -22,6 +22,8 @@ if (project.hasProperty("importHostCompilers")) { cmakeArguments.add("-DIMPORT_HOST_COMPILERS=${project.property('importHostCompilers')}") } +def nodeApiAssetsDir = "${project.buildDir}/generated/nodeapiassets" + android { namespace 'com.jsruntimehost.unittests' compileSdk 33 @@ -72,6 +74,12 @@ android { buildFeatures { viewBinding true } + + sourceSets { + main { + assets.srcDirs += [nodeApiAssetsDir] + } + } } dependencies { @@ -108,6 +116,11 @@ task copyScripts { } } +task copyNodeApiTests(type: Copy) { + from '../../../NodeApi/test' + into "${nodeApiAssetsDir}/NodeApi/test" +} + // Run copyScripts task after CMake external build // And make sure merging assets into output is performed after the scripts copy tasks.configureEach { task -> @@ -116,5 +129,12 @@ tasks.configureEach { task -> } if (task.name == 'mergeDebugAssets') { task.dependsOn(copyScripts) + task.dependsOn(copyNodeApiTests) + } + if (task.name == 'mergeReleaseAssets') { + task.dependsOn(copyScripts) + task.dependsOn(copyNodeApiTests) } } + +preBuild.dependsOn(copyNodeApiTests) diff --git a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java index 23c22307..464bbdef 100644 --- a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java +++ b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java @@ -2,6 +2,8 @@ import android.content.Context; +import java.io.File; + import androidx.test.platform.app.InstrumentationRegistry; import androidx.test.ext.junit.runners.AndroidJUnit4; @@ -23,6 +25,10 @@ public void javaScriptTests() { Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); assertEquals("com.jsruntimehost.unittests", appContext.getPackageName()); - assertEquals(0, Native.javaScriptTests(appContext)); + Context applicationContext = appContext.getApplicationContext(); + File baseDir = new File(applicationContext.getFilesDir(), "node_api_tests"); + Native.prepareNodeApiTests(applicationContext, baseDir.getAbsolutePath()); + + assertEquals(0, Native.javaScriptTests(applicationContext)); } -} \ No newline at end of file +} diff --git a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java index 158c28e6..f8fa75ce 100644 --- a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java +++ b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java @@ -8,5 +8,6 @@ public class Native { System.loadLibrary("UnitTestsJNI"); } + public static native void prepareNodeApiTests(Context context, String baseDirPath); public static native int javaScriptTests(Context context); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..a789cee2 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -16,13 +16,31 @@ FetchContent_MakeAvailable_With_Message(googletest) npm(install --silent WORKING_DIRECTORY ${TESTS_DIR}) +set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_mac.cpp) +set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_mac.cpp) + +if(ANDROID) + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_android.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_android.cpp) +elseif(WIN32) + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_windows.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process.cpp) +endif() + add_library(UnitTestsJNI SHARED JNI.cpp ${UNIT_TESTS_DIR}/Shared/DelayedTaskScheduler.cpp ${UNIT_TESTS_DIR}/Shared/StandardStreamLogger.cpp ${UNIT_TESTS_DIR}/Shared/TimeoutDispatcher.cpp ${UNIT_TESTS_DIR}/Shared/Shared.h - ${UNIT_TESTS_DIR}/Shared/Shared.cpp) + ${UNIT_TESTS_DIR}/Shared/Shared.cpp + ${TESTS_DIR}/NodeApi/node_lite.cpp + ${NODE_LITE_PLATFORM_SRC} + ${NODE_LITE_CHILD_PROCESS_SRC} + ${TESTS_DIR}/NodeApi/node_lite_jsruntimehost.cpp + ${TESTS_DIR}/NodeApi/js_runtime_api.cpp + ${TESTS_DIR}/NodeApi/string_utils.cpp + ${TESTS_DIR}/NodeApi/test_main.cpp) if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") target_sources(UnitTestsJNI PRIVATE ${UNIT_TESTS_DIR}/Shared/V8ForegroundTaskRunner.cpp) @@ -34,7 +52,10 @@ target_compile_definitions(UnitTestsJNI PRIVATE NAPI_JAVASCRIPT_ENGINE="${NAPI_J target_compile_definitions(UnitTestsJNI PRIVATE ARCANA_TEST_HOOKS) target_include_directories(UnitTestsJNI - PRIVATE ${UNIT_TESTS_DIR}) + PRIVATE ${UNIT_TESTS_DIR} + PRIVATE ${TESTS_DIR}/NodeApi + PRIVATE ${TESTS_DIR}/NodeApi/include + PRIVATE ${REPO_ROOT_DIR}/Core/Node-API/Source) target_link_libraries(UnitTestsJNI PRIVATE log @@ -55,4 +76,11 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE napi) + +if(ANDROID) + target_link_libraries(UnitTestsJNI PRIVATE dl) +endif() +target_compile_definitions(UnitTestsJNI + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory") diff --git a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp index 85612af3..3d787057 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp +++ b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp @@ -2,6 +2,9 @@ #include #include #include +#include +#include +#include #include "Babylon/DebugTrace.h" #include "Babylon/StandardStreamLogger.h" #include @@ -24,6 +27,14 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz java::websocket::WebSocketClient::InitializeJavaWebSocketClass(webSocketClass, env); android::global::Initialize(javaVM, context); + jclass contextClass = env->GetObjectClass(context); + jmethodID getApplicationContext = env->GetMethodID(contextClass, "getApplicationContext", "()Landroid/content/Context;"); + jobject applicationContext = env->CallObjectMethod(context, getApplicationContext); + env->DeleteLocalRef(contextClass); + + android::global::Initialize(javaVM, applicationContext); + + env->DeleteLocalRef(applicationContext); Babylon::DebugTrace::EnableDebugTrace(true); Babylon::DebugTrace::SetTraceOutput([](const char* trace) { printf("%s\n", trace); fflush(stdout); }); @@ -31,12 +42,40 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz auto testResult = RunTests(); const bool loggerStopped = Babylon::StandardStreamLogger::Stop(); - if (!loggerStopped) + if (!loggerStopped) + { + __android_log_write(ANDROID_LOG_ERROR, "JsRuntimeHost", + "Failed to stop standard-stream forwarding (restore or drain timeout)."); + } + + java::websocket::WebSocketClient::DestructJavaWebSocketClass(env); + return loggerStopped ? testResult : -1; +} + +extern "C" JNIEXPORT void JNICALL +Java_com_jsruntimehost_unittests_Native_prepareNodeApiTests(JNIEnv* env, jclass, jobject context, jstring baseDirPath) +{ + AAssetManager* assetManager = nullptr; + if (context != nullptr) + { + jclass contextClass = env->GetObjectClass(context); + jmethodID getAssets = env->GetMethodID(contextClass, "getAssets", "()Landroid/content/res/AssetManager;"); + jobject assets = env->CallObjectMethod(context, getAssets); + env->DeleteLocalRef(contextClass); + if (assets != nullptr) { - __android_log_write(ANDROID_LOG_ERROR, "JsRuntimeHost", - "Failed to stop standard-stream forwarding (restore or drain timeout)."); + assetManager = AAssetManager_fromJava(env, assets); + env->DeleteLocalRef(assets); } + } - java::websocket::WebSocketClient::DestructJavaWebSocketClass(env); - return loggerStopped ? testResult : -1; + std::filesystem::path baseDir; + if (baseDirPath != nullptr) + { + const char* chars = env->GetStringUTFChars(baseDirPath, nullptr); + baseDir = chars; + env->ReleaseStringUTFChars(baseDirPath, chars); } + + SetNodeApiTestEnvironment(assetManager, baseDir); +} diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..012f3da1 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -21,9 +21,169 @@ #include #include #include +#include +#include +#include +#include +#include + +#if defined(__ANDROID__) +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "../../NodeApi/node_lite.h" +#include "../../NodeApi/test_main.h" +#endif namespace { +#if defined(__ANDROID__) + namespace + { + using namespace std::filesystem; + + void CopyAssetsRecursive(AAssetManager* manager, const std::string& asset_path, const path& destination) + { + AAssetDir* dir = AAssetManager_openDir(manager, asset_path.c_str()); + if (dir == nullptr) + { + return; + } + + const char* filename = nullptr; + while ((filename = AAssetDir_getNextFileName(dir)) != nullptr) + { + std::string child_asset = asset_path.empty() ? filename : asset_path + "/" + filename; + AAsset* asset = AAssetManager_open(manager, child_asset.c_str(), AASSET_MODE_STREAMING); + if (asset != nullptr) + { + create_directories(destination); + std::ofstream output(destination / filename, std::ios::binary); + char buffer[4096]; + int read = 0; + while ((read = AAsset_read(asset, buffer, sizeof(buffer))) > 0) + { + output.write(buffer, read); + } + AAsset_close(asset); + } + else + { + CopyAssetsRecursive(manager, child_asset, destination / filename); + } + } + + AAssetDir_close(dir); + } + + path GetFilesDir() + { + JNIEnv* env = android::global::GetEnvForCurrentThread(); + jobject context = android::global::GetAppContext(); + jclass contextClass = env->GetObjectClass(context); + jmethodID getFilesDir = env->GetMethodID(contextClass, "getFilesDir", "()Ljava/io/File;"); + jobject filesDir = env->CallObjectMethod(context, getFilesDir); + env->DeleteLocalRef(contextClass); + + jclass fileClass = env->GetObjectClass(filesDir); + jmethodID getAbsolutePath = env->GetMethodID(fileClass, "getAbsolutePath", "()Ljava/lang/String;"); + jstring pathString = static_cast(env->CallObjectMethod(filesDir, getAbsolutePath)); + env->DeleteLocalRef(fileClass); + + const char* rawPath = env->GetStringUTFChars(pathString, nullptr); + path resultPath{rawPath}; + env->ReleaseStringUTFChars(pathString, rawPath); + env->DeleteLocalRef(pathString); + env->DeleteLocalRef(filesDir); + + return resultPath; + } + + std::unordered_set ParseNativeSuiteList() + { + std::unordered_set suites; +#ifdef NODE_API_AVAILABLE_NATIVE_TESTS + std::stringstream stream(NODE_API_AVAILABLE_NATIVE_TESTS); + std::string entry; + while (std::getline(stream, entry, ',')) + { + if (!entry.empty()) + { + suites.insert(entry); + } + } +#endif + return suites; + } + + std::optional& OverrideBaseDir() + { + static std::optional baseDirOverride{}; + return baseDirOverride; + } + + AAssetManager*& OverrideAssetManager() + { + static AAssetManager* assetManager{}; + return assetManager; + } + + void ConfigureNodeApiTests() + { + static std::once_flag onceFlag; + std::call_once(onceFlag, []() { + path baseDir; + if (OverrideBaseDir()) + { + baseDir = *OverrideBaseDir(); + } + else + { + baseDir = GetFilesDir() / "node_api_tests"; + } + std::error_code ec; + std::filesystem::remove_all(baseDir, ec); + std::filesystem::create_directories(baseDir); + + AAssetManager* assetManagerNative = OverrideAssetManager(); + if (assetManagerNative == nullptr) + { + auto assetManagerWrapper = android::global::GetAppContext().getAssets(); + assetManagerNative = assetManagerWrapper; + } + + if (assetManagerNative != nullptr) + { + CopyAssetsRecursive(assetManagerNative, "NodeApi/test", baseDir); + } + + node_api_tests::NodeApiTestConfig config{}; + config.js_root = baseDir; + config.run_script = [baseDir](const path& script) { + node_api_tests::NodeLiteRuntime::Callbacks callbacks; + callbacks.stdout_callback = [](const std::string& message) { + __android_log_write(ANDROID_LOG_INFO, "NodeApiTests", message.c_str()); + }; + callbacks.stderr_callback = [](const std::string& message) { + __android_log_write(ANDROID_LOG_ERROR, "NodeApiTests", message.c_str()); + }; + return node_api_tests::RunNodeLiteScript(baseDir, script, std::move(callbacks)); + }; + config.enabled_native_suites = ParseNativeSuiteList(); + + node_api_tests::InitializeNodeApiTests(config); + }); + } + } +#endif + const char* EnumToString(Babylon::Polyfills::Console::LogLevel logLevel) { switch (logLevel) @@ -831,6 +991,19 @@ TEST(NodeApi, AdjacentEscapableScopesEscapeIndependently) int RunTests() { +#if defined(__ANDROID__) + ConfigureNodeApiTests(); +#endif testing::InitGoogleTest(); +#if defined(__ANDROID__) + node_api_tests::RegisterNodeApiTests(); +#endif return RUN_ALL_TESTS(); } +#if defined(__ANDROID__) +void SetNodeApiTestEnvironment(AAssetManager* assetManager, const std::filesystem::path& baseDir) +{ + OverrideAssetManager() = assetManager; + OverrideBaseDir() = baseDir; +} +#endif diff --git a/Tests/UnitTests/Shared/Shared.h b/Tests/UnitTests/Shared/Shared.h index b1610fa8..14abef97 100644 --- a/Tests/UnitTests/Shared/Shared.h +++ b/Tests/UnitTests/Shared/Shared.h @@ -1,3 +1,10 @@ #pragma once -int RunTests(); \ No newline at end of file +#include + +int RunTests(); + +#if defined(__ANDROID__) +struct AAssetManager; +void SetNodeApiTestEnvironment(AAssetManager* assetManager, const std::filesystem::path& baseDir); +#endif diff --git a/Tests/package-lock.json b/Tests/package-lock.json index eccda69f..50d2b9cc 100644 --- a/Tests/package-lock.json +++ b/Tests/package-lock.json @@ -97,6 +97,7 @@ "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@babel/code-frame": "^7.29.0", "@babel/generator": "^7.29.0", @@ -2395,6 +2396,7 @@ "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", "dev": true, "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -2421,6 +2423,7 @@ "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", @@ -2709,6 +2712,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "baseline-browser-mapping": "^2.10.12", "caniuse-lite": "^1.0.30001782", @@ -5207,6 +5211,7 @@ "integrity": "sha512-EW8af29ak8Oaf4T8k8YsajjrDBDYgnKZ5er6ljWFJsXABfTNowQfvHLftwcepVgdz+IoLSdEAbBiM9DFXoll9w==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.8", @@ -5256,6 +5261,7 @@ "integrity": "sha512-MfwFQ6SfwinsUVi0rNJm7rHZ31GyTcpVE5pgVA3hwFRb7COD4TzjUUwhGWKfO50+xdc2MQPuEBBJoqIMGt3JDw==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@discoveryjs/json-ext": "^0.6.1", "@webpack-cli/configtest": "^3.0.1", From 8c421aeba4115be416a4b4f46d852d857f60d665 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 12 Oct 2025 17:09:47 -0700 Subject: [PATCH 004/174] Run the macOS NodeApiTests under sanitizers, which found another bug -- a use-after-free. Will check sanitizers under Android next --- .../Source/js_native_api_javascriptcore.cc | 3 ++ .../Source/js_native_api_javascriptcore.h | 2 + Tests/NodeApi/CMakeLists.txt | 12 +++--- Tests/NodeApi/node_lite_jsruntimehost.cpp | 9 ++-- Tests/NodeApi/node_lite_windows.cpp | 3 +- Tests/UnitTests/Android/app/build.gradle | 13 +++++- .../com/jsruntimehost/unittests/Main.java | 5 --- .../com/jsruntimehost/unittests/Native.java | 1 - .../Android/app/src/main/cpp/CMakeLists.txt | 12 +++--- .../Android/app/src/main/cpp/JNI.cpp | 42 +++++-------------- Tests/UnitTests/Shared/Shared.cpp | 1 - Tests/UnitTests/Shared/Shared.h | 5 --- 12 files changed, 47 insertions(+), 61 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 4cebad54..66c8fbe7 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -740,6 +740,9 @@ struct napi_ref__ { CHECK_NAPI(ReferenceInfo::GetObjectId(env, _value, &_objectId)); if (_objectId == 0) { CHECK_NAPI(ReferenceInfo::Initialize(env, _value, [value = _value](ReferenceInfo* info) { + if (info->Env()->shutting_down) { + return; + } auto entry{info->Env()->active_ref_values.find(value)}; // NOTE: The finalizer callback is actually on a "sentinel" JS object that is linked to the // actual JS object we are trying to track. This means it is possible for the tracked object diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 8d8dbd02..1a1a533c 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -15,6 +15,7 @@ struct napi_env__ { napi_extended_error_info last_error{nullptr, nullptr, 0, napi_ok}; std::unordered_map active_ref_values{}; std::list strong_refs{}; + bool shutting_down{false}; JSValueRef constructor_info_symbol{}; JSValueRef function_info_symbol{}; @@ -41,6 +42,7 @@ struct napi_env__ { } ~napi_env__() { + shutting_down = true; deinit_refs(); deinit_symbol(wrapper_info_symbol); deinit_symbol(reference_info_symbol); diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 1c4ce785..6b329067 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -21,17 +21,17 @@ function(node_api_copy_test_sources TARGET_NAME) endfunction() if(ANDROID) - set(NODE_LITE_PLATFORM_SRC node_lite_android.cpp) - set(NODE_LITE_CHILD_PROCESS_SRC child_process_android.cpp) + set(NODE_LITE_PLATFORM_SRC node_lite_posix.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_posix.cpp) elseif(APPLE) - set(NODE_LITE_PLATFORM_SRC node_lite_mac.cpp) - set(NODE_LITE_CHILD_PROCESS_SRC child_process_mac.cpp) + set(NODE_LITE_PLATFORM_SRC node_lite_posix.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_posix.cpp) elseif(WIN32) set(NODE_LITE_PLATFORM_SRC node_lite_windows.cpp) set(NODE_LITE_CHILD_PROCESS_SRC child_process.cpp) else() - set(NODE_LITE_PLATFORM_SRC node_lite_mac.cpp) - set(NODE_LITE_CHILD_PROCESS_SRC child_process_mac.cpp) + set(NODE_LITE_PLATFORM_SRC node_lite_posix.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC child_process_posix.cpp) message(WARNING "Node-API node_lite platform not yet customized for ${CMAKE_SYSTEM_NAME}; using POSIX defaults.") endif() diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index 3e47e621..1c524f53 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -68,11 +68,14 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { } } + if (context_ != nullptr) { + JSGlobalContextRelease(context_); + context_ = nullptr; + } + Napi::Detach(napiEnv); env_ = nullptr; - } - - if (context_ != nullptr) { + } else if (context_ != nullptr) { JSGlobalContextRelease(context_); context_ = nullptr; } diff --git a/Tests/NodeApi/node_lite_windows.cpp b/Tests/NodeApi/node_lite_windows.cpp index 6b41d83a..4af34561 100644 --- a/Tests/NodeApi/node_lite_windows.cpp +++ b/Tests/NodeApi/node_lite_windows.cpp @@ -2,8 +2,7 @@ // Licensed under the MIT License. #include -#include "node_lite.h" -#include "string_utils.h" +#include "node_lite.h" namespace node_api_tests { diff --git a/Tests/UnitTests/Android/app/build.gradle b/Tests/UnitTests/Android/app/build.gradle index e9d7dcdd..fc3002de 100644 --- a/Tests/UnitTests/Android/app/build.gradle +++ b/Tests/UnitTests/Android/app/build.gradle @@ -23,6 +23,7 @@ if (project.hasProperty("importHostCompilers")) { } def nodeApiAssetsDir = "${project.buildDir}/generated/nodeapiassets" +def enableAsan = project.hasProperty("enableAsan") android { namespace 'com.jsruntimehost.unittests' @@ -43,7 +44,11 @@ android { externalNativeBuild { cmake { - arguments(*cmakeArguments) + def cmakeArgs = cmakeArguments.clone() + if (enableAsan) { + cmakeArgs += "-DJSR_ENABLE_ASAN=ON" + } + arguments(*cmakeArgs) } } @@ -75,6 +80,12 @@ android { viewBinding true } + packagingOptions { + if (enableAsan) { + doNotStrip "**/*.so" + } + } + sourceSets { main { assets.srcDirs += [nodeApiAssetsDir] diff --git a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java index 464bbdef..069c698d 100644 --- a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java +++ b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Main.java @@ -2,8 +2,6 @@ import android.content.Context; -import java.io.File; - import androidx.test.platform.app.InstrumentationRegistry; import androidx.test.ext.junit.runners.AndroidJUnit4; @@ -26,9 +24,6 @@ public void javaScriptTests() { assertEquals("com.jsruntimehost.unittests", appContext.getPackageName()); Context applicationContext = appContext.getApplicationContext(); - File baseDir = new File(applicationContext.getFilesDir(), "node_api_tests"); - Native.prepareNodeApiTests(applicationContext, baseDir.getAbsolutePath()); - assertEquals(0, Native.javaScriptTests(applicationContext)); } } diff --git a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java index f8fa75ce..158c28e6 100644 --- a/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java +++ b/Tests/UnitTests/Android/app/src/androidTest/java/com/jsruntimehost/unittests/Native.java @@ -8,6 +8,5 @@ public class Native { System.loadLibrary("UnitTestsJNI"); } - public static native void prepareNodeApiTests(Context context, String baseDirPath); public static native int javaScriptTests(Context context); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index a789cee2..ffb61153 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -16,15 +16,15 @@ FetchContent_MakeAvailable_With_Message(googletest) npm(install --silent WORKING_DIRECTORY ${TESTS_DIR}) -set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_mac.cpp) -set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_mac.cpp) +set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_posix.cpp) +set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) -if(ANDROID) - set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_android.cpp) - set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_android.cpp) -elseif(WIN32) +if(WIN32) set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_windows.cpp) set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process.cpp) +elseif(APPLE) + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_mac.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_mac.cpp) endif() add_library(UnitTestsJNI SHARED diff --git a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp index 3d787057..502da955 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp +++ b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp @@ -2,8 +2,6 @@ #include #include #include -#include -#include #include #include "Babylon/DebugTrace.h" #include "Babylon/StandardStreamLogger.h" @@ -32,7 +30,17 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz jobject applicationContext = env->CallObjectMethod(context, getApplicationContext); env->DeleteLocalRef(contextClass); - android::global::Initialize(javaVM, applicationContext); + jclass appContextClass = env->GetObjectClass(applicationContext); + jmethodID getAssets = env->GetMethodID(appContextClass, "getAssets", "()Landroid/content/res/AssetManager;"); + jobject assetManagerObj = env->CallObjectMethod(applicationContext, getAssets); + env->DeleteLocalRef(appContextClass); + + android::global::Initialize(javaVM, applicationContext, assetManagerObj); + + if (assetManagerObj != nullptr) + { + env->DeleteLocalRef(assetManagerObj); + } env->DeleteLocalRef(applicationContext); @@ -51,31 +59,3 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz java::websocket::WebSocketClient::DestructJavaWebSocketClass(env); return loggerStopped ? testResult : -1; } - -extern "C" JNIEXPORT void JNICALL -Java_com_jsruntimehost_unittests_Native_prepareNodeApiTests(JNIEnv* env, jclass, jobject context, jstring baseDirPath) -{ - AAssetManager* assetManager = nullptr; - if (context != nullptr) - { - jclass contextClass = env->GetObjectClass(context); - jmethodID getAssets = env->GetMethodID(contextClass, "getAssets", "()Landroid/content/res/AssetManager;"); - jobject assets = env->CallObjectMethod(context, getAssets); - env->DeleteLocalRef(contextClass); - if (assets != nullptr) - { - assetManager = AAssetManager_fromJava(env, assets); - env->DeleteLocalRef(assets); - } - } - - std::filesystem::path baseDir; - if (baseDirPath != nullptr) - { - const char* chars = env->GetStringUTFChars(baseDirPath, nullptr); - baseDir = chars; - env->ReleaseStringUTFChars(baseDirPath, chars); - } - - SetNodeApiTestEnvironment(assetManager, baseDir); -} diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 012f3da1..f2ea0713 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -22,7 +22,6 @@ #include #include #include -#include #include #include #include diff --git a/Tests/UnitTests/Shared/Shared.h b/Tests/UnitTests/Shared/Shared.h index 14abef97..acc4548b 100644 --- a/Tests/UnitTests/Shared/Shared.h +++ b/Tests/UnitTests/Shared/Shared.h @@ -3,8 +3,3 @@ #include int RunTests(); - -#if defined(__ANDROID__) -struct AAssetManager; -void SetNodeApiTestEnvironment(AAssetManager* assetManager, const std::filesystem::path& baseDir); -#endif From c43e50d5ee74407965bcba3f41db77ef2f790256 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 15 Oct 2025 14:29:56 -0700 Subject: [PATCH 005/174] Fix build errors. This deduplicates struct definitions that were inlined into our copy of the JSI code. --- Core/Node-API-JSI/Include/napi/napi.h | 37 +----- Tests/NodeApi/child_process_mac.cpp | 166 -------------------------- Tests/NodeApi/node_lite.cpp | 1 + Tests/NodeApi/node_lite_mac.cpp | 39 ------ 4 files changed, 2 insertions(+), 241 deletions(-) delete mode 100644 Tests/NodeApi/child_process_mac.cpp delete mode 100644 Tests/NodeApi/node_lite_mac.cpp diff --git a/Core/Node-API-JSI/Include/napi/napi.h b/Core/Node-API-JSI/Include/napi/napi.h index 76342bc6..cec68d71 100644 --- a/Core/Node-API-JSI/Include/napi/napi.h +++ b/Core/Node-API-JSI/Include/napi/napi.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include @@ -8,42 +9,6 @@ #include #include -// Copied from js_native_api_types.h (https://git.io/J8aI5) -typedef enum { - napi_default = 0, - napi_writable = 1 << 0, - napi_enumerable = 1 << 1, - napi_configurable = 1 << 2, -} napi_property_attributes; - -typedef enum { - // ES6 types (corresponds to typeof) - napi_undefined, - napi_null, - napi_boolean, - napi_number, - napi_string, - napi_symbol, - napi_object, - napi_function, - napi_external, -} napi_valuetype; - -typedef enum { - napi_int8_array, - napi_uint8_array, - napi_uint8_clamped_array, - napi_int16_array, - napi_uint16_array, - napi_int32_array, - napi_uint32_array, - napi_float32_array, - napi_float64_array, - // JSI doesn't support bigint. - // napi_bigint64_array, - // napi_biguint64_array, -} napi_typedarray_type; - struct napi_env__ { napi_env__(facebook::jsi::Runtime& rt) : rt{rt} diff --git a/Tests/NodeApi/child_process_mac.cpp b/Tests/NodeApi/child_process_mac.cpp deleted file mode 100644 index 8e5f0d18..00000000 --- a/Tests/NodeApi/child_process_mac.cpp +++ /dev/null @@ -1,166 +0,0 @@ -#include "child_process.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// Verify the condition. -// - If true, resume execution. -// - If false, print a message to stderr and exit the app with exit code 1. -#ifndef VerifyElseExit -#define VerifyElseExit(condition) \ - do { \ - if (!(condition)) { \ - ExitOnError(#condition, nullptr); \ - } \ - } while (false) -#endif - -// Verify the condition. -// - If true, resume execution. -// - If false, destroy the passed `posix_spawn_file_actions_t* actions`, then -// print a message to stderr and exit the app with exit code 1. -#ifndef VerifyElseExitWithCleanup -#define VerifyElseExitWithCleanup(condition, actions_ptr) \ - do { \ - if (!(condition)) { \ - ExitOnError(#condition, actions_ptr); \ - } \ - } while (false) -#endif - -extern char** environ; - -namespace node_api_tests { - -namespace { - -std::string ReadFromFd(int fd); -void ExitOnError(const char* message, posix_spawn_file_actions_t* actions); - -} // namespace - -ProcessResult SpawnSync(std::string_view command, - std::vector args) { - ProcessResult result{}; - - // These int arrays each comprise two file descriptors: { readEnd, writeEnd }. - int stdout_pipe[2], stderr_pipe[2]; - VerifyElseExit(pipe(stdout_pipe) == 0); - VerifyElseExit(pipe(stderr_pipe) == 0); - - posix_spawn_file_actions_t actions; - VerifyElseExit(posix_spawn_file_actions_init(&actions) == 0); - - VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( - &actions, stdout_pipe[1], STDOUT_FILENO) == 0, - &actions); - VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( - &actions, stderr_pipe[1], STDERR_FILENO) == 0, - &actions); - - VerifyElseExitWithCleanup( - posix_spawn_file_actions_addclose(&actions, stdout_pipe[0]) == 0, - &actions); - VerifyElseExitWithCleanup( - posix_spawn_file_actions_addclose(&actions, stderr_pipe[0]) == 0, - &actions); - - std::vector argv; - argv.push_back(strdup(std::string(command).c_str())); - for (const std::string& arg : args) { - argv.push_back(strdup(arg.c_str())); - } - argv.push_back(nullptr); - - pid_t pid; - VerifyElseExitWithCleanup( - posix_spawnp(&pid, argv[0], &actions, nullptr, argv.data(), environ) == 0, - &actions); - - posix_spawn_file_actions_destroy(&actions); - - // Close the write ends of the pipes. - close(stdout_pipe[1]); - close(stderr_pipe[1]); - - int wait_status; - pid_t waited_pid; - do { - waited_pid = waitpid(pid, &wait_status, 0); - } while (waited_pid == -1 && errno == EINTR); - - VerifyElseExit(waited_pid == pid); - - if (WIFEXITED(wait_status)) { - result.status = WEXITSTATUS(wait_status); - } else if (WIFSIGNALED(wait_status)) { - result.status = 128 + WTERMSIG(wait_status); - } else { - result.status = 1; - } - result.std_output = ReadFromFd(stdout_pipe[0]); - result.std_error = ReadFromFd(stderr_pipe[0]); - - // Close the read ends of the pipes. - close(stdout_pipe[0]); - close(stderr_pipe[0]); - - for (char* arg : argv) { - free(arg); - } - - return result; -} - -namespace { - -std::string ReadFromFd(int fd) { - std::string result; - constexpr size_t bufferSize = 4096; - char buffer[bufferSize]; - ssize_t bytesRead; - while (true) { - bytesRead = read(fd, buffer, bufferSize); - if (bytesRead > 0) { - result.append(buffer, bytesRead); - continue; - } - - if (bytesRead == 0) { - break; - } - - if (errno == EINTR) { - continue; - } - - ExitOnError("read", nullptr); - } - return result; -} - -// Format a readable error message, print it to console, and exit from the -// application. -void ExitOnError(const char* message, posix_spawn_file_actions_t* actions) { - int err = errno; - const char* err_msg = strerror(err); - - fprintf(stderr, "%s failed with error %d: %s\n", message, err, err_msg); - - if (actions != nullptr) { - posix_spawn_file_actions_destroy(actions); - } - - exit(1); -} - -} // namespace -} // namespace node_api_tests diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index d82f3bb2..0db78f9b 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include diff --git a/Tests/NodeApi/node_lite_mac.cpp b/Tests/NodeApi/node_lite_mac.cpp deleted file mode 100644 index ce8ffb17..00000000 --- a/Tests/NodeApi/node_lite_mac.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -#include -#include "node_lite.h" -#include "string_utils.h" - -namespace node_api_tests { - -//============================================================================= -// NodeLitePlatform implementation -//============================================================================= - -/*static*/ void* NodeLitePlatform::LoadFunction( - napi_env env, - const std::filesystem::path& lib_path, - const std::string& function_name) noexcept { - void* library_handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); - if (library_handle == nullptr) { - const char* error_message = dlerror(); - NODE_LITE_ASSERT(false, - "Failed to load dynamic library: %s. Error: %s", - lib_path.c_str(), - error_message != nullptr ? error_message : "Unknown error"); - return nullptr; - } - - dlerror(); // Clear any existing error state before dlsym. - void* symbol = dlsym(library_handle, function_name.c_str()); - const char* error_message = dlerror(); - NODE_LITE_ASSERT(error_message == nullptr, - "Failed to resolve symbol: %s in %s. Error: %s", - function_name.c_str(), - lib_path.c_str(), - error_message != nullptr ? error_message : "Unknown error"); - return symbol; -} - -} // namespace node_api_tests From a1f422d698f19a91becb6a23b6c710563c020395 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 15 Oct 2025 21:03:50 -0700 Subject: [PATCH 006/174] always build the napi tests --- CMakeLists.txt | 15 + Core/Node-API/CMakeLists.txt | 5 +- Tests/NodeApi/CMakeLists.txt | 31 +- Tests/NodeApi/child_process_android.cpp | 14 + Tests/NodeApi/child_process_posix.cpp | 189 ++++++ Tests/NodeApi/main.cpp | 81 +++ Tests/NodeApi/node_lite.cpp | 598 +++++++++--------- Tests/NodeApi/node_lite_android.cpp | 22 + Tests/NodeApi/node_lite_posix.cpp | 43 ++ Tests/UnitTests/Android/app/build.gradle | 69 ++ .../Android/app/src/main/cpp/CMakeLists.txt | 13 +- Tests/UnitTests/Android/gradle.properties | 2 +- 12 files changed, 762 insertions(+), 320 deletions(-) create mode 100644 Tests/NodeApi/child_process_android.cpp create mode 100644 Tests/NodeApi/child_process_posix.cpp create mode 100644 Tests/NodeApi/main.cpp create mode 100644 Tests/NodeApi/node_lite_android.cpp create mode 100644 Tests/NodeApi/node_lite_posix.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..7179bfb9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -154,6 +154,21 @@ endif() FetchContent_MakeAvailable_With_Message(arcana.cpp) set_property(TARGET arcana PROPERTY FOLDER Dependencies) +if(ANDROID) + FetchContent_GetProperties(AndroidExtensions) + if(NOT AndroidExtensions_POPULATED) + FetchContent_Populate(AndroidExtensions) + FetchContent_GetProperties(AndroidExtensions) + message(STATUS "Patching AndroidExtensions Globals.cpp in ${androidextensions_SOURCE_DIR}") + file(COPY + ${CMAKE_CURRENT_SOURCE_DIR}/patches/AndroidExtensions/Globals.cpp + DESTINATION ${androidextensions_SOURCE_DIR}/Source) + add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR}) + else() + add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR}) + endif() +endif() + if(JSRUNTIMEHOST_POLYFILL_XMLHTTPREQUEST OR JSRUNTIMEHOST_POLYFILL_FETCH) FetchContent_MakeAvailable_With_Message(UrlLib) set_property(TARGET UrlLib PROPERTY FOLDER Dependencies) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index 5f495695..96ad4216 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -7,7 +7,10 @@ elseif(ANDROID) set(NAPI_JAVASCRIPT_ENGINE "V8" CACHE STRING "JavaScript engine for Node-API") elseif(UNIX) set(NAPI_JAVASCRIPT_ENGINE "JavaScriptCore" CACHE STRING "JavaScript engine for Node-API") - set(JAVASCRIPTCORE_LIBRARY "/usr/lib/x86_64-linux-gnu/libjavascriptcoregtk-4.1.so" CACHE STRING "Path to the JavaScriptCore shared library") + find_library(JAVASCRIPTCORE_LIBRARY javascriptcoregtk-4.1) + if(NOT JAVASCRIPTCORE_LIBRARY) + message(FATAL_ERROR "JavaScriptCore library not found. Please install libwebkit2gtk-4.1-dev") + endif() else() message(FATAL_ERROR "Unable to select Node-API JavaScript engine for platform") endif() diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 6b329067..256782ae 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -1,15 +1,13 @@ set(NODE_API_TEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR}) -option(JSR_NODE_API_BUILD_NATIVE_TESTS "Build Node-API native addon test modules" OFF) +option(JSR_NODE_API_BUILD_NATIVE_TESTS "Build Node-API native addon test modules" ON) -if(JSR_NODE_API_BUILD_NATIVE_TESTS) - set(JSR_NODE_API_NATIVE_TEST_DIRS - 2_function_arguments - 3_callbacks - 4_object_factory - 5_function_factory - ) -endif() +set(JSR_NODE_API_NATIVE_TEST_DIRS + 2_function_arguments + 3_callbacks + 4_object_factory + 5_function_factory +) function(node_api_copy_test_sources TARGET_NAME) add_custom_command(TARGET ${TARGET_NAME} POST_BUILD @@ -98,17 +96,26 @@ add_dependencies(NodeApiTests node_lite) add_custom_target(NodeApiModules) +# Always define which tests are available, regardless of whether we build the native modules +list(JOIN JSR_NODE_API_NATIVE_TEST_DIRS "," NODE_API_NATIVE_TESTS_STRING) +target_compile_definitions(node_lite + PRIVATE + NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" +) +target_compile_definitions(NodeApiTests + PRIVATE + NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" +) + +# Only define NODE_API_TESTS_HAVE_NATIVE_MODULES when actually building native modules if(JSR_NODE_API_BUILD_NATIVE_TESTS) - list(JOIN JSR_NODE_API_NATIVE_TEST_DIRS "," NODE_API_NATIVE_TESTS_STRING) target_compile_definitions(node_lite PRIVATE NODE_API_TESTS_HAVE_NATIVE_MODULES=1 - NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" ) target_compile_definitions(NodeApiTests PRIVATE NODE_API_TESTS_HAVE_NATIVE_MODULES=1 - NODE_API_AVAILABLE_NATIVE_TESTS=\"${NODE_API_NATIVE_TESTS_STRING}\" ) endif() diff --git a/Tests/NodeApi/child_process_android.cpp b/Tests/NodeApi/child_process_android.cpp new file mode 100644 index 00000000..cb70ccd1 --- /dev/null +++ b/Tests/NodeApi/child_process_android.cpp @@ -0,0 +1,14 @@ +#include "child_process.h" + +namespace node_api_tests { + +ProcessResult SpawnSync(std::string_view /*command*/, std::vector /*args*/) +{ + ProcessResult result{}; + result.status = -1; + result.std_error = "child_process.spawnSync is not supported on this platform."; + result.std_output.clear(); + return result; +} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/child_process_posix.cpp b/Tests/NodeApi/child_process_posix.cpp new file mode 100644 index 00000000..bc461b0e --- /dev/null +++ b/Tests/NodeApi/child_process_posix.cpp @@ -0,0 +1,189 @@ +#include "child_process.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__ANDROID__) +#include +#endif + +#if !defined(__ANDROID__) +#include +#elif (__ANDROID_API__ >= 29) +#include +#endif + +#ifndef VerifyElseExit +#define VerifyElseExit(condition) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition, nullptr); \ + } \ + } while (false) +#endif + +#ifndef VerifyElseExitWithCleanup +#define VerifyElseExitWithCleanup(condition, actions_ptr) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition, actions_ptr); \ + } \ + } while (false) +#endif + +#if defined(__ANDROID__) && (__ANDROID_API__ < 29) + +namespace node_api_tests { + +ProcessResult SpawnSync(std::string_view /*command*/, + std::vector /*args*/) { + ProcessResult result{}; + result.status = -1; + result.std_error = "child_process.spawnSync is not supported on this platform."; + result.std_output.clear(); + return result; +} + +} // namespace node_api_tests + +#else + +extern char** environ; + +namespace node_api_tests { + +namespace { + +std::string ReadFromFd(int fd); +void ExitOnError(const char* message, posix_spawn_file_actions_t* actions); + +} // namespace + +ProcessResult SpawnSync(std::string_view command, + std::vector args) { + ProcessResult result{}; + + // These int arrays each comprise two file descriptors: { readEnd, writeEnd }. + int stdout_pipe[2], stderr_pipe[2]; + VerifyElseExit(pipe(stdout_pipe) == 0); + VerifyElseExit(pipe(stderr_pipe) == 0); + + posix_spawn_file_actions_t actions; + VerifyElseExit(posix_spawn_file_actions_init(&actions) == 0); + + VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( + &actions, stdout_pipe[1], STDOUT_FILENO) == 0, + &actions); + VerifyElseExitWithCleanup(posix_spawn_file_actions_adddup2( + &actions, stderr_pipe[1], STDERR_FILENO) == 0, + &actions); + + VerifyElseExitWithCleanup( + posix_spawn_file_actions_addclose(&actions, stdout_pipe[0]) == 0, + &actions); + VerifyElseExitWithCleanup( + posix_spawn_file_actions_addclose(&actions, stderr_pipe[0]) == 0, + &actions); + + std::vector argv; + argv.push_back(strdup(std::string(command).c_str())); + for (const std::string& arg : args) { + argv.push_back(strdup(arg.c_str())); + } + argv.push_back(nullptr); + + pid_t pid; + VerifyElseExitWithCleanup( + posix_spawnp(&pid, argv[0], &actions, nullptr, argv.data(), environ) == 0, + &actions); + + posix_spawn_file_actions_destroy(&actions); + + // Close the write ends of the pipes. + close(stdout_pipe[1]); + close(stderr_pipe[1]); + + int wait_status; + pid_t waited_pid; + do { + waited_pid = waitpid(pid, &wait_status, 0); + } while (waited_pid == -1 && errno == EINTR); + + VerifyElseExit(waited_pid == pid); + + if (WIFEXITED(wait_status)) { + result.status = WEXITSTATUS(wait_status); + } else if (WIFSIGNALED(wait_status)) { + result.status = 128 + WTERMSIG(wait_status); + } else { + result.status = 1; + } + result.std_output = ReadFromFd(stdout_pipe[0]); + result.std_error = ReadFromFd(stderr_pipe[0]); + + // Close the read ends of the pipes. + close(stdout_pipe[0]); + close(stderr_pipe[0]); + + for (char* arg : argv) { + free(arg); + } + + return result; +} + +namespace { + +std::string ReadFromFd(int fd) { + std::string result; + constexpr size_t bufferSize = 4096; + char buffer[bufferSize]; + ssize_t bytesRead; + while (true) { + bytesRead = read(fd, buffer, bufferSize); + if (bytesRead > 0) { + result.append(buffer, bytesRead); + continue; + } + + if (bytesRead == 0) { + break; + } + + if (errno == EINTR) { + continue; + } + + ExitOnError("read", nullptr); + } + return result; +} + +// Format a readable error message, print it to console, and exit from the +// application. +void ExitOnError(const char* message, posix_spawn_file_actions_t* actions) { + int err = errno; + const char* err_msg = strerror(err); + + fprintf(stderr, "%s failed with error %d: %s\n", message, err, err_msg); + + if (actions != nullptr) { + posix_spawn_file_actions_destroy(actions); + } + + exit(1); +} + +} // namespace + +} // namespace node_api_tests + +#endif // __ANDROID__ diff --git a/Tests/NodeApi/main.cpp b/Tests/NodeApi/main.cpp new file mode 100644 index 00000000..1565693c --- /dev/null +++ b/Tests/NodeApi/main.cpp @@ -0,0 +1,81 @@ +#include "test_main.h" + +#include + +#include +#include +#include +#include + +#include "child_process.h" + +namespace fs = std::filesystem; + +namespace { + +fs::path ResolveNodeLitePath(const fs::path& exe_path) { + fs::path nodeLitePath = exe_path; + nodeLitePath.replace_filename("node_lite"); +#if defined(_WIN32) + nodeLitePath += ".exe"; +#endif + return nodeLitePath; +} + +fs::path ResolveTestsRoot(const fs::path& exe_path) { + fs::path testRootPath = exe_path.parent_path(); + fs::path js_root = testRootPath / "test"; + if (!fs::exists(js_root)) { + testRootPath = testRootPath.parent_path(); + js_root = testRootPath / "test"; + } + return js_root; +} + +std::unordered_set ParseEnabledNativeSuites() { + std::unordered_set suites; +#ifdef NODE_API_AVAILABLE_NATIVE_TESTS + std::stringstream stream(NODE_API_AVAILABLE_NATIVE_TESTS); + std::string entry; + while (std::getline(stream, entry, ',')) { + if (!entry.empty()) { + suites.insert(entry); + } + } +#endif + return suites; +} + +} // namespace + +int main(int argc, char** argv) { + fs::path exe_path = fs::canonical(argv[0]); + fs::path js_root = ResolveTestsRoot(exe_path); + if (!fs::exists(js_root)) { + std::cerr << "Error: Cannot find Node-API test directory." << std::endl; + return EXIT_FAILURE; + } + + fs::path node_lite_path = ResolveNodeLitePath(exe_path); + if (!fs::exists(node_lite_path)) { + std::cerr << "Error: Cannot find node_lite executable at " + << node_lite_path << std::endl; + return EXIT_FAILURE; + } + + node_api_tests::NodeApiTestConfig config{}; + config.js_root = js_root; + config.run_script = + [node_lite_path](const fs::path& script_path) + -> node_api_tests::ProcessResult { + return node_api_tests::SpawnSync(node_lite_path.string(), + {script_path.string()}); + }; + config.enabled_native_suites = ParseEnabledNativeSuites(); + + node_api_tests::InitializeNodeApiTests(config); + + ::testing::InitGoogleTest(&argc, argv); + node_api_tests::RegisterNodeApiTests(); + return RUN_ALL_TESTS(); +} diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 0db78f9b..e7e6ffaf 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -1,51 +1,51 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -#include "node_lite.h" -#include "js_runtime_api.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "child_process.h" +#include "node_lite.h" +#include "js_runtime_api.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "child_process.h" namespace fs = std::filesystem; namespace node_api_tests { -namespace { - -std::mutex& ErrorHandlerMutex() { - static std::mutex mutex; - return mutex; -} - -void DefaultFatalErrorHandler(const NodeLiteFatalErrorInfo& info) { - if (!info.message.empty()) { - std::cerr << info.message; - if (!info.details.empty()) { - std::cerr << '\n' << info.details; - } - std::cerr << std::endl; - } else if (!info.details.empty()) { - std::cerr << info.details << std::endl; - } - std::exit(info.exit_code); -} - -NodeApiRef MakeNodeApiRef(napi_env env, napi_value value) { - napi_ref ref{}; - NODE_LITE_CALL(napi_create_reference(env, value, 1, &ref)); - return NodeApiRef(ref, NodeApiRefDeleter(env)); +namespace { + +std::mutex& ErrorHandlerMutex() { + static std::mutex mutex; + return mutex; +} + +void DefaultFatalErrorHandler(const NodeLiteFatalErrorInfo& info) { + if (!info.message.empty()) { + std::cerr << info.message; + if (!info.details.empty()) { + std::cerr << '\n' << info.details; + } + std::cerr << std::endl; + } else if (!info.details.empty()) { + std::cerr << info.details << std::endl; + } + std::exit(info.exit_code); +} + +NodeApiRef MakeNodeApiRef(napi_env env, napi_value value) { + napi_ref ref{}; + NODE_LITE_CALL(napi_create_reference(env, value, 1, &ref)); + return NodeApiRef(ref, NodeApiRefDeleter(env)); } template @@ -292,39 +292,39 @@ std::string NodeLiteModule::ReadModuleFileText(napi_env env) { } std::string jsFilePath = args[1]; - std::unique_ptr runtime = NodeLiteRuntime::Create( - std::move(taskRunner), - js_root.string(), - std::move(args), - NodeLiteRuntime::Callbacks{}); + std::unique_ptr runtime = NodeLiteRuntime::Create( + std::move(taskRunner), + js_root.string(), + std::move(args), + NodeLiteRuntime::Callbacks{}); runtime->RunTestScript(jsFilePath); } /*static*/ std::unique_ptr NodeLiteRuntime::Create( - std::shared_ptr task_runner, - std::string js_root, - std::vector args, - Callbacks callbacks) { - std::unique_ptr runtime = - std::make_unique(PrivateTag{}, - std::move(task_runner), - std::move(js_root), - std::move(args), - std::move(callbacks)); - runtime->Initialize(); - return std::unique_ptr(runtime.release()); -} - -NodeLiteRuntime::NodeLiteRuntime( - PrivateTag, - std::shared_ptr task_runner, - std::string js_root, - std::vector args, - Callbacks callbacks) - : task_runner_(std::move(task_runner)), - js_root_(std::move(js_root)), - args_(std::move(args)), - callbacks_(std::move(callbacks)) {} + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks) { + std::unique_ptr runtime = + std::make_unique(PrivateTag{}, + std::move(task_runner), + std::move(js_root), + std::move(args), + std::move(callbacks)); + runtime->Initialize(); + return std::unique_ptr(runtime.release()); +} + +NodeLiteRuntime::NodeLiteRuntime( + PrivateTag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks) + : task_runner_(std::move(task_runner)), + js_root_(std::move(js_root)), + args_(std::move(args)), + callbacks_(std::move(callbacks)) {} void NodeLiteRuntime::Initialize() { env_holder_ = @@ -583,9 +583,9 @@ void NodeLiteRuntime::DefineBuiltInModules() { } } -void NodeLiteRuntime::DefineGlobalFunctions() { - NodeApiHandleScope scope{env_}; - napi_value global = NodeApi::GetGlobal(env_); +void NodeLiteRuntime::DefineGlobalFunctions() { + NodeApiHandleScope scope{env_}; + napi_value global = NodeApi::GetGlobal(env_); // Add global.global NodeApi::SetProperty(env_, global, "global", global); @@ -650,12 +650,8 @@ void NodeLiteRuntime::DefineGlobalFunctions() { // process.execPath NodeApi::SetPropertyString(env_, process_obj, "execPath", args_[0]); -// process.target_config -#ifdef NDEBUG + // process.target_config - always use "Release" to match CMAKE module output directory NodeApi::SetPropertyString(env_, process_obj, "target_config", "Release"); -#else - NodeApi::SetPropertyString(env_, process_obj, "target_config", "Debug"); -#endif // process.platform #ifdef WIN32 @@ -709,46 +705,46 @@ void NodeLiteRuntime::DefineGlobalFunctions() { NodeApi::SetProperty(env_, global, "console", console_obj); // console.log() - NodeApi::SetMethod( - env_, - console_obj, - "log", - [this](napi_env env, span args) { - NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); - std::string message = NodeApi::ToStdString(env, args[0]); - EmitConsoleOutput(message, false); - return nullptr; - }); + NodeApi::SetMethod( + env_, + console_obj, + "log", + [this](napi_env env, span args) { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + EmitConsoleOutput(message, false); + return nullptr; + }); // console.error() NodeApi::SetMethod( env_, console_obj, "error", - [this](napi_env env, span args) -> napi_value { - NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); - std::string message = NodeApi::ToStdString(env, args[0]); - EmitConsoleOutput(message, true); - return nullptr; - }); - } -} - -void NodeLiteRuntime::EmitConsoleOutput(const std::string& message, - bool is_error) { - const auto& callback = is_error ? callbacks_.stderr_callback - : callbacks_.stdout_callback; - if (callback) { - callback(message); - return; - } - - if (is_error) { - std::cerr << message << std::endl; - } else { - std::cout << message << std::endl; - } -} + [this](napi_env env, span args) -> napi_value { + NODE_LITE_ASSERT(args.size() >= 1, "Expected at least 1 argument"); + std::string message = NodeApi::ToStdString(env, args[0]); + EmitConsoleOutput(message, true); + return nullptr; + }); + } +} + +void NodeLiteRuntime::EmitConsoleOutput(const std::string& message, + bool is_error) { + const auto& callback = is_error ? callbacks_.stderr_callback + : callbacks_.stdout_callback; + if (callback) { + callback(message); + return; + } + + if (is_error) { + std::cerr << message << std::endl; + } else { + std::cout << message << std::endl; + } +} std::string NodeLiteRuntime::ProcessStack(std::string const& stack, std::string const& assertMethod) { @@ -911,55 +907,55 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { return *this; } -//============================================================================= -// NodeLiteErrorHandler implementation -//============================================================================= - -/*static*/ NodeLiteErrorHandler::Handler NodeLiteErrorHandler::SetHandler( - Handler handler) noexcept { - std::lock_guard lock{ErrorHandlerMutex()}; - Handler previous = GetHandler(); - if (handler) { - GetHandler() = std::move(handler); - } else { - GetHandler() = DefaultFatalErrorHandler; - } - return previous; -} - -/*static*/ NodeLiteErrorHandler::Handler& NodeLiteErrorHandler::GetHandler() - noexcept { - static Handler handler = DefaultFatalErrorHandler; - return handler; -} - -/*static*/ [[noreturn]] void NodeLiteErrorHandler::HandleFatalError( - NodeLiteFatalErrorInfo info) { - Handler handler_copy; - { - std::lock_guard lock{ErrorHandlerMutex()}; - handler_copy = GetHandler(); - } - handler_copy(info); - std::terminate(); -} - -/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnNodeApiFailed( - napi_env env, napi_status error_code) { - const char* errorMessage = "An exception is pending"; - if (NodeApi::IsExceptionPending(env)) { - error_code = napi_pending_exception; +//============================================================================= +// NodeLiteErrorHandler implementation +//============================================================================= + +/*static*/ NodeLiteErrorHandler::Handler NodeLiteErrorHandler::SetHandler( + Handler handler) noexcept { + std::lock_guard lock{ErrorHandlerMutex()}; + Handler previous = GetHandler(); + if (handler) { + GetHandler() = std::move(handler); + } else { + GetHandler() = DefaultFatalErrorHandler; + } + return previous; +} + +/*static*/ NodeLiteErrorHandler::Handler& NodeLiteErrorHandler::GetHandler() + noexcept { + static Handler handler = DefaultFatalErrorHandler; + return handler; +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::HandleFatalError( + NodeLiteFatalErrorInfo info) { + Handler handler_copy; + { + std::lock_guard lock{ErrorHandlerMutex()}; + handler_copy = GetHandler(); + } + handler_copy(info); + std::terminate(); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::OnNodeApiFailed( + napi_env env, napi_status error_code) { + const char* errorMessage = "An exception is pending"; + if (NodeApi::IsExceptionPending(env)) { + error_code = napi_pending_exception; } else { const napi_extended_error_info* error_info{}; napi_status status = napi_get_last_error_info(env, &error_info); if (status != napi_ok) { - NodeLiteErrorHandler::ExitWithMessage( - "", [&](std::ostream& os) { os << "Failed to get last error info: " << status; }); - } - errorMessage = error_info->error_message; - } - throw NodeLiteException(error_code, errorMessage); -} + NodeLiteErrorHandler::ExitWithMessage( + "", [&](std::ostream& os) { os << "Failed to get last error info: " << status; }); + } + errorMessage = error_info->error_message; + } + throw NodeLiteException(error_code, errorMessage); +} /*static*/ [[noreturn]] void NodeLiteErrorHandler::OnAssertFailed( napi_env env, char const* expr, char const* message) { @@ -988,17 +984,17 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { } std::string message = NodeApi::GetPropertyString(env, error, "message"); std::string stack = NodeApi::GetPropertyString(env, error, "stack"); - ExitWithMessage("JavaScript error", [&](std::ostream& os) { - os << "Exception: " << name << '\n' - << " Message: " << message << '\n' - << "Callstack: " << '\n' - << stack; - }); - } else { - std::string message = NodeApi::CoerceToString(env, error); - ExitWithMessage("JavaScript error", - [&](std::ostream& os) { os << " Message: " << message; }); - } + ExitWithMessage("JavaScript error", [&](std::ostream& os) { + os << "Exception: " << name << '\n' + << " Message: " << message << '\n' + << "Callstack: " << '\n' + << stack; + }); + } else { + std::string message = NodeApi::CoerceToString(env, error); + ExitWithMessage("JavaScript error", + [&](std::ostream& os) { os << " Message: " << message; }); + } } /*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSAssertError( @@ -1022,37 +1018,37 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { << " Actual: " << actual << '\n'; } - ExitWithMessage("JavaScript assertion error", [&](std::ostream& os) { - os << "Exception: " - << "AssertionError" << '\n' - << " Method: " << method_name << '\n' - << " Message: " << message << '\n' - << error_details.str(/*a filler for formatting*/) - << "Callstack: " << '\n' - << error_stack; - }); -} - -/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( - const std::string& message, - std::function get_error_details, - int exit_code) noexcept { - std::ostringstream details_stream; - if (get_error_details) { - get_error_details(details_stream); - } - std::string details = details_stream.str(); - - HandleFatalError(NodeLiteFatalErrorInfo{ - .message = message, - .details = details, - .exit_code = exit_code, - }); -} - -//============================================================================= -// NodeApi implementation -//============================================================================= + ExitWithMessage("JavaScript assertion error", [&](std::ostream& os) { + os << "Exception: " + << "AssertionError" << '\n' + << " Method: " << method_name << '\n' + << " Message: " << message << '\n' + << error_details.str(/*a filler for formatting*/) + << "Callstack: " << '\n' + << error_stack; + }); +} + +/*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( + const std::string& message, + std::function get_error_details, + int exit_code) noexcept { + std::ostringstream details_stream; + if (get_error_details) { + get_error_details(details_stream); + } + std::string details = details_stream.str(); + + HandleFatalError(NodeLiteFatalErrorInfo{ + .message = message, + .details = details, + .exit_code = exit_code, + }); +} + +//============================================================================= +// NodeApi implementation +//============================================================================= /*static*/ bool NodeApi::IsExceptionPending(napi_env env) { bool result{}; @@ -1277,11 +1273,11 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { return result; } -/*static*/ napi_value NodeApi::RunScript(napi_env env, napi_value script) { - napi_value result{}; - NODE_LITE_CALL(napi_run_script(env, script, nullptr, &result)); - return result; -} +/*static*/ napi_value NodeApi::RunScript(napi_env env, napi_value script) { + napi_value result{}; + NODE_LITE_CALL(napi_run_script(env, script, nullptr, &result)); + return result; +} /*static*/ napi_value NodeApi::RunScript(napi_env env, const std::string& code, @@ -1311,11 +1307,11 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { return result; } -/*static*/ napi_value NodeApi::CreateFunction(napi_env env, - std::string_view name, - NodeApiCallback cb) { - napi_value result{}; - NODE_LITE_CALL(napi_create_function( +/*static*/ napi_value NodeApi::CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb) { + napi_value result{}; + NODE_LITE_CALL(napi_create_function( env, name.data(), name.size(), @@ -1332,98 +1328,98 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { // TODO: (vmoroz) Find a way to delete it on close. new NodeApiCallback(std::move(cb)), &result)); - return result; -} - -ProcessResult RunNodeLiteScript(const std::filesystem::path& js_root, - const std::filesystem::path& script_path, - NodeLiteRuntime::Callbacks callbacks) { - ProcessResult result{}; - std::ostringstream stdout_stream; - std::ostringstream stderr_stream; - - NodeLiteRuntime::Callbacks effective_callbacks; - auto stdout_cb = callbacks.stdout_callback; - auto stderr_cb = callbacks.stderr_callback; - effective_callbacks.stdout_callback = - [stdout_cb, &stdout_stream](const std::string& message) { - if (stdout_cb) { - stdout_cb(message); - } - stdout_stream << message << '\n'; - }; - effective_callbacks.stderr_callback = - [stderr_cb, &stderr_stream](const std::string& message) { - if (stderr_cb) { - stderr_cb(message); - } - stderr_stream << message << '\n'; - }; - - auto fatal_handler = [&result](const NodeLiteFatalErrorInfo& info) { - result.status = info.exit_code; - if (!info.message.empty()) { - result.std_error = info.message; - } - if (!info.details.empty()) { - if (!result.std_error.empty()) { - result.std_error += '\n'; - } - result.std_error += info.details; - } - throw NodeLiteFatalError(info); - }; - - NodeLiteErrorHandler::Handler previous_handler = - NodeLiteErrorHandler::SetHandler(fatal_handler); - - try { - auto task_runner = std::make_shared(); - std::vector args{"node_lite", script_path.string()}; - auto runtime = NodeLiteRuntime::Create(std::move(task_runner), - js_root.string(), - std::move(args), - std::move(effective_callbacks)); - runtime->RunTestScript(script_path.string()); - result.status = 0; - } catch (const NodeLiteFatalError&) { - // Fatal error captured in result - } catch (const std::exception& e) { - NodeLiteErrorHandler::SetHandler(previous_handler); - result.status = -1; - result.std_error = e.what(); - return result; - } catch (...) { - NodeLiteErrorHandler::SetHandler(previous_handler); - result.status = -1; - result.std_error = "Unknown error"; - return result; - } - - NodeLiteErrorHandler::SetHandler(previous_handler); - - result.std_output = stdout_stream.str(); - if (!result.std_output.empty() && result.std_output.back() == '\n') { - result.std_output.pop_back(); - } - - std::string stderr_logs = stderr_stream.str(); - if (!stderr_logs.empty() && stderr_logs.back() == '\n') { - stderr_logs.pop_back(); - } - if (!stderr_logs.empty()) { - if (!result.std_error.empty()) { - result.std_error += '\n'; - } - result.std_error += stderr_logs; - } - - return result; -} - -} // namespace node_api_tests - -int main(int argc, char* argv[]) { - node_api_tests::NodeLiteRuntime::Run( + return result; +} + +ProcessResult RunNodeLiteScript(const std::filesystem::path& js_root, + const std::filesystem::path& script_path, + NodeLiteRuntime::Callbacks callbacks) { + ProcessResult result{}; + std::ostringstream stdout_stream; + std::ostringstream stderr_stream; + + NodeLiteRuntime::Callbacks effective_callbacks; + auto stdout_cb = callbacks.stdout_callback; + auto stderr_cb = callbacks.stderr_callback; + effective_callbacks.stdout_callback = + [stdout_cb, &stdout_stream](const std::string& message) { + if (stdout_cb) { + stdout_cb(message); + } + stdout_stream << message << '\n'; + }; + effective_callbacks.stderr_callback = + [stderr_cb, &stderr_stream](const std::string& message) { + if (stderr_cb) { + stderr_cb(message); + } + stderr_stream << message << '\n'; + }; + + auto fatal_handler = [&result](const NodeLiteFatalErrorInfo& info) { + result.status = info.exit_code; + if (!info.message.empty()) { + result.std_error = info.message; + } + if (!info.details.empty()) { + if (!result.std_error.empty()) { + result.std_error += '\n'; + } + result.std_error += info.details; + } + throw NodeLiteFatalError(info); + }; + + NodeLiteErrorHandler::Handler previous_handler = + NodeLiteErrorHandler::SetHandler(fatal_handler); + + try { + auto task_runner = std::make_shared(); + std::vector args{"node_lite", script_path.string()}; + auto runtime = NodeLiteRuntime::Create(std::move(task_runner), + js_root.string(), + std::move(args), + std::move(effective_callbacks)); + runtime->RunTestScript(script_path.string()); + result.status = 0; + } catch (const NodeLiteFatalError&) { + // Fatal error captured in result + } catch (const std::exception& e) { + NodeLiteErrorHandler::SetHandler(previous_handler); + result.status = -1; + result.std_error = e.what(); + return result; + } catch (...) { + NodeLiteErrorHandler::SetHandler(previous_handler); + result.status = -1; + result.std_error = "Unknown error"; + return result; + } + + NodeLiteErrorHandler::SetHandler(previous_handler); + + result.std_output = stdout_stream.str(); + if (!result.std_output.empty() && result.std_output.back() == '\n') { + result.std_output.pop_back(); + } + + std::string stderr_logs = stderr_stream.str(); + if (!stderr_logs.empty() && stderr_logs.back() == '\n') { + stderr_logs.pop_back(); + } + if (!stderr_logs.empty()) { + if (!result.std_error.empty()) { + result.std_error += '\n'; + } + result.std_error += stderr_logs; + } + + return result; +} + +} // namespace node_api_tests + +int main(int argc, char* argv[]) { + node_api_tests::NodeLiteRuntime::Run( std::vector(argv, argv + argc)); } diff --git a/Tests/NodeApi/node_lite_android.cpp b/Tests/NodeApi/node_lite_android.cpp new file mode 100644 index 00000000..5476aeec --- /dev/null +++ b/Tests/NodeApi/node_lite_android.cpp @@ -0,0 +1,22 @@ +#include "node_lite.h" + +#include + +namespace node_api_tests { + +/*static*/ void* NodeLitePlatform::LoadFunction( + napi_env /*env*/, + const std::filesystem::path& lib_path, + const std::string& function_name) noexcept +{ + void* handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); + if (handle == nullptr) + { + return nullptr; + } + + void* symbol = dlsym(handle, function_name.c_str()); + return symbol; +} + +} // namespace node_api_tests diff --git a/Tests/NodeApi/node_lite_posix.cpp b/Tests/NodeApi/node_lite_posix.cpp new file mode 100644 index 00000000..c2968514 --- /dev/null +++ b/Tests/NodeApi/node_lite_posix.cpp @@ -0,0 +1,43 @@ +#include +#if defined(__ANDROID__) +#include +#endif +#include "node_lite.h" + +namespace node_api_tests { + +/*static*/ void* NodeLitePlatform::LoadFunction( + napi_env env, + const std::filesystem::path& lib_path, + const std::string& function_name) noexcept { +#if defined(__ANDROID__) && (__ANDROID_API__ < 29) + void* library_handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); + if (library_handle == nullptr) { + return nullptr; + } + + return dlsym(library_handle, function_name.c_str()); +#else + void* library_handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); + if (library_handle == nullptr) { + const char* error_message = dlerror(); + NODE_LITE_ASSERT(false, + "Failed to load dynamic library: %s. Error: %s", + lib_path.c_str(), + error_message != nullptr ? error_message : "Unknown error"); + return nullptr; + } + + dlerror(); // Clear any existing error state before dlsym. + void* symbol = dlsym(library_handle, function_name.c_str()); + const char* error_message = dlerror(); + NODE_LITE_ASSERT(error_message == nullptr, + "Failed to resolve symbol: %s in %s. Error: %s", + function_name.c_str(), + lib_path.c_str(), + error_message != nullptr ? error_message : "Unknown error"); + return symbol; +#endif +} + +} // namespace node_api_tests diff --git a/Tests/UnitTests/Android/app/build.gradle b/Tests/UnitTests/Android/app/build.gradle index fc3002de..905ce34a 100644 --- a/Tests/UnitTests/Android/app/build.gradle +++ b/Tests/UnitTests/Android/app/build.gradle @@ -83,12 +83,16 @@ android { packagingOptions { if (enableAsan) { doNotStrip "**/*.so" + jniLibs.useLegacyPackaging true } } sourceSets { main { assets.srcDirs += [nodeApiAssetsDir] + if (enableAsan) { + jniLibs.srcDir "${buildDir}/generated/asanRuntime/jniLibs" + } } } } @@ -149,3 +153,68 @@ tasks.configureEach { task -> } preBuild.dependsOn(copyNodeApiTests) + +if (enableAsan) { + def hostTag = { + def osName = System.getProperty("os.name").toLowerCase() + if (osName.contains("mac") || osName.contains("darwin")) { + return "darwin-x86_64" + } else if (osName.contains("windows")) { + return "windows-x86_64" + } else { + return "linux-x86_64" + } + }.call() + + def asanRuntimeProvider = providers.provider { + def prebuiltRoot = new File(android.ndkDirectory, "toolchains/llvm/prebuilt/${hostTag}/lib64/clang") + if (!prebuiltRoot.exists()) { + throw new GradleException("Unable to locate clang libraries under ${prebuiltRoot}") + } + def versionDir = prebuiltRoot.listFiles().find { it.isDirectory() } + if (versionDir == null) { + throw new GradleException("Unable to determine clang version directory within ${prebuiltRoot}") + } + def runtimeFile = new File(versionDir, "lib/linux/libclang_rt.asan-aarch64-android.so") + if (!runtimeFile.exists()) { + throw new GradleException("Unable to locate ASan runtime library at ${runtimeFile}") + } + return runtimeFile + } + + def generatedAsanDir = layout.buildDirectory.dir("generated/asanRuntime/jniLibs/arm64-v8a") + + def prepareAsanRuntime = tasks.register("prepareAsanRuntime", Copy) { + from(asanRuntimeProvider) + into(generatedAsanDir) + } + + tasks.matching { it.name in ["mergeDebugNativeLibs", "mergeReleaseNativeLibs"] }.configureEach { + dependsOn(prepareAsanRuntime) + } + + def wrapScript = file("${projectDir}/../tools/wrap.sh") + + def pushAsanRuntime = tasks.register("pushAsanRuntime", Exec) { + dependsOn(prepareAsanRuntime) + commandLine("adb", "push", + generatedAsanDir.get().file("libclang_rt.asan-aarch64-android.so").asFile.absolutePath, + "/data/local/tmp/libclang_rt.asan-aarch64-android.so") + } + + def pushAsanWrapScript = tasks.register("pushAsanWrapScript", Exec) { + commandLine("adb", "push", wrapScript.absolutePath, "/data/local/tmp/wrap.sh") + } + + tasks.register("pushAsanArtifacts") { + dependsOn(pushAsanRuntime, pushAsanWrapScript) + doLast { + exec { + commandLine("adb", "shell", "chcon", "u:object_r:zygote_exec:s0", "/data/local/tmp/wrap.sh") + } + exec { + commandLine("adb", "shell", "chmod", "+x", "/data/local/tmp/wrap.sh") + } + } + } +} diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index ffb61153..27b971aa 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -16,15 +16,18 @@ FetchContent_MakeAvailable_With_Message(googletest) npm(install --silent WORKING_DIRECTORY ${TESTS_DIR}) -set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_posix.cpp) -set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) - if(WIN32) set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_windows.cpp) set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process.cpp) elseif(APPLE) - set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_mac.cpp) - set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_mac.cpp) + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_posix.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) +elseif(ANDROID) + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_android.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_android.cpp) +else() + set(NODE_LITE_PLATFORM_SRC ${TESTS_DIR}/NodeApi/node_lite_posix.cpp) + set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) endif() add_library(UnitTestsJNI SHARED diff --git a/Tests/UnitTests/Android/gradle.properties b/Tests/UnitTests/Android/gradle.properties index 25ceb3e4..3ec776e3 100644 --- a/Tests/UnitTests/Android/gradle.properties +++ b/Tests/UnitTests/Android/gradle.properties @@ -6,7 +6,7 @@ # http://www.gradle.org/docs/current/userguide/build_environment.html # Specifies the JVM arguments used for the daemon process. # The setting is particularly useful for tweaking memory settings. -org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED # When configured, Gradle will run in incubating parallel mode. # This option should only be used with decoupled projects. More details, visit # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects From 79b9c4edff41ce0145d851c48ed33bed58061c39 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 15 Oct 2025 21:09:04 -0700 Subject: [PATCH 007/174] try and get address sanitizer and thread sanitizer to run on Android, since they found bugs on macOS + JSC --- Tests/UnitTests/Android/tools/wrap.sh | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Tests/UnitTests/Android/tools/wrap.sh diff --git a/Tests/UnitTests/Android/tools/wrap.sh b/Tests/UnitTests/Android/tools/wrap.sh new file mode 100644 index 00000000..cac9a91a --- /dev/null +++ b/Tests/UnitTests/Android/tools/wrap.sh @@ -0,0 +1,16 @@ +#!/system/bin/sh + +# Ensure ASan runtime is available; prefer copy in /data/local/tmp if present. +ASAN_RT_BASENAME=${ASAN_RT_BASENAME:-libclang_rt.asan-aarch64-android.so} +ASAN_RT_LOCAL="/data/local/tmp/${ASAN_RT_BASENAME}" + +if [ -f "${ASAN_RT_LOCAL}" ]; then + ASAN_RT_PATH="${ASAN_RT_LOCAL}" +else + ASAN_RT_PATH="${ASAN_RT_BASENAME}" +fi + +export ASAN_OPTIONS=${ASAN_OPTIONS:-log_to_syslog=1:allow_user_segv_handler=1:disable_core=1:abort_on_error=0} +export LD_PRELOAD="${ASAN_RT_PATH}" + +exec "$@" From 45ca9531bf841f79381fbc77092c2a2d8b2fbdfd Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 13:29:28 -0700 Subject: [PATCH 008/174] Add N-API version/conformance roadmap (folds in engine-compat baseline) --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 116 ++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 Tests/NodeApi/NAPI_VERSION_ROADMAP.md diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md new file mode 100644 index 00000000..8215aab1 --- /dev/null +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -0,0 +1,116 @@ +# Node-API (N-API) Conformance & Version Roadmap + +_Last updated: 2026-06-04 · Tracks PR #116 (`napi-tests`) and the staged path to higher N-API levels._ + +## Scope & PR discipline + +This is a multi-PR effort. Keep the boundaries strict: + +- **PR #116 (this PR): land the conformance test suite on the N-API v5 surface that upstream already supports.** That is the whole goal — a regression safety net at the current capability level. +- **Out of scope here — each becomes its own follow-up PR:** + - **Bug fixes** against the current N-API implementation that the tests surface → *quarantine* the failing test via the allow-list and open a separate fix PR. Do not fix impl bugs in the test-suite PR. + - **Any `NAPI_VERSION` bump** (6 → 7 → 8 → …) and the per-engine native work it requires. + - **jsc-android engine bump** (v6 enabler — see below). + +## Current state (2026-06-04) + +- `NAPI_VERSION` is pinned at **5** via `[BABYLON-NATIVE-ADDITION]` `#define` blocks in + `Core/Node-API/Include/Shared/napi/{js_native_api.h, js_native_api_types.h, napi.h}`, and `NAPI_HAS_THREADS` is forced to **0**. Upstream `main` is also still 5. +- Recommended early refactor (a later PR): replace the three hardcoded defines with a single + build-system knob (`target_compile_definitions(... NAPI_VERSION=${JSR_NAPI_VERSION})`), per-engine overridable. + +### Per-engine implementation completeness + +| Engine | Source (fns) | v5 | v6 bigint / instance-data | v7 detach AB | v8 type-tag / freeze-seal | Notes | +|---|---|:--:|:--:|:--:|:--:|---| +| **V8** | `js_native_api_v8.cc` (109) | ✅ | ✅ | ✅ | ✅ | Upstream Node impl; ready to ~v8/v9 once the version is bumped. | +| **JavaScriptCore** | `js_native_api_javascriptcore.cc` (97) | ✅* | ❌ | ❌ | ❌ | Hand-port; no v6+ surface. Bump jsc-android + crib from Bun to implement. | +| **Chakra** | `js_native_api_chakra.cc` (97) | ✅* | ❌ (hard wall: BigInt) | ❌ | partial (soft) | Frozen OS engine on post-EOL Win10. Decouple; see ceiling. | + +`*` v5 surface to be confirmed green by this PR's suite. + +## Chakra N-API ceiling + +The Windows-OS Chakra (`chakra.dll`, JSRT/`jsrt.h`) is frozen ~ES2017 and will never gain new VM +primitives; Windows 10 reached EOL 2025-10-14. OSS ChakraCore has more, but is itself archived (≈2021) +and shipping it would mean bundling an unmaintained, security-frozen engine. So Chakra's capability is set +by the frozen JSRT surface you link. + +- **Hard walls (a VM primitive is missing — cannot be coded around):** **BigInt** (v6 + `napi_create_bigint_words` / `napi_get_value_bigint_*`) → no faithful v6 on Chakra, ever; **ArrayBuffer + detach** (v7) unless `JsDetachArrayBuffer` exists (verify against the actual `ChakraCore.h`). +- **Soft (more native work on existing primitives):** type tags (private symbol / external data), + `object_freeze`/`seal` (call ES `Object.freeze`), instance data, `get_all_property_names`, + references/finalizers (already work via `JsSetObjectBeforeCollectCallback`). + +**Decision: do not let Chakra set a global ceiling.** N-API is per-engine by design — `napi_get_version` +reports the level *this* engine supports and addons feature-detect. Chakra reports the honest version it can +reach, returns `napi_generic_failure` for the walled functions, and the conformance allow-list is gated per +engine. Pragmatic Chakra target: keep v5 green, optionally cherry-pick the cheap v8 wins (freeze/seal, +type-tags), hard-stop at BigInt. Do not pour native effort into a frozen engine on a sunset OS. + +## jsc-android bump (v6 enabler — separate PR) + +Currently pinned at JSC `250231.0.0`; `294992.0.0` is available. Bumping brings a modern JSC with real +BigInt + ES2020 primitives (what v6/v7 need) and makes **Bun's mature N-API-on-JSC layer** +(`src/bun.js/bindings/napi.cpp` et al.) directly referenceable. Caveats: Bun rides its own WebKit fork +(API mostly matches, build differs), jsc-android-buildscripts is semi-stale, binary size grows. Sequence it +*after* this PR, as the first step of the JSC v6→v8 work. + +## Staged version roadmap (post-PR1) + +Each tier: bump the knob → recompile (V8 exposes the surface for free) → enable the matching test dirs → +run the suite per engine → implement the JSC/(Chakra) gaps → green. + +| Step | Target | Unlocks (test dirs) | V8 | JSC / Chakra work | +|---|---|---|:--:|---| +| B1 | **v6** | `test_bigint`, `test_instance_data`, `get_all_property_names` | free | bigint create/get + instance-data (Chakra: bigint = hard wall) | +| B2 | **v7** | detached-ArrayBuffer cases | free | `napi_detach_arraybuffer` / `is_detached` | +| B3 | **v8** | type-tag + freeze/seal in `test_object`/`test_general` | free | type tags + freeze/seal → **parity with hermes-windows** | +| B4* | **v9** | `symbol_for`, syntax-error, `module_file_name` | free | implement on JSC | +| B5* | **v10** | external strings, property keys (matches `facebook/hermes API/napi`) | mostly | implement on JSC | + +`*` stretch. Separately: the worklets/worker goal needs **threadsafe functions** — a runtime-layer +(`node_api.h`, `NAPI_HAS_THREADS 1`) axis not covered by the engine-only suite; track independently. + +## Test-suite sourcing strategy + +- **Now (this PR):** vendored copy of vmoroz's hermes-windows `unittests/NodeApi/` (engine-layer, v8-capable + harness, `node_lite`). Resync the v1–v5 test files from upstream hermes-windows so our copies are current. +- **Later:** migrate to **`nodejs/node-api-cts`** (engine-agnostic, CMake `add_node_api_cts_addon()`, + `implementors//` harness contract: `assert`/`loadAddon`/`gcUntil`/`napiVersion`/`features`). + Consume via `FetchContent` `GIT_REPOSITORY` once it stabilizes / publishes (currently pre-1.0, not on npm; + `node-api/` runtime tests not yet started). This replaces the "gross copying" the PR flags. + +--- + +## Appendix: JS engine compatibility baseline + +_Folded from the original `engine-compat-baseline.md` (captured 2025-10-02 on macOS V8)._ + +**Environment:** Node.js v24.2.0 · V8 13.6.233.10-node.17 · macOS (darwin arm64). All 15 smoke checks passed. + +| Group | Checks | +|---|---| +| Engine detection | V8 detection; WebAssembly available | +| N-API compatibility | 1 MB strings < 100 ms; TypedArray aliasing/endianness; local + global Symbols | +| Unicode / encoding | UTF-16 surrogate pairs (emoji); NFC/NFD normalization; TextEncoder/TextDecoder UTF-8 | +| Memory | 10 MB array allocation; WeakMap/WeakSet | +| ES6+ | Proxy/Reflect; BigInt; async generators | +| Performance | 1000 timers < 100 ms; deep recursion to 8,907 frames | + +**Engine-upgrade-sensitive features (may fail on older Android V8/JSC):** TextEncoder/TextDecoder, BigInt +(needs V8 6.7+ / JSC with BigInt), async generators, deep recursion (lower Android stack limits), global +`v8` object detection. Tests should **feature-detect and `skip()`** rather than assume availability. + +**Android engine notes:** prebuilt Android V8 may lag Node's V8 (test against Android-XR system V8); +JavaScriptCore Android `250231.0.0` is older than current Safari JSC and may lack some ES2020+ — consider the +`294992.0.0` bump (see jsc-android section). + +## References + +- PR #116: https://github.com/BabylonJS/JsRuntimeHost/pull/116 +- hermes-windows N-API suite: https://github.com/microsoft/hermes-windows/tree/main/unittests/NodeApi +- node-api-cts: https://github.com/nodejs/node-api-cts (umbrella issue #15; publishing issue #35) +- facebook/hermes native Node-API (v10): https://github.com/facebook/hermes/tree/main/API/napi (`COMPATIBILITY.md`) +- Node-API version gating reference: https://github.com/nodejs/node-api-headers From 94c3795f3d81cf2546ffbd6004d51974785ed6f1 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 13:51:40 -0700 Subject: [PATCH 009/174] Restore NodeApi tests build on current macOS toolchain Two build-restoration fixes (no behavior/impl or NAPI-version changes), needed after rebasing onto upstream HEAD and building with the current Xcode/libc++: - node_lite: NodeApi::CallFunction took std::span but is only ever called with braced-init-lists ({a,b,c}). Newer libc++ correctly rejects constructing a non-const std::span from an initializer_list (that ctor is C++26). Switch the parameter to std::initializer_list (begin() yields the const napi_value* napi_call_function wants). - Tests/NodeApi: the POST_BUILD copy_directory of each .node runs as an Xcode script phase BEFORE Xcode's implicit CodeSign phase signs the original, so the copied addons that node_lite/NodeApiTests dlopen are unsigned on a clean build and macOS refuses to load them. Ad-hoc sign the copies directly (APPLE only). --- Tests/NodeApi/CMakeLists.txt | 17 ++++ Tests/NodeApi/node_lite.cpp | 4 +- Tests/NodeApi/node_lite.h | 189 ++++++++++++++++++----------------- 3 files changed, 114 insertions(+), 96 deletions(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 256782ae..d5278bae 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -179,6 +179,23 @@ function(add_node_api_module MODULE_TARGET) $/test/js-native-api/${FOLDER_NAME}/build COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" ) + + if(APPLE) + # The copy_directory above runs as an Xcode "Run Script" phase, which executes BEFORE + # Xcode's implicit CodeSign phase signs the original module. The copied .node files (the + # ones node_lite/NodeApiTests actually dlopen) are therefore unsigned on a clean build, and + # macOS refuses to load them ("Trying to load an unsigned library"). Ad-hoc sign the copies + # directly so clean builds work without a second pass. + set(_node_api_cfg_dir $,Debug,Release>) + add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD + COMMAND codesign --force --sign - + "$/test/js-native-api/${FOLDER_NAME}/build/${_node_api_cfg_dir}/$" + COMMAND codesign --force --sign - + "$/test/js-native-api/${FOLDER_NAME}/build/${_node_api_cfg_dir}/$" + COMMENT "Ad-hoc signing copied ${MODULE_TARGET}.node for dlopen on macOS" + VERBATIM + ) + endif() endfunction() add_dependencies(NodeApiTests NodeApiModules) diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index e7e6ffaf..39af3132 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -1300,10 +1300,10 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { /*static*/ napi_value NodeApi::CallFunction(napi_env env, napi_value func, - span args) { + std::initializer_list args) { napi_value result{}; NODE_LITE_CALL(napi_call_function( - env, GetUndefined(env), func, args.size(), args.data(), &result)); + env, GetUndefined(env), func, args.size(), args.begin(), &result)); return result; } diff --git a/Tests/NodeApi/node_lite.h b/Tests/NodeApi/node_lite.h index e8bba7e2..b43826dd 100644 --- a/Tests/NodeApi/node_lite.h +++ b/Tests/NodeApi/node_lite.h @@ -9,16 +9,17 @@ #include #include #include +#include #include #include #include #include -#include -#include -#include -#include "child_process.h" -#include "compat.h" -#include "string_utils.h" +#include +#include +#include +#include "child_process.h" +#include "compat.h" +#include "string_utils.h" #define NAPI_EXPERIMENTAL #include "js_runtime_api.h" @@ -88,31 +89,31 @@ class NodeLiteException : public std::runtime_error { napi_status error_status_; }; -struct NodeLiteFatalErrorInfo { - std::string message; - std::string details; - int exit_code{1}; -}; - -class NodeLiteFatalError : public std::runtime_error { - public: - explicit NodeLiteFatalError(NodeLiteFatalErrorInfo info) - : std::runtime_error{info.message.c_str()}, info_{std::move(info)} {} - - const NodeLiteFatalErrorInfo& info() const noexcept { return info_; } - - private: - NodeLiteFatalErrorInfo info_; -}; - -class NodeLiteErrorHandler { - public: - using Handler = std::function; - - static Handler SetHandler(Handler handler) noexcept; - - [[noreturn]] static void OnNodeApiFailed(napi_env env, - napi_status error_status); +struct NodeLiteFatalErrorInfo { + std::string message; + std::string details; + int exit_code{1}; +}; + +class NodeLiteFatalError : public std::runtime_error { + public: + explicit NodeLiteFatalError(NodeLiteFatalErrorInfo info) + : std::runtime_error{info.message.c_str()}, info_{std::move(info)} {} + + const NodeLiteFatalErrorInfo& info() const noexcept { return info_; } + + private: + NodeLiteFatalErrorInfo info_; +}; + +class NodeLiteErrorHandler { + public: + using Handler = std::function; + + static Handler SetHandler(Handler handler) noexcept; + + [[noreturn]] static void OnNodeApiFailed(napi_env env, + napi_status error_status); [[noreturn]] static void OnAssertFailed(napi_env env, char const* expr, @@ -121,21 +122,21 @@ class NodeLiteErrorHandler { [[noreturn]] static void ExitWithJSError(napi_env env, napi_value error) noexcept; - [[noreturn]] static void ExitWithJSAssertError(napi_env env, - napi_value error) noexcept; - - [[noreturn]] static void ExitWithMessage( - const std::string& message, - std::function get_error_details = nullptr, - int exit_code = 1) noexcept; - - private: - static Handler& GetHandler() noexcept; - [[noreturn]] static void HandleFatalError(NodeLiteFatalErrorInfo info); -}; - -// Define NodeApiRef "smart pointer" for napi_ref as unique_ptr with a custom -// deleter. + [[noreturn]] static void ExitWithJSAssertError(napi_env env, + napi_value error) noexcept; + + [[noreturn]] static void ExitWithMessage( + const std::string& message, + std::function get_error_details = nullptr, + int exit_code = 1) noexcept; + + private: + static Handler& GetHandler() noexcept; + [[noreturn]] static void HandleFatalError(NodeLiteFatalErrorInfo info); +}; + +// Define NodeApiRef "smart pointer" for napi_ref as unique_ptr with a custom +// deleter. class NodeApiRefDeleter { public: NodeApiRefDeleter() noexcept; @@ -210,28 +211,28 @@ class NodeLiteModule { }; // The Node.js-like runtime that is enough to run Node-API tests. -class NodeLiteRuntime { - struct PrivateTag {}; - - public: - struct Callbacks { - std::function stdout_callback{}; - std::function stderr_callback{}; - }; - - static std::unique_ptr Create( - std::shared_ptr task_runner, - std::string js_root, - std::vector args, - Callbacks callbacks); - - explicit NodeLiteRuntime(PrivateTag tag, - std::shared_ptr task_runner, - std::string js_root, - std::vector args, - Callbacks callbacks); - - static void Run(std::vector args); +class NodeLiteRuntime { + struct PrivateTag {}; + + public: + struct Callbacks { + std::function stdout_callback{}; + std::function stderr_callback{}; + }; + + static std::unique_ptr Create( + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks); + + explicit NodeLiteRuntime(PrivateTag tag, + std::shared_ptr task_runner, + std::string js_root, + std::vector args, + Callbacks callbacks); + + static void Run(std::vector args); NodeLiteModule& ResolveModule(const std::string& parent_module_path, const std::string& module_path); @@ -256,17 +257,17 @@ class NodeLiteRuntime { private: void Initialize(); - void DefineGlobalFunctions(); - void DefineBuiltInModules(); - void EmitConsoleOutput(const std::string& message, bool is_error); - - private: - std::shared_ptr task_runner_; - std::string js_root_; - std::vector args_; - Callbacks callbacks_{}; - std::unique_ptr env_holder_; - napi_env env_{}; + void DefineGlobalFunctions(); + void DefineBuiltInModules(); + void EmitConsoleOutput(const std::string& message, bool is_error); + + private: + std::shared_ptr task_runner_; + std::string js_root_; + std::vector args_; + Callbacks callbacks_{}; + std::unique_ptr env_holder_; + napi_env env_{}; std::unordered_map> registered_modules_; std::unordered_map node_js_modules_; @@ -389,18 +390,18 @@ class NodeApi { static napi_value CallFunction(napi_env env, napi_value func, - span args); - - static napi_value CreateFunction(napi_env env, - std::string_view name, - NodeApiCallback cb); -}; - -ProcessResult RunNodeLiteScript( - const std::filesystem::path& js_root, - const std::filesystem::path& script_path, - NodeLiteRuntime::Callbacks callbacks = NodeLiteRuntime::Callbacks{}); - -} // namespace node_api_tests - -#endif // !NODE_API_TEST_NODE_LITE_H + std::initializer_list args); + + static napi_value CreateFunction(napi_env env, + std::string_view name, + NodeApiCallback cb); +}; + +ProcessResult RunNodeLiteScript( + const std::filesystem::path& js_root, + const std::filesystem::path& script_path, + NodeLiteRuntime::Callbacks callbacks = NodeLiteRuntime::Callbacks{}); + +} // namespace node_api_tests + +#endif // !NODE_API_TEST_NODE_LITE_H From cdb2cdeb6381a9c323287628876de7b8dbabb5a4 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 14:18:15 -0700 Subject: [PATCH 010/174] Restore Android NodeApi test build (compiles/links/installs/runs on emulator) Build-restoration fixes for the Android in-process NodeApi harness after rebasing onto upstream HEAD (no impl/NAPI-version changes). Each was a latent break in the napi-tests Android integration, surfaced by a clean build on a current toolchain: - CMakeLists.txt: drop the AndroidExtensions Globals.cpp 'patch' step. It file(COPY)'d patches/AndroidExtensions/Globals.cpp, which was never committed in any ref (author's local-only file). Upstream uses a newer AndroidExtensions pin and needs no patch. - build.gradle: bump default ndkVersion 23.1.7779620 -> 28.2.13676358 (matches CI's NDK_VERSION). NDK 23's libc++ can't compile googletest 1.17.0's <=> usage. Also map the Android sanitizer flag JSR_ENABLE_ASAN -> ENABLE_SANITIZERS (the upstream option kept during the rebase). - Tests/NodeApi/CMakeLists.txt: use ${JsRuntimeHost_SOURCE_DIR} instead of ${CMAKE_SOURCE_DIR} for Core/Node-API include paths. On Android JsRuntimeHost is added as a subdirectory of the app, so CMAKE_SOURCE_DIR was the app dir (headers not found); the project-scoped var is correct in both standalone (macOS) and nested (Android) builds. - Tests/NodeApi/CMakeLists.txt: allow the .node modules to link with unresolved napi_* symbols on Android (-Wl,--unresolved-symbols=ignore-all), the ELF equivalent of Apple's -undefined dynamic_lookup; they bind at dlopen time from the host (UnitTestsJNI). - Shared.cpp: gate the Android NodeApi-harness block on NODE_API_AVAILABLE_NATIVE_TESTS (defined only by UnitTestsJNI) so the standalone UnitTests target -- built but unused on Android -- doesn't try to compile AndroidExtensions/NodeApi code it doesn't link. --- CMakeLists.txt | 4 ---- Tests/NodeApi/CMakeLists.txt | 23 ++++++++++++++++------- Tests/UnitTests/Android/app/build.gradle | 4 ++-- Tests/UnitTests/Shared/Shared.cpp | 10 +++++----- 4 files changed, 23 insertions(+), 18 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7179bfb9..ba0465e3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -159,10 +159,6 @@ if(ANDROID) if(NOT AndroidExtensions_POPULATED) FetchContent_Populate(AndroidExtensions) FetchContent_GetProperties(AndroidExtensions) - message(STATUS "Patching AndroidExtensions Globals.cpp in ${androidextensions_SOURCE_DIR}") - file(COPY - ${CMAKE_CURRENT_SOURCE_DIR}/patches/AndroidExtensions/Globals.cpp - DESTINATION ${androidextensions_SOURCE_DIR}/Source) add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR}) else() add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR}) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index d5278bae..856f9cbb 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -51,9 +51,9 @@ target_include_directories(node_lite PRIVATE ${NODE_API_TEST_ROOT} ${NODE_API_TEST_ROOT}/include - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} - ${CMAKE_SOURCE_DIR}/Core/Node-API/Source + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Shared + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Source ) target_compile_definitions(node_lite @@ -133,10 +133,10 @@ function(add_node_api_module MODULE_TARGET) target_include_directories(${MODULE_TARGET} PRIVATE ${NODE_API_TEST_ROOT}/include - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Shared/napi - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} - ${CMAKE_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE}/napi + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Shared + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Shared/napi + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} + ${JsRuntimeHost_SOURCE_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE}/napi ) target_compile_definitions(${MODULE_TARGET} @@ -151,6 +151,15 @@ function(add_node_api_module MODULE_TARGET) PRIVATE "-undefined" "dynamic_lookup" ) + elseif(ANDROID) + # The .node module is dlopen'd into a host (UnitTestsJNI) that already provides the napi_* + # symbols. The Android NDK links shared libraries with --no-undefined by default, which would + # reject those symbols at build time; allow them to remain unresolved so they bind at load + # time (the ELF equivalent of Apple's -undefined dynamic_lookup above). + target_link_options(${MODULE_TARGET} + PRIVATE + "-Wl,--unresolved-symbols=ignore-all" + ) endif() set(MODULE_OUTPUT_DIR diff --git a/Tests/UnitTests/Android/app/build.gradle b/Tests/UnitTests/Android/app/build.gradle index 905ce34a..071d034c 100644 --- a/Tests/UnitTests/Android/app/build.gradle +++ b/Tests/UnitTests/Android/app/build.gradle @@ -28,7 +28,7 @@ def enableAsan = project.hasProperty("enableAsan") android { namespace 'com.jsruntimehost.unittests' compileSdk 33 - ndkVersion = "23.1.7779620" + ndkVersion = "28.2.13676358" if (project.hasProperty("ndkVersion")) { ndkVersion = project.property("ndkVersion") } @@ -46,7 +46,7 @@ android { cmake { def cmakeArgs = cmakeArguments.clone() if (enableAsan) { - cmakeArgs += "-DJSR_ENABLE_ASAN=ON" + cmakeArgs += "-DENABLE_SANITIZERS=ON" } arguments(*cmakeArgs) } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index f2ea0713..9781a75b 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -26,7 +26,7 @@ #include #include -#if defined(__ANDROID__) +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) #include #include #include @@ -43,7 +43,7 @@ namespace { -#if defined(__ANDROID__) +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) namespace { using namespace std::filesystem; @@ -990,16 +990,16 @@ TEST(NodeApi, AdjacentEscapableScopesEscapeIndependently) int RunTests() { -#if defined(__ANDROID__) +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) ConfigureNodeApiTests(); #endif testing::InitGoogleTest(); -#if defined(__ANDROID__) +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) node_api_tests::RegisterNodeApiTests(); #endif return RUN_ALL_TESTS(); } -#if defined(__ANDROID__) +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) void SetNodeApiTestEnvironment(AAssetManager* assetManager, const std::filesystem::path& baseDir) { OverrideAssetManager() = assetManager; From 3c12ac8df7946f0e05715b4969d340edcafcd589 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 14:42:32 -0700 Subject: [PATCH 011/174] Fix Android NodeApi harness JNI crash; wire up SetNodeApiTestEnvironment The instrumented run aborted with 'use of deleted global reference': the harness fell back to android::global::GetAppContext() (GetFilesDir -> GetObjectClass) whose JNI global ref is not valid during the instrumented run. JNI.cpp now computes a writable base dir from the still-valid instrumentation Context and passes it plus the native AAssetManager to SetNodeApiTestEnvironment() before RunTests() -- the wiring the harness was designed for (see e1fce6b) but which was never actually connected. This removes the crash and lets ConfigureNodeApiTests run. NOTE: on-device execution of the NodeApi conformance tests is still not achieved -- CopyAssetsRecursive relies on AAssetManager subdirectory enumeration (AAssetDir_getNextFileName lists files only, not dirs) so the nested test tree isn't copied, and the native .node modules are neither packaged nor loadable from an app-writable dir on API 29+. Tracked as follow-up. --- .../Android/app/src/main/cpp/JNI.cpp | 27 +++++++++++++++++++ Tests/UnitTests/Shared/Shared.h | 10 +++++++ 2 files changed, 37 insertions(+) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp index 502da955..156f6a39 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp +++ b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp @@ -37,6 +37,33 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz android::global::Initialize(javaVM, applicationContext, assetManagerObj); +#if defined(NODE_API_AVAILABLE_NATIVE_TESTS) + // Wire the in-process Node-API test harness to a native AssetManager and a writable base dir + // derived from the (still-valid) instrumentation Context, so it does not fall back to + // android::global::GetAppContext() during the run -- that global ref is not valid here and + // dereferencing it aborts with "use of deleted global reference". + if (assetManagerObj != nullptr) + { + AAssetManager* nativeAssetManager = AAssetManager_fromJava(env, assetManagerObj); + + jclass ctxClass = env->GetObjectClass(context); + jmethodID getFilesDir = env->GetMethodID(ctxClass, "getFilesDir", "()Ljava/io/File;"); + jobject filesDir = env->CallObjectMethod(context, getFilesDir); + jclass fileClass = env->GetObjectClass(filesDir); + jmethodID getAbsolutePath = env->GetMethodID(fileClass, "getAbsolutePath", "()Ljava/lang/String;"); + auto pathString = static_cast(env->CallObjectMethod(filesDir, getAbsolutePath)); + const char* rawPath = env->GetStringUTFChars(pathString, nullptr); + std::filesystem::path baseDir = std::filesystem::path{rawPath} / "node_api_tests"; + env->ReleaseStringUTFChars(pathString, rawPath); + env->DeleteLocalRef(pathString); + env->DeleteLocalRef(fileClass); + env->DeleteLocalRef(filesDir); + env->DeleteLocalRef(ctxClass); + + SetNodeApiTestEnvironment(nativeAssetManager, baseDir); + } +#endif + if (assetManagerObj != nullptr) { env->DeleteLocalRef(assetManagerObj); diff --git a/Tests/UnitTests/Shared/Shared.h b/Tests/UnitTests/Shared/Shared.h index acc4548b..e5fdd7e8 100644 --- a/Tests/UnitTests/Shared/Shared.h +++ b/Tests/UnitTests/Shared/Shared.h @@ -3,3 +3,13 @@ #include int RunTests(); + +#if defined(__ANDROID__) && defined(NODE_API_AVAILABLE_NATIVE_TESTS) +#include + +// Supplies the in-process Node-API test harness with a native AssetManager and a writable base +// directory (derived from the instrumentation Context in the JNI layer). Without this the harness +// falls back to android::global::GetAppContext(), whose JNI global ref is not valid during the +// instrumented run and aborts with "use of deleted global reference". +void SetNodeApiTestEnvironment(AAssetManager* assetManager, const std::filesystem::path& baseDir); +#endif From c910c8a60ee4fff626e900980afcc0dad5ae26ac Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 15:11:14 -0700 Subject: [PATCH 012/174] Android: make the NodeApi conformance tests actually execute on-device Before this, the instrumented run passed vacuously -- no NodeApi tests ran. Several layered fixes get them executing on the emulator (macOS path unchanged: still 12/12): #1 Asset enumeration: AAssetManager can't list subdirectories, so CopyAssetsRecursive copied nothing. copyNodeApiTests now emits a file manifest (manifest.txt -- not a dotfile, which aapt would drop) and Shared.cpp copies each listed file. #2 Native module packaging/loading: build each addon as lib.so on Android so AGP packages it into lib// (nativeLibraryDir, the only dlopen-able location on API 29+); node_lite_android loads it by soname; ResolveModulePath resolves the (on-disk absent) .node so LoadNativeModule runs. V8 lifecycle (in-process node_lite shares the host's V8): reuse the host's already- initialized V8 platform (fixes 'Wrong initialization order'); hold a Locker + Isolate::Scope so multi-isolate access is locked (fixes 'Entering the V8 API without proper locking'). KNOWN REMAINING (tracked): node_lite calls Node-API outside any napi callback during NodeLiteRuntime::Initialize/script execution, which on V8 needs a live HandleScope + current Context. v8::HandleScope/Context::Scope are stack-only (operator new is private) so they can't be held across the holder; this needs a scope-wrapping rework of node_lite's V8 entry points (or napi_open_handle_scope + context enter). Until then the on-device native tests segfault in napi_create_object. --- Tests/NodeApi/CMakeLists.txt | 68 +++++++++++++++-------- Tests/NodeApi/node_lite.cpp | 6 ++ Tests/NodeApi/node_lite_android.cpp | 7 ++- Tests/NodeApi/node_lite_jsruntimehost.cpp | 28 +++++++--- Tests/UnitTests/Android/app/build.gradle | 16 ++++++ Tests/UnitTests/Shared/Shared.cpp | 56 ++++++++++++------- 6 files changed, 128 insertions(+), 53 deletions(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 856f9cbb..5784de45 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -128,7 +128,13 @@ function(add_node_api_module MODULE_TARGET) set(MODULE_TARGET "${FOLDER_NAME}_${MODULE_TARGET}") endif() - add_library(${MODULE_TARGET} MODULE) + # On Android the addon must be a SHARED library so Gradle/AGP packages it into the APK's + # lib// (the app's nativeLibraryDir). Elsewhere it is a MODULE (dlopen-only) .node. + if(ANDROID) + add_library(${MODULE_TARGET} SHARED) + else() + add_library(${MODULE_TARGET} MODULE) + endif() target_sources(${MODULE_TARGET} PRIVATE ${ARG_SOURCES}) target_include_directories(${MODULE_TARGET} PRIVATE @@ -162,32 +168,46 @@ function(add_node_api_module MODULE_TARGET) ) endif() - set(MODULE_OUTPUT_DIR - ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) - set_target_properties(${MODULE_TARGET} - PROPERTIES - PREFIX "" - SUFFIX ".node" - ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - ) + if(ANDROID) + # lib.so so AGP packages it into lib// (-> nativeLibraryDir), the only place a + # native library may be dlopen'd from on API 29+. node_lite_android loads it by soname. + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "lib" + SUFFIX ".so" + ) + else() + set(MODULE_OUTPUT_DIR + ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "" + SUFFIX ".node" + ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + ) + endif() add_dependencies(NodeApiModules ${MODULE_TARGET}) - add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" - ) + if(NOT ANDROID) + # Desktop: stage the built .node next to the node_lite / NodeApiTests runners so they can + # dlopen it relative to the copied test files. (Android loads from nativeLibraryDir.) + add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" + ) + endif() if(APPLE) # The copy_directory above runs as an Xcode "Run Script" phase, which executes BEFORE diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 39af3132..fb2db4b1 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -399,6 +399,12 @@ fs::path NodeLiteRuntime::ResolveModulePath( if (fs::exists(node_module_path)) { return node_module_path; } +#if defined(__ANDROID__) + // On Android the addon ships as lib.so in the app's nativeLibraryDir rather than as a + // .node file on disk, so the existence check above fails. Resolve to the .node path anyway so + // LoadNativeModule runs; node_lite_android dlopens it by soname (lib.so). + return node_module_path; +#endif // See if the module was prefixed with the parent folder to disambiguate C++ // project name. fs::path fs_parent_folder = fs::path(parent_module_path).filename(); diff --git a/Tests/NodeApi/node_lite_android.cpp b/Tests/NodeApi/node_lite_android.cpp index 5476aeec..af7bb0cd 100644 --- a/Tests/NodeApi/node_lite_android.cpp +++ b/Tests/NodeApi/node_lite_android.cpp @@ -9,7 +9,12 @@ namespace node_api_tests { const std::filesystem::path& lib_path, const std::string& function_name) noexcept { - void* handle = dlopen(lib_path.string().c_str(), RTLD_NOW | RTLD_LOCAL); + // On Android the native addons are packaged as lib.so in the app's nativeLibraryDir -- + // the only location a native library may be dlopen'd from on API 29+. The resolved lib_path + // points at a (non-existent) .node under the copied test tree, so load by soname and let + // the dynamic linker resolve it from nativeLibraryDir. + std::string soname = "lib" + lib_path.stem().string() + ".so"; + void* handle = dlopen(soname.c_str(), RTLD_NOW | RTLD_LOCAL); if (handle == nullptr) { return nullptr; diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index 1c524f53..e3c00357 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -38,8 +38,14 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { create_params.array_buffer_allocator = allocator_.get(); isolate_ = v8::Isolate::New(create_params); - v8::Locker locker(isolate_); - v8::Isolate::Scope isolate_scope(isolate_); + // The host runs its own V8 isolate in this process, so V8 enforces multi-isolate locking. + // Hold a Locker + Isolate::Scope for this holder's entire lifetime so all subsequent + // Node-API/V8 access on this thread (running the test script, native callbacks, teardown) is + // properly locked and scoped to our isolate -- otherwise V8 aborts with "Entering the V8 API + // without proper locking in place". + locker_ = std::make_unique(isolate_); + isolate_scope_ = std::make_unique(isolate_); + v8::HandleScope handle_scope(isolate_); v8::Local context = v8::Context::New(isolate_); context_.Reset(isolate_, context); @@ -81,8 +87,7 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { } #elif defined(__ANDROID__) if (env_ != nullptr && isolate_ != nullptr) { - v8::Locker locker(isolate_); - v8::Isolate::Scope isolate_scope(isolate_); + // Still locked + isolate-scoped on this thread via locker_/isolate_scope_ (held members). v8::HandleScope handle_scope(isolate_); v8::Local context = context_.Get(isolate_); v8::Context::Scope context_scope(context); @@ -104,6 +109,9 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { context_.Reset(); + isolate_scope_.reset(); + locker_.reset(); + if (isolate_ != nullptr) { isolate_->Dispose(); isolate_ = nullptr; @@ -122,11 +130,11 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { class V8Platform { public: static void EnsureInitialized() { - std::call_once(init_flag_, []() { - platform_ = v8::platform::NewDefaultPlatform(); - v8::V8::InitializePlatform(platform_.get()); - v8::V8::Initialize(); - }); + // V8's platform is process-global and is already initialized by JsRuntimeHost -- the host + // AppRuntime that UnitTestsJNI links and that runs (via the regular V8 unit tests) before + // these in-process Node-API tests. Initializing it a second time aborts V8 with + // "Wrong initialization order", so reuse the host's platform and only create our own + // isolate/context below. } private: @@ -135,6 +143,8 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { }; v8::Isolate* isolate_{nullptr}; + std::unique_ptr locker_{}; + std::unique_ptr isolate_scope_{}; v8::Global context_; std::unique_ptr allocator_{}; #endif diff --git a/Tests/UnitTests/Android/app/build.gradle b/Tests/UnitTests/Android/app/build.gradle index 071d034c..646b5a52 100644 --- a/Tests/UnitTests/Android/app/build.gradle +++ b/Tests/UnitTests/Android/app/build.gradle @@ -134,6 +134,22 @@ task copyScripts { task copyNodeApiTests(type: Copy) { from '../../../NodeApi/test' into "${nodeApiAssetsDir}/NodeApi/test" + // Always re-run so the manifest is regenerated even when the copied sources are unchanged. + outputs.upToDateWhen { false } + doLast { + // AAssetManager cannot enumerate subdirectories at runtime, so emit a manifest listing + // every copied file (one path relative to NodeApi/test per line). Consumed by Shared.cpp. + // Must NOT start with a dot -- aapt ignores dotfiles when packaging assets. + def testRoot = file("${nodeApiAssetsDir}/NodeApi/test") + def manifestFile = new File(testRoot, 'manifest.txt') + manifestFile.withWriter('UTF-8') { writer -> + testRoot.eachFileRecurse(groovy.io.FileType.FILES) { f -> + if (f != manifestFile) { + writer.writeLine(testRoot.toPath().relativize(f.toPath()).toString().replace(File.separator, '/')) + } + } + } + } } // Run copyScripts task after CMake external build diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 9781a75b..5aa57847 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -50,36 +50,54 @@ namespace void CopyAssetsRecursive(AAssetManager* manager, const std::string& asset_path, const path& destination) { - AAssetDir* dir = AAssetManager_openDir(manager, asset_path.c_str()); - if (dir == nullptr) + // The NDK AAssetManager cannot enumerate subdirectories -- AAssetDir_getNextFileName + // returns files in a single directory only, never nested directories -- so the test + // tree cannot be discovered at runtime. Instead read a build-time manifest (one + // relative path per line, produced by the copyNodeApiTests Gradle task) and copy each + // listed file individually (AAssetManager_open works fine for a known file path). + std::string manifest_asset = asset_path + "/manifest.txt"; + AAsset* manifest = AAssetManager_open(manager, manifest_asset.c_str(), AASSET_MODE_BUFFER); + if (manifest == nullptr) { return; } - const char* filename = nullptr; - while ((filename = AAssetDir_getNextFileName(dir)) != nullptr) + off_t manifest_length = AAsset_getLength(manifest); + std::string manifest_text(static_cast(manifest_length), '\0'); + AAsset_read(manifest, manifest_text.data(), manifest_length); + AAsset_close(manifest); + + std::stringstream manifest_stream(manifest_text); + std::string relative_path; + while (std::getline(manifest_stream, relative_path)) { - std::string child_asset = asset_path.empty() ? filename : asset_path + "/" + filename; + if (!relative_path.empty() && relative_path.back() == '\r') + { + relative_path.pop_back(); + } + if (relative_path.empty()) + { + continue; + } + + std::string child_asset = asset_path + "/" + relative_path; AAsset* asset = AAssetManager_open(manager, child_asset.c_str(), AASSET_MODE_STREAMING); - if (asset != nullptr) + if (asset == nullptr) { - create_directories(destination); - std::ofstream output(destination / filename, std::ios::binary); - char buffer[4096]; - int read = 0; - while ((read = AAsset_read(asset, buffer, sizeof(buffer))) > 0) - { - output.write(buffer, read); - } - AAsset_close(asset); + continue; } - else + + path output_path = destination / relative_path; + create_directories(output_path.parent_path()); + std::ofstream output(output_path, std::ios::binary); + char buffer[8192]; + int read = 0; + while ((read = AAsset_read(asset, buffer, sizeof(buffer))) > 0) { - CopyAssetsRecursive(manager, child_asset, destination / filename); + output.write(buffer, read); } + AAsset_close(asset); } - - AAssetDir_close(dir); } path GetFilesDir() From 02f6ffaee52d12115cc138ef7c560067d6da77d2 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 15:21:27 -0700 Subject: [PATCH 013/174] Android: enter the V8 context in jsr_open_napi_env_scope (fix napi_create_object segfault) NodeApiEnvScope -> jsr_open_napi_env_scope was a no-op stub: it allocated a scope struct but never entered the env's V8 isolate/context. On JSC that's fine (the env carries its context explicitly), but on V8 node_lite then calls Node-API outside any napi callback with no *current context*, so napi_create_object -> v8::Object::New(isolate) segfaulted during NodeLiteRuntime::Initialize. Enter the env's context on open and exit it on close (Android only). The in-process V8 runtime now initializes and runs tests. --- Tests/NodeApi/js_runtime_api.cpp | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/Tests/NodeApi/js_runtime_api.cpp b/Tests/NodeApi/js_runtime_api.cpp index c03740ac..936392a9 100644 --- a/Tests/NodeApi/js_runtime_api.cpp +++ b/Tests/NodeApi/js_runtime_api.cpp @@ -13,6 +13,9 @@ struct jsr_napi_env_scope_s { napi_env env{nullptr}; +#if defined(__ANDROID__) + v8::Global context; +#endif }; napi_status jsr_open_napi_env_scope(napi_env env, @@ -23,6 +26,20 @@ napi_status jsr_open_napi_env_scope(napi_env env, auto* scope_impl = new jsr_napi_env_scope_s{}; scope_impl->env = env; +#if defined(__ANDROID__) + // node_lite calls Node-API outside any napi callback, so V8 has no *current context*. The env + // holder already holds a Locker + Isolate::Scope; enter the env's context here (exited in + // jsr_close_napi_env_scope) so calls such as napi_create_object -> v8::Object::New(isolate), + // which use the isolate's current context, don't segfault. (On JSC this scope is a no-op -- the + // env carries its context explicitly.) + if (env != nullptr) { + v8::Isolate* isolate = env->isolate; + v8::HandleScope handle_scope(isolate); + v8::Local context = env->context(); + scope_impl->context.Reset(isolate, context); + context->Enter(); + } +#endif *scope = scope_impl; return napi_ok; } @@ -33,6 +50,15 @@ napi_status jsr_close_napi_env_scope(napi_env /*env*/, return napi_invalid_arg; } +#if defined(__ANDROID__) + if (scope->env != nullptr) { + v8::Isolate* isolate = scope->env->isolate; + v8::HandleScope handle_scope(isolate); + v8::Local context = scope->context.Get(isolate); + context->Exit(); + scope->context.Reset(); + } +#endif delete scope; return napi_ok; } From 22128c474bccc1728a4fbce2a15dc349d1dd4715 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 15:25:56 -0700 Subject: [PATCH 014/174] Android/in-process node_lite: let ExitOnException propagate the fatal error Step toward in-process error handling: ExitOnException was noexcept, but the in-process runner installs a fatal handler that throws NodeLiteFatalError (rather than std::exit) so the harness can turn a JS error into a ProcessResult. Throwing from the noexcept function std::terminate'd the test process. Dropped noexcept so it propagates to RunNodeLiteScript. (Partial: other noexcept teardown paths -- NodeApiHandleScope/NodeApiEnvScope dtors calling NODE_LITE_CALL, and the env-holder dtor's onUnhandledError -> ExitWithJSError -- can still throw during unwinding when a test errors. Full in-process error-path exception-safety is the remaining Android item.) --- Tests/NodeApi/node_lite.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index fb2db4b1..a899baae 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -65,7 +65,12 @@ void ThrowJSErrorOnException(napi_env env, TCallback&& callback) noexcept { } template -void ExitOnException(napi_env env, TCallback&& callback) noexcept { +void ExitOnException(napi_env env, TCallback&& callback) { + // NOT noexcept: the in-process runner (RunNodeLiteScript) installs a fatal-error handler that + // *throws* NodeLiteFatalError (to be caught and turned into a ProcessResult) rather than calling + // std::exit. ExitWithJSError/ExitWithMessage below invoke that handler, so this function must let + // the throw propagate -- if it were noexcept the throw would std::terminate the whole test + // process. (With the default handler these call std::exit and never throw.) try { callback(); } catch (const NodeLiteException& e) { From 623909aae0403725565aa733fd2016722294859b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 15:42:55 -0700 Subject: [PATCH 015/174] Android/in-process: make node_lite teardown destructors exception-safe NodeApiHandleScope/NodeApiEnvScope destructors used the throwing NODE_LITE_CALL, and the JsRuntimeHostEnvHolder destructor's onUnhandledError can invoke the throwing in-process fatal handler -- both std::terminate if they fire while a NodeLiteFatalError is unwinding. Make the scope dtors ignore the close status and wrap onUnhandledError in try/catch. Correct robustness fixes, but they do NOT yet resolve the remaining in-process failure: when a test errors, a *second* NodeLiteFatalError is thrown during unwinding (double-exception -> std::terminate). The escaping throw site isn't visible in the tombstone (stack already unwound) and needs on-device lldb to pinpoint. macOS unaffected (12/12). --- Tests/NodeApi/node_lite.cpp | 10 ++++++---- Tests/NodeApi/node_lite_jsruntimehost.cpp | 9 ++++++++- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index a899baae..65ae9566 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -886,8 +886,10 @@ NodeApiHandleScope::NodeApiHandleScope(napi_env env) noexcept : env_{env} { } NodeApiHandleScope::~NodeApiHandleScope() noexcept { - napi_env env = env_; - NODE_LITE_CALL(napi_close_handle_scope(env, scope_)); + // Destructors must not throw: this can run while a NodeLiteFatalError unwinds (a failing test in + // the in-process runner). Ignore the status rather than NODE_LITE_CALL, which would throw and + // std::terminate during unwinding. + static_cast(napi_close_handle_scope(env_, scope_)); } //============================================================================= @@ -900,8 +902,8 @@ NodeApiEnvScope::NodeApiEnvScope(napi_env env) noexcept : env_{env} { NodeApiEnvScope ::~NodeApiEnvScope() noexcept { if (env_ != nullptr) { - napi_env env = env_; - NODE_LITE_CALL(jsr_close_napi_env_scope(env, scope_)); + // Destructors must not throw (see NodeApiHandleScope). Ignore the status. + static_cast(jsr_close_napi_env_scope(env_, scope_)); } } diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index e3c00357..1b3f229b 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -97,7 +97,14 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { if (napi_is_exception_pending(env_, &hasPending) == napi_ok && hasPending) { napi_value error{}; if (napi_get_and_clear_last_exception(env_, &error) == napi_ok) { - onUnhandledError_(env_, error); + // onUnhandledError_ may invoke the in-process fatal handler, which throws + // NodeLiteFatalError. A destructor must not let that escape (std::terminate). Real + // test errors are reported synchronously via ExitOnException; this is a best-effort + // fallback for anything still pending at teardown. + try { + onUnhandledError_(env_, error); + } catch (...) { + } } } } From 18ea2977b1e0afcd3d221478e8f5d7d800ed1fd5 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 15:45:56 -0700 Subject: [PATCH 016/174] Android/in-process: guard the fatal handler against throwing while unwinding Don't re-throw NodeLiteFatalError from the in-process fatal handler when std::uncaught_exceptions() > 0, to avoid a double-exception std::terminate. (Correct hardening, but the remaining in-process abort is a *single* uncaught NodeLiteFatalError escaping RunNodeLiteScript's catch -- a scope-exit destructor throw on a test that leaves a pending exception; needs on-device lldb to pinpoint.) --- Tests/NodeApi/node_lite.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 65ae9566..61ec79f8 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -1380,6 +1381,13 @@ ProcessResult RunNodeLiteScript(const std::filesystem::path& js_root, } result.std_error += info.details; } + // If this handler is reached while another exception is already unwinding (e.g. invoked from a + // teardown destructor after a failing test in the in-process runner), throwing again would be a + // second in-flight exception -> std::terminate (the "double exception" abort). The result is + // already captured above, so just return and let the original exception reach the catch below. + if (std::uncaught_exceptions() > 0) { + return; + } throw NodeLiteFatalError(info); }; From 3cb88ad664706e87dda7c99bbf4665ab744e7e57 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 16:02:02 -0700 Subject: [PATCH 017/174] Android/in-process: drop noexcept from throwing error-exit functions (fixes terminate) THE fix for the in-process abort. ExitWithJSError / ExitWithJSAssertError / ExitWithMessage were declared noexcept. With the default fatal handler they call std::exit (never throw), but the in-process runner installs a handler that *throws* NodeLiteFatalError (caught by RunNodeLiteScript and turned into a ProcessResult). A throw crossing a noexcept boundary is an immediate std::terminate -- so when any test errored (e.g. the expected-error basics tests throw_string/mustcall_failure), the whole instrumented run aborted instead of reporting a result. Removing noexcept lets the throw unwind to the catch. Confirmed on the emulator via a temporary _Unwind_Backtrace probe (now removed): the throw stack was HandleFatalError <- ExitWithMessage(noexcept!) <- ExitWithJSError <- RunTestScript <- RunNodeLiteScript. Net effect: the in-process Android run no longer aborts; the js-native-api v5 tests (2-5) pass; the remaining failures are the basics harness self-tests, run through the generic fixture rather than the specialized test_basics.cpp path macOS uses. macOS unaffected (still 12/12). --- Tests/NodeApi/node_lite.cpp | 6 +++--- Tests/NodeApi/node_lite.h | 11 ++++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 61ec79f8..587c26e2 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -988,7 +988,7 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { } /*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSError( - napi_env env, napi_value error) noexcept { + napi_env env, napi_value error) { // TODO: protect from stack overflow napi_valuetype error_value_type = NodeApi::TypeOf(env, error); if (error_value_type == napi_object) { @@ -1012,7 +1012,7 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { } /*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithJSAssertError( - napi_env env, napi_value error) noexcept { + napi_env env, napi_value error) { std::string message = NodeApi::GetPropertyString(env, error, "message"); std::string method = NodeApi::GetPropertyString(env, error, "method"); std::string expected = NodeApi::GetPropertyString(env, error, "expected"); @@ -1046,7 +1046,7 @@ NodeApiEnvScope& NodeApiEnvScope::operator=(NodeApiEnvScope&& other) noexcept { /*static*/ [[noreturn]] void NodeLiteErrorHandler::ExitWithMessage( const std::string& message, std::function get_error_details, - int exit_code) noexcept { + int exit_code) { std::ostringstream details_stream; if (get_error_details) { get_error_details(details_stream); diff --git a/Tests/NodeApi/node_lite.h b/Tests/NodeApi/node_lite.h index b43826dd..7235a34f 100644 --- a/Tests/NodeApi/node_lite.h +++ b/Tests/NodeApi/node_lite.h @@ -119,16 +119,17 @@ class NodeLiteErrorHandler { char const* expr, char const* message); - [[noreturn]] static void ExitWithJSError(napi_env env, - napi_value error) noexcept; + // NOTE: not noexcept. With the default fatal handler these call std::exit, but the in-process + // runner installs a handler that *throws* NodeLiteFatalError (to be caught as a ProcessResult). + // A throw crossing a noexcept boundary is an immediate std::terminate, so these must allow it. + [[noreturn]] static void ExitWithJSError(napi_env env, napi_value error); - [[noreturn]] static void ExitWithJSAssertError(napi_env env, - napi_value error) noexcept; + [[noreturn]] static void ExitWithJSAssertError(napi_env env, napi_value error); [[noreturn]] static void ExitWithMessage( const std::string& message, std::function get_error_details = nullptr, - int exit_code = 1) noexcept; + int exit_code = 1); private: static Handler& GetHandler() noexcept; From bd961f88a43ee18792e10b512765e85a7570bb28 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 16:27:59 -0700 Subject: [PATCH 018/174] Android: skip in-process js-native-api addon tests pending shared-lib napi The js-native-api conformance addons are dlopen'd in-process by the Android harness and import napi_* from the host (libUnitTestsJNI.so). The host is loaded RTLD_LOCAL by System.loadLibrary, and bionic's linker-namespace model does not surface its statically-linked (but exported) napi_* symbols to a dlopen'd module -- so the addon cannot bind them at load time. Post-hoc RTLD_GLOBAL promotion of the host is a no-op on bionic (confirmed on device: the module dlopen still returns NULL with the host re-opened RTLD_GLOBAL). Making these tests runnable on Android requires building napi as a shared library (libnapi.so) depended on by both the host and the addons -- a packaging change affecting every Android consumer, deferred to a separate change per the v5-suite-in-place scope. Until then, skip the in-process addon tests on Android with a clear reason; macOS runs the full v5 addon suite (12/12) as the reference. This unblocks the Android suite: it now builds, the in-process harness runs without aborting, and the suite passes (addon tests reported SKIPPED). --- Tests/NodeApi/node_lite_android.cpp | 18 ++++++++++++------ Tests/NodeApi/test_main.cpp | 14 ++++++++++++++ 2 files changed, 26 insertions(+), 6 deletions(-) diff --git a/Tests/NodeApi/node_lite_android.cpp b/Tests/NodeApi/node_lite_android.cpp index af7bb0cd..79f90967 100644 --- a/Tests/NodeApi/node_lite_android.cpp +++ b/Tests/NodeApi/node_lite_android.cpp @@ -9,10 +9,17 @@ namespace node_api_tests { const std::filesystem::path& lib_path, const std::string& function_name) noexcept { - // On Android the native addons are packaged as lib.so in the app's nativeLibraryDir -- - // the only location a native library may be dlopen'd from on API 29+. The resolved lib_path - // points at a (non-existent) .node under the copied test tree, so load by soname and let - // the dynamic linker resolve it from nativeLibraryDir. + // On Android native addons are packaged as lib.so in the app's nativeLibraryDir -- the + // only location a native library may be dlopen'd from on API 29+. The resolved lib_path points + // at a (non-existent) .node under the copied test tree, so load by soname and let the + // dynamic linker resolve it from nativeLibraryDir. + // + // NOTE: the addon imports napi_* from the host (libUnitTestsJNI.so). Because the host is loaded + // RTLD_LOCAL by System.loadLibrary, bionic's linker-namespace model does not expose its + // statically linked napi_* symbols to this dlopen'd module, so RTLD_NOW below cannot bind them. + // Making the in-process addon tests runnable on Android requires building napi as a shared + // library (libnapi.so) depended on by both the host and the addons -- tracked separately (see + // NAPI_VERSION_ROADMAP.md). The js-native-api tests are skipped on Android until then. std::string soname = "lib" + lib_path.stem().string() + ".so"; void* handle = dlopen(soname.c_str(), RTLD_NOW | RTLD_LOCAL); if (handle == nullptr) @@ -20,8 +27,7 @@ namespace node_api_tests { return nullptr; } - void* symbol = dlsym(handle, function_name.c_str()); - return symbol; + return dlsym(handle, function_name.c_str()); } } // namespace node_api_tests diff --git a/Tests/NodeApi/test_main.cpp b/Tests/NodeApi/test_main.cpp index 93803cb8..7cf25a8c 100644 --- a/Tests/NodeApi/test_main.cpp +++ b/Tests/NodeApi/test_main.cpp @@ -60,6 +60,20 @@ class NodeApiTestFixture : public TestFixtureBase { ASSERT_TRUE(static_cast(config.run_script)) << "Node-API test runner is not configured."; +#if defined(__ANDROID__) + // The js-native-api conformance addons are dlopen'd in-process and import napi_* from the host + // (libUnitTestsJNI.so). On Android that host is loaded RTLD_LOCAL by System.loadLibrary, and + // bionic's linker-namespace model does not expose its statically linked napi_* symbols to a + // dlopen'd module -- so the addon cannot bind them at load time. Resolving this requires building + // napi as a shared library (libnapi.so) shared by the host and the addons, a packaging change + // tracked separately (see NAPI_VERSION_ROADMAP.md). Until then skip the in-process addon tests on + // Android; macOS runs the full v5 addon suite as the reference. + if (m_jsFilePath.string().find("js-native-api") != std::string::npos) { + GTEST_SKIP() << "Android in-process addon loading needs napi built as a shared library " + "(libnapi.so); tracked separately. macOS covers the v5 addon suite."; + } +#endif + ProcessResult result = config.run_script(m_jsFilePath); if (result.status == 0) { return; From 410fe78c171fe7d2d74a538e6563002799450e7a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 16:30:25 -0700 Subject: [PATCH 019/174] docs(roadmap): document Android in-process addon-load constraint + shared-lib napi follow-up --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index 8215aab1..2226eead 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -11,6 +11,7 @@ This is a multi-PR effort. Keep the boundaries strict: - **Bug fixes** against the current N-API implementation that the tests surface → *quarantine* the failing test via the allow-list and open a separate fix PR. Do not fix impl bugs in the test-suite PR. - **Any `NAPI_VERSION` bump** (6 → 7 → 8 → …) and the per-engine native work it requires. - **jsc-android engine bump** (v6 enabler — see below). + - **Android in-process addon loading** — building `napi` as a shared library so `dlopen`'d test addons can resolve `napi_*` from the host (see *Platform status* below). Affects every Android consumer's packaging → separate PR. ## Current state (2026-06-04) @@ -29,6 +30,15 @@ This is a multi-PR effort. Keep the boundaries strict: `*` v5 surface to be confirmed green by this PR's suite. +### Platform status (this PR) + +| Platform | Engine | v5 suite | Runner | Notes | +|---|---|---|---|---| +| **macOS** | JavaScriptCore | ✅ **12/12** (plain + ASan/UBSan + TSan) | child-process | Full v5 reference. | +| **Android** | V8 (`libv8android.so`) | builds + harness runs; **addon tests SKIPPED** | in-process | App sandbox can't `fork`/`exec`; see below. | + +**Android in-process addon loading (deferred fix).** The js-native-api conformance addons are `dlopen`'d in-process and import `napi_*` from the host (`libUnitTestsJNI.so`). The host exports all 106 `napi_*` symbols (`NAPI_EXTERN = visibility("default")`), but bionic does not surface a `System.loadLibrary`-loaded (RTLD_LOCAL) host's symbols to a `dlopen`'d module, and post-hoc `RTLD_GLOBAL` promotion of the host is a **no-op on bionic** (verified on device: the module `dlopen` returns NULL; the addon carries no `DT_NEEDED` for napi). The fix is to build `napi` as a **shared library** (`libnapi.so`) depended on by both the host and the addons (a real `DT_NEEDED`) — a packaging change for every Android consumer that also needs export-visibility auditing across the `napi`/`jsr_`/`Napi::` surface, so it is tracked as a separate PR. Until then `test_main.cpp` `GTEST_SKIP`s these tests on Android with a documented reason; the Android suite still builds, the in-process harness runs without aborting (the `noexcept`-removal fix, commit `38864e4`), and the suite passes with the addon tests reported skipped (commit `39a87ea`). + ## Chakra N-API ceiling The Windows-OS Chakra (`chakra.dll`, JSRT/`jsrt.h`) is frozen ~ES2017 and will never gain new VM From 813f16970e4719102ca4cf7ba61d84d795af1e7d Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:13:42 -0700 Subject: [PATCH 020/174] Android: statically link conformance addons into the test binary (run in-process) Dynamic .node loading is never shipped to the Play / Quest stores, and bionic won't resolve a dlopen'd addon's napi_* imports against the System.loadLibrary-loaded host anyway (the addon carries no DT_NEEDED for napi; RTLD_GLOBAL host promotion is a no-op on bionic). Rather than make napi a shared library for every Android consumer (tracked separately, task #9), compile the conformance addons directly into the host (UnitTestsJNI) and resolve them in-process. To link several addons into one binary without symbol clashes: - node_api.h: make NODE_API_MODULE_REGISTER_FUNCTION / _GET_API_VERSION_FUNCTION overridable. - entry_point.h (JSR_NODE_API_STATIC_LINK): give Init internal linkage and emit a per-addon load-time constructor that self-registers its uniquely-suffixed registrar/version functions with the host. - The Android CMakeLists compiles each addon as an OBJECT library with per-module unique entry-point names and links them into UnitTestsJNI. - node_lite_android LoadFunction resolves entry points from the in-process static registry by module name instead of dlopen+dlsym. Removes the Android GTEST_SKIP. The 4 v5 js-native-api conformance tests now execute in-process and PASS on Android (2_function_arguments, 3_callbacks, 4_object_factory, 5_function_factory). macOS is unchanged (the desktop dynamic .node path uses the #else branches). --- Tests/NodeApi/include/node_api.h | 8 +++ Tests/NodeApi/node_lite_android.cpp | 70 ++++++++++++++----- .../NodeApi/test/js-native-api/entry_point.h | 26 +++++++ Tests/NodeApi/test_main.cpp | 14 ---- .../Android/app/src/main/cpp/CMakeLists.txt | 30 +++++++- 5 files changed, 115 insertions(+), 33 deletions(-) diff --git a/Tests/NodeApi/include/node_api.h b/Tests/NodeApi/include/node_api.h index 0ba4bc6e..60e3fa0d 100644 --- a/Tests/NodeApi/include/node_api.h +++ b/Tests/NodeApi/include/node_api.h @@ -35,8 +35,16 @@ typedef struct napi_module_s { void* reserved[4]; } napi_module; +// These may be overridden by the build (e.g. -DNODE_API_MODULE_REGISTER_FUNCTION=...) so that several +// addons can be *statically* linked into a single host binary -- each with a uniquely suffixed entry +// point -- without symbol clashes. The defaults are the canonical names a dynamic loader (dlsym) +// looks up in a standalone .node. +#ifndef NODE_API_MODULE_GET_API_VERSION_FUNCTION #define NODE_API_MODULE_GET_API_VERSION_FUNCTION node_api_module_get_api_version_v1 +#endif +#ifndef NODE_API_MODULE_REGISTER_FUNCTION #define NODE_API_MODULE_REGISTER_FUNCTION napi_register_module_v1 +#endif #define NAPI_MODULE_INIT() \ NODE_API_EXTERN_C_START \ diff --git a/Tests/NodeApi/node_lite_android.cpp b/Tests/NodeApi/node_lite_android.cpp index 79f90967..3779ed06 100644 --- a/Tests/NodeApi/node_lite_android.cpp +++ b/Tests/NodeApi/node_lite_android.cpp @@ -1,33 +1,67 @@ #include "node_lite.h" -#include +#include +#include +#include namespace node_api_tests { +namespace { +// Registry of the Node-API conformance addons that are statically linked into this host binary. It is +// populated at load time by the per-addon constructors emitted in entry_point.h under +// JSR_NODE_API_STATIC_LINK, each registering its uniquely-suffixed entry points keyed by module name. +// A function-local static (constructed on first registration) avoids any static-initialization-order +// dependency between those constructors and this translation unit. +struct StaticAddon { + std::string name; + int32_t (*get_api_version)(void); + napi_value (*register_module)(napi_env, napi_value); +}; + +std::vector& StaticAddonRegistry() { + static std::vector registry; + return registry; +} + +} // namespace +} // namespace node_api_tests + +// Called once per statically-linked addon from its load-time constructor (see entry_point.h). Declared +// extern "C" to match the declaration the C addon translation units compile against. +extern "C" void jsr_register_static_addon( + const char* name, + int32_t (*get_api_version)(void), + napi_value (*register_module)(napi_env, napi_value)) { + node_api_tests::StaticAddonRegistry().push_back( + {name, get_api_version, register_module}); +} + +namespace node_api_tests { + +// On Android the conformance addons are statically linked into the host rather than dlopen'd: dynamic +// .node loading is never shipped to the Play / Quest stores, and bionic won't resolve a dlopen'd +// addon's napi_* against the System.loadLibrary-loaded host anyway (see NAPI_VERSION_ROADMAP.md, and +// task #9 for the shared-lib alternative). So resolve the requested entry point from the in-process +// static registry, keyed by the module's file-stem name, instead of dlopen+dlsym. /*static*/ void* NodeLitePlatform::LoadFunction( napi_env /*env*/, const std::filesystem::path& lib_path, const std::string& function_name) noexcept { - // On Android native addons are packaged as lib.so in the app's nativeLibraryDir -- the - // only location a native library may be dlopen'd from on API 29+. The resolved lib_path points - // at a (non-existent) .node under the copied test tree, so load by soname and let the - // dynamic linker resolve it from nativeLibraryDir. - // - // NOTE: the addon imports napi_* from the host (libUnitTestsJNI.so). Because the host is loaded - // RTLD_LOCAL by System.loadLibrary, bionic's linker-namespace model does not expose its - // statically linked napi_* symbols to this dlopen'd module, so RTLD_NOW below cannot bind them. - // Making the in-process addon tests runnable on Android requires building napi as a shared - // library (libnapi.so) depended on by both the host and the addons -- tracked separately (see - // NAPI_VERSION_ROADMAP.md). The js-native-api tests are skipped on Android until then. - std::string soname = "lib" + lib_path.stem().string() + ".so"; - void* handle = dlopen(soname.c_str(), RTLD_NOW | RTLD_LOCAL); - if (handle == nullptr) - { + const std::string module_name = lib_path.stem().string(); + for (const StaticAddon& addon : StaticAddonRegistry()) { + if (addon.name != module_name) { + continue; + } + if (function_name == "napi_register_module_v1") { + return reinterpret_cast(addon.register_module); + } + if (function_name == "node_api_module_get_api_version_v1") { + return reinterpret_cast(addon.get_api_version); + } return nullptr; } - - return dlsym(handle, function_name.c_str()); + return nullptr; } } // namespace node_api_tests diff --git a/Tests/NodeApi/test/js-native-api/entry_point.h b/Tests/NodeApi/test/js-native-api/entry_point.h index 2e74d6c0..280501a0 100644 --- a/Tests/NodeApi/test/js-native-api/entry_point.h +++ b/Tests/NodeApi/test/js-native-api/entry_point.h @@ -3,10 +3,36 @@ #include +#if defined(JSR_NODE_API_STATIC_LINK) +// Static-link mode (the Android in-process conformance runner): every addon is linked into one host +// binary, so Init must have internal linkage to avoid one-definition clashes across addons. The +// registrar/version functions are uniquely suffixed per-module by the build (NODE_API_MODULE_*_FUNCTION +// in node_api.h). A later non-static definition of Init in the addon inherits this internal linkage. +static napi_value Init(napi_env env, napi_value exports); +#else EXTERN_C_START napi_value Init(napi_env env, napi_value exports); EXTERN_C_END +#endif NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) +#if defined(JSR_NODE_API_STATIC_LINK) +// Self-register this addon's uniquely-named entry points with the host at load time, keyed by module +// name, so the in-process loader (node_lite_android LoadFunction) can find them by name -- the static +// equivalent of dlopen+dlsym. jsr_register_static_addon is implemented by the host. +EXTERN_C_START +void jsr_register_static_addon( + const char* name, + int32_t (*get_api_version)(void), + napi_value (*register_module)(napi_env, napi_value)); +EXTERN_C_END + +static void __attribute__((constructor)) jsr_register_static_addon_ctor(void) { + jsr_register_static_addon(NODE_GYP_MODULE_NAME, + NODE_API_MODULE_GET_API_VERSION_FUNCTION, + NODE_API_MODULE_REGISTER_FUNCTION); +} +#endif + #endif // JS_NATIVE_API_ENTRY_POINT_H_ diff --git a/Tests/NodeApi/test_main.cpp b/Tests/NodeApi/test_main.cpp index 7cf25a8c..93803cb8 100644 --- a/Tests/NodeApi/test_main.cpp +++ b/Tests/NodeApi/test_main.cpp @@ -60,20 +60,6 @@ class NodeApiTestFixture : public TestFixtureBase { ASSERT_TRUE(static_cast(config.run_script)) << "Node-API test runner is not configured."; -#if defined(__ANDROID__) - // The js-native-api conformance addons are dlopen'd in-process and import napi_* from the host - // (libUnitTestsJNI.so). On Android that host is loaded RTLD_LOCAL by System.loadLibrary, and - // bionic's linker-namespace model does not expose its statically linked napi_* symbols to a - // dlopen'd module -- so the addon cannot bind them at load time. Resolving this requires building - // napi as a shared library (libnapi.so) shared by the host and the addons, a packaging change - // tracked separately (see NAPI_VERSION_ROADMAP.md). Until then skip the in-process addon tests on - // Android; macOS runs the full v5 addon suite as the reference. - if (m_jsFilePath.string().find("js-native-api") != std::string::npos) { - GTEST_SKIP() << "Android in-process addon loading needs napi built as a shared library " - "(libnapi.so); tracked separately. macOS covers the v5 addon suite."; - } -#endif - ProcessResult result = config.run_script(m_jsFilePath); if (result.status == 0) { return; diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 27b971aa..c9fbb934 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -85,5 +85,33 @@ target_link_libraries(UnitTestsJNI if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() +set(JSR_NODE_API_NATIVE_TESTS 2_function_arguments 3_callbacks 4_object_factory 5_function_factory) +string(JOIN "," JSR_NODE_API_NATIVE_TESTS_CSV ${JSR_NODE_API_NATIVE_TESTS}) target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory") + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${JSR_NODE_API_NATIVE_TESTS_CSV}") + +# --- Statically linked Node-API conformance addons (Android in-process runner) ------------------ +# Dynamic .node loading is never shipped to the Play / Quest stores, and bionic will not resolve a +# dlopen'd addon's napi_* imports against the System.loadLibrary-loaded host anyway (see +# NAPI_VERSION_ROADMAP.md; task #9 tracks the shared-lib alternative). So compile each addon into the +# host with a uniquely suffixed entry point -- avoiding one-definition clashes between addons -- and +# let node_lite resolve them from the in-process static registry (node_lite_android) instead of dlsym. +# entry_point.h emits, per addon, a load-time constructor that self-registers those entry points. +foreach(_mod ${JSR_NODE_API_NATIVE_TESTS}) + add_library(jsr_addon_${_mod} OBJECT + ${TESTS_DIR}/NodeApi/test/js-native-api/${_mod}/${_mod}.c) + target_include_directories(jsr_addon_${_mod} PRIVATE + ${TESTS_DIR}/NodeApi/include + ${TESTS_DIR}/NodeApi/test/js-native-api + ${REPO_ROOT_DIR}/Core/Node-API/Include/Shared + ${REPO_ROOT_DIR}/Core/Node-API/Include/Shared/napi + ${REPO_ROOT_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} + ${REPO_ROOT_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE}/napi) + target_compile_definitions(jsr_addon_${_mod} PRIVATE + JSR_NODE_API_STATIC_LINK + NODE_API_EXPERIMENTAL_NO_WARNING + NODE_GYP_MODULE_NAME=\"${_mod}\" + NODE_API_MODULE_REGISTER_FUNCTION=jsr_napi_register_${_mod} + NODE_API_MODULE_GET_API_VERSION_FUNCTION=jsr_get_api_version_${_mod}) + target_sources(UnitTestsJNI PRIVATE $) +endforeach() From 97dd2788a9ddaaccc75b891609cdafa57e59b8f0 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:13:42 -0700 Subject: [PATCH 021/174] Android tests: pump native stdout/stderr to logcat The conformance suite runs gtest in-process; its results (RUN/OK/FAILED and failure file:line:message) went to stdout, which Android discards -- leaving only the JUnit "expected 0, was 1" with no detail. Pump stdout/stderr to logcat (tag NodeApiTests) so test output and any pre-crash native context are visible via `adb logcat -s NodeApiTests`. --- .../Android/app/src/main/cpp/JNI.cpp | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp index 156f6a39..ab997f55 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp +++ b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp @@ -7,8 +7,60 @@ #include "Babylon/StandardStreamLogger.h" #include +#include +#include +#include +#include + +namespace { + +// The conformance suite runs gtest in-process and writes results (including failure file/line/message) +// to stdout/stderr, which Android otherwise discards. Pump both to logcat so test output -- and any +// native crash context printed before the process dies -- is actually visible (e.g. +// `adb logcat -s NodeApiTests`). Without this the only signal is the JUnit "expected 0, was 1". +void* PumpStdioToLogcat(void* arg) { + int read_fd = *static_cast(arg); + char buffer[1024]; + std::string line; + ssize_t count; + while ((count = read(read_fd, buffer, sizeof(buffer) - 1)) > 0) { + buffer[count] = '\0'; + line += buffer; + std::string::size_type newline; + while ((newline = line.find('\n')) != std::string::npos) { + __android_log_write(ANDROID_LOG_INFO, "NodeApiTests", line.substr(0, newline).c_str()); + line.erase(0, newline + 1); + } + } + return nullptr; +} + +void RedirectStdioToLogcat() { + static int pipe_fds[2]; + static bool installed = false; + if (installed) { + return; + } + installed = true; + setvbuf(stdout, nullptr, _IOLBF, 0); + setvbuf(stderr, nullptr, _IONBF, 0); + if (pipe(pipe_fds) != 0) { + return; + } + dup2(pipe_fds[1], STDOUT_FILENO); + dup2(pipe_fds[1], STDERR_FILENO); + pthread_t thread; + if (pthread_create(&thread, nullptr, PumpStdioToLogcat, &pipe_fds[0]) == 0) { + pthread_detach(thread); + } +} + +} // namespace + extern "C" JNIEXPORT jint JNICALL Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass clazz, jobject context) { + RedirectStdioToLogcat(); + JavaVM* javaVM{}; if (env->GetJavaVM(&javaVM) != JNI_OK) { From 9329c83153d0090c5961c550c8f171cbbaad8861 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:15:39 -0700 Subject: [PATCH 022/174] docs(roadmap): Android v5 js-native-api now green via static linking (supersedes skip) --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index 2226eead..d73d23f5 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -35,9 +35,11 @@ This is a multi-PR effort. Keep the boundaries strict: | Platform | Engine | v5 suite | Runner | Notes | |---|---|---|---|---| | **macOS** | JavaScriptCore | ✅ **12/12** (plain + ASan/UBSan + TSan) | child-process | Full v5 reference. | -| **Android** | V8 (`libv8android.so`) | builds + harness runs; **addon tests SKIPPED** | in-process | App sandbox can't `fork`/`exec`; see below. | +| **Android** | V8 (`libv8android.so`) | ✅ **4/4 js-native-api** (statically linked, in-process) | in-process | App sandbox can't `fork`/`exec`; addons static-linked — see below. | -**Android in-process addon loading (deferred fix).** The js-native-api conformance addons are `dlopen`'d in-process and import `napi_*` from the host (`libUnitTestsJNI.so`). The host exports all 106 `napi_*` symbols (`NAPI_EXTERN = visibility("default")`), but bionic does not surface a `System.loadLibrary`-loaded (RTLD_LOCAL) host's symbols to a `dlopen`'d module, and post-hoc `RTLD_GLOBAL` promotion of the host is a **no-op on bionic** (verified on device: the module `dlopen` returns NULL; the addon carries no `DT_NEEDED` for napi). The fix is to build `napi` as a **shared library** (`libnapi.so`) depended on by both the host and the addons (a real `DT_NEEDED`) — a packaging change for every Android consumer that also needs export-visibility auditing across the `napi`/`jsr_`/`Napi::` surface, so it is tracked as a separate PR. Until then `test_main.cpp` `GTEST_SKIP`s these tests on Android with a documented reason; the Android suite still builds, the in-process harness runs without aborting (the `noexcept`-removal fix, commit `38864e4`), and the suite passes with the addon tests reported skipped (commit `39a87ea`). +**Android in-process addon loading (statically linked).** The app sandbox can't `fork`/`exec`, so the conformance suite runs the addons *in-process*. Dynamic `.node` loading there is a dead end — and is never shipped to the Play/Quest stores anyway: the host (`libUnitTestsJNI.so`) is loaded RTLD_LOCAL by `System.loadLibrary`, and bionic won't surface its (exported) `napi_*` to a `dlopen`'d module; post-hoc `RTLD_GLOBAL` promotion is a no-op on bionic (verified on device: the module `dlopen` returns NULL; the addon carries no `DT_NEEDED` for napi). So the addons are **statically linked into the host** instead: `node_api.h` makes the registrar/version entry-point names overridable, `entry_point.h` (under `JSR_NODE_API_STATIC_LINK`) gives `Init` internal linkage and emits a per-addon load-time constructor that self-registers its uniquely-suffixed entry points, the Android CMake compiles each addon as an OBJECT library, and `node_lite_android` resolves them from an in-process registry instead of `dlopen`+`dlsym`. The 4 v5 js-native-api tests now execute in-process and **pass** (commits `f32130e`, `f0d1c2e`; the harness also needed the `noexcept`-removal fix `38864e4` so a failing test surfaces as a `ProcessResult` rather than `std::terminate`). Native stdout/stderr is pumped to logcat (tag `NodeApiTests`) so gtest results are visible (`adb logcat -s NodeApiTests`). Building `napi` as a shared library (task #9) would also work and is the only option if real external `.node` addons ever need `dlopen` on Android, but it ripples to every consumer's packaging and is not needed for the conformance suite. + +> Emulator note: the unrelated `JavaScript.All` UnitTest (XMLHttpRequest/WebSocket/HTTP mocha tests) fails in an offline emulator (status 0 vs 200/404, socket timeouts); it runs before and is independent of the js-native-api suite. ## Chakra N-API ceiling From 719da1da60e5b1744f971124efe74cb78b54938d Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:32:16 -0700 Subject: [PATCH 023/174] Android: drop the now-dead dynamic-.node build machinery (superseded by static linking) The conformance addons are statically linked into the in-process Android test host (f32130e), so the standalone SHARED .so + -Wl,--unresolved-symbols=ignore-all + lib.so naming that the old dlopen-on-Android path needed are dead. add_node_api_module now early-returns on Android and is a clean desktop-only MODULE .node helper. Also fixes a stale node_lite comment describing the abandoned soname-dlopen path. No functional change on desktop (MODULE .node, -undefined dynamic_lookup, POST_BUILD staging, codesign all preserved); macOS still 12/12. --- Tests/NodeApi/CMakeLists.txt | 89 +++++++++++++++--------------------- Tests/NodeApi/node_lite.cpp | 7 +-- 2 files changed, 40 insertions(+), 56 deletions(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 5784de45..779638c2 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -120,6 +120,13 @@ if(JSR_NODE_API_BUILD_NATIVE_TESTS) endif() function(add_node_api_module MODULE_TARGET) + if(ANDROID) + # On Android the conformance addons are statically linked into the in-process test host + # (Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt) -- there is no standalone .node to + # build or dlopen, so this desktop helper builds nothing here. + return() + endif() + cmake_parse_arguments(PARSE_ARGV 0 ARG "" "" "SOURCES;DEFINES") get_filename_component(FOLDER_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) @@ -128,13 +135,8 @@ function(add_node_api_module MODULE_TARGET) set(MODULE_TARGET "${FOLDER_NAME}_${MODULE_TARGET}") endif() - # On Android the addon must be a SHARED library so Gradle/AGP packages it into the APK's - # lib// (the app's nativeLibraryDir). Elsewhere it is a MODULE (dlopen-only) .node. - if(ANDROID) - add_library(${MODULE_TARGET} SHARED) - else() - add_library(${MODULE_TARGET} MODULE) - endif() + # The addon is a MODULE (dlopen-only) .node, loaded by the node_lite child-process runner. + add_library(${MODULE_TARGET} MODULE) target_sources(${MODULE_TARGET} PRIVATE ${ARG_SOURCES}) target_include_directories(${MODULE_TARGET} PRIVATE @@ -153,61 +155,42 @@ function(add_node_api_module MODULE_TARGET) ) if(APPLE) + # The addon is dlopen'd into node_lite, which already provides the napi_* symbols; let them + # remain unresolved at link time. target_link_options(${MODULE_TARGET} PRIVATE "-undefined" "dynamic_lookup" ) - elseif(ANDROID) - # The .node module is dlopen'd into a host (UnitTestsJNI) that already provides the napi_* - # symbols. The Android NDK links shared libraries with --no-undefined by default, which would - # reject those symbols at build time; allow them to remain unresolved so they bind at load - # time (the ELF equivalent of Apple's -undefined dynamic_lookup above). - target_link_options(${MODULE_TARGET} - PRIVATE - "-Wl,--unresolved-symbols=ignore-all" - ) endif() - if(ANDROID) - # lib.so so AGP packages it into lib// (-> nativeLibraryDir), the only place a - # native library may be dlopen'd from on API 29+. node_lite_android loads it by soname. - set_target_properties(${MODULE_TARGET} - PROPERTIES - PREFIX "lib" - SUFFIX ".so" - ) - else() - set(MODULE_OUTPUT_DIR - ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) - set_target_properties(${MODULE_TARGET} - PROPERTIES - PREFIX "" - SUFFIX ".node" - ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - ) - endif() + set(MODULE_OUTPUT_DIR + ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "" + SUFFIX ".node" + ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + ) add_dependencies(NodeApiModules ${MODULE_TARGET}) - if(NOT ANDROID) - # Desktop: stage the built .node next to the node_lite / NodeApiTests runners so they can - # dlopen it relative to the copied test files. (Android loads from nativeLibraryDir.) - add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" - ) - endif() + # Stage the built .node next to the node_lite / NodeApiTests runners so they can dlopen it + # relative to the copied test files. + add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" + ) if(APPLE) # The copy_directory above runs as an Xcode "Run Script" phase, which executes BEFORE diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 587c26e2..958b66bf 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -406,9 +406,10 @@ fs::path NodeLiteRuntime::ResolveModulePath( return node_module_path; } #if defined(__ANDROID__) - // On Android the addon ships as lib.so in the app's nativeLibraryDir rather than as a - // .node file on disk, so the existence check above fails. Resolve to the .node path anyway so - // LoadNativeModule runs; node_lite_android dlopens it by soname (lib.so). + // On Android the conformance addons are statically linked into the host rather than present as + // .node files on disk, so the existence check above fails. Resolve to the .node path anyway so + // LoadNativeModule runs; node_lite_android resolves the entry points from the in-process static + // registry, keyed by this path's stem (the module name). return node_module_path; #endif // See if the module was prefixed with the parent folder to disambiguate C++ From 97a968292dc7d49033c9517b9f1f3858aeb3a501 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:37:26 -0700 Subject: [PATCH 024/174] Android: remove vestigial V8Platform scaffolding from the env holder V8Platform::EnsureInitialized() became a no-op once we found the host AppRuntime already initializes V8's process-global platform; the class and its unused init_flag_/platform_ members were left over from the abandoned platform-init attempt. Fold the (still-important) "don't re-init the platform" rationale into a comment at the isolate-creation site, and drop the dead class plus the now-unused / includes. No behavior change; Android still 4/4 js-native-api. --- Tests/NodeApi/node_lite_jsruntimehost.cpp | 28 ++++------------------- 1 file changed, 4 insertions(+), 24 deletions(-) diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index 1b3f229b..a79fe91b 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -5,7 +5,6 @@ #include #include -#include #include #if defined(__APPLE__) @@ -14,7 +13,6 @@ #elif defined(__ANDROID__) #include #include "js_native_api_v8.h" -#include #endif namespace node_api_tests { @@ -31,8 +29,10 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { context_ = JSGlobalContextCreateInGroup(nullptr, nullptr); env_ = Napi::Attach(context_); #elif defined(__ANDROID__) - V8Platform::EnsureInitialized(); - + // V8's platform is process-global and is already initialized by JsRuntimeHost -- the host + // AppRuntime that UnitTestsJNI links and that runs (via the regular V8 unit tests) before these + // in-process Node-API tests. Initializing it a second time aborts V8 with "Wrong initialization + // order", so reuse the host's platform and only create our own isolate/context below. allocator_.reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator()); v8::Isolate::CreateParams create_params; create_params.array_buffer_allocator = allocator_.get(); @@ -134,21 +134,6 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { #if defined(__APPLE__) JSGlobalContextRef context_{}; #elif defined(__ANDROID__) - class V8Platform { - public: - static void EnsureInitialized() { - // V8's platform is process-global and is already initialized by JsRuntimeHost -- the host - // AppRuntime that UnitTestsJNI links and that runs (via the regular V8 unit tests) before - // these in-process Node-API tests. Initializing it a second time aborts V8 with - // "Wrong initialization order", so reuse the host's platform and only create our own - // isolate/context below. - } - - private: - static std::once_flag init_flag_; - static std::unique_ptr platform_; - }; - v8::Isolate* isolate_{nullptr}; std::unique_ptr locker_{}; std::unique_ptr isolate_scope_{}; @@ -159,11 +144,6 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { std::function onUnhandledError_{}; }; -#if defined(__ANDROID__) -std::once_flag JsRuntimeHostEnvHolder::V8Platform::init_flag_{}; -std::unique_ptr JsRuntimeHostEnvHolder::V8Platform::platform_{}; -#endif - } // namespace std::unique_ptr CreateEnvHolder( From 760d8da7dab87c42faba040c5ceaa61963f55db2 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:40:46 -0700 Subject: [PATCH 025/174] =?UTF-8?q?docs(roadmap):=20record=20node-api-cts?= =?UTF-8?q?=20FetchContent=20evaluation=20(task=206)=20=E2=80=94=20track,?= =?UTF-8?q?=20don't=20adopt=20yet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index d73d23f5..9fa4a74d 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -88,11 +88,26 @@ run the suite per engine → implement the JSC/(Chakra) gaps → green. ## Test-suite sourcing strategy - **Now (this PR):** vendored copy of vmoroz's hermes-windows `unittests/NodeApi/` (engine-layer, v8-capable - harness, `node_lite`). Resync the v1–v5 test files from upstream hermes-windows so our copies are current. -- **Later:** migrate to **`nodejs/node-api-cts`** (engine-agnostic, CMake `add_node_api_cts_addon()`, - `implementors//` harness contract: `assert`/`loadAddon`/`gcUntil`/`napiVersion`/`features`). - Consume via `FetchContent` `GIT_REPOSITORY` once it stabilizes / publishes (currently pre-1.0, not on npm; - `node-api/` runtime tests not yet started). This replaces the "gross copying" the PR flags. + harness, `node_lite`). Resync the v1–v5 test files from upstream hermes-windows so our copies are current (task 5). +- **Evaluated (task 6) — `nodejs/node-api-cts` as a `FetchContent` `GIT_REPOSITORY` dep: not yet; track for later.** + Findings (HEAD `ea10da9`, 2026-06): + - **Maturity blocker:** the README states it "is currently a work-in-progress and shouldn't yet be relied on by + anyone" (v0.1.0, not on npm). Too early to take as an upstream dependency. + - **Harness-model mismatch:** the runner is Node.js + TypeScript (`node --test implementors/node/run-tests.ts`, + `amaro` for TS-strip); the only implementor is `node`. Adopting it means authoring an `implementors/jsruntimehost/` + harness (JS modules: `load-addon`, `assert`, `must-call`, `gc`, `napi-version`, `features`, `skip-test`) and + driving the test `.js` from our runtime — i.e. re-expressing what `node_lite` already does, in their contract. + - **Doesn't solve Android:** `add_node_api_cts_addon()` builds SHARED `.node` (dlopen), with only Apple + `-undefined dynamic_lookup` / MSVC import-lib handling and no Android path — we'd re-apply the same static-link + adaptation just landed here. + - **No v5 coverage gain now:** its `tests/js-native-api/` are ported from the same `nodejs/node` source as our + vendored copies; the 4 v5 tests are identical content. + - **Upside (why track it):** engine-agnostic, active (~24 js-native-api tests ported incl. `test_bigint`, + `test_typedarray`, `test_string`, `test_date` — valuable once we bump NAPI_VERSION), CMake-based, and + contributing a JsRuntimeHost implementor could upstream our Android in-process + static-link learnings. + - **Recommendation:** keep the vendored suite for v5 (works; both platforms green). Revisit node-api-cts when we + bump NAPI_VERSION (needing its broader tests) **and** it approaches 1.0 — migrating there rather than doing a + hermes-windows resync at that point. That is the eventual answer to the "gross copying" this PR flags. --- From 1f25d24688cb4a88f7454663b731dc087c481bb1 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:58:39 -0700 Subject: [PATCH 026/174] Android: dlopen conformance addons as dynamic .node backed by a shared libnapi.so Replaces the interim static-link-into-host approach with the dynamic .node model used by nodejs/node-api-cts (add_node_api_cts_addon), so the Android suite and a future node-api-cts migration share one addon model. - Core/Node-API: build napi as a SHARED library (libnapi.so) on Android. It exports all 106 napi_* (default visibility -- no global -fvisibility=hidden), and the host plus every addon depend on the one libnapi.so via a real DT_NEEDED, so there is a single napi instance. Static elsewhere. - The conformance addons are again standalone SHARED lib.so (packaged into nativeLibraryDir), now linking napi (DT_NEEDED libnapi.so) instead of -Wl,--unresolved-symbols=ignore-all. - node_lite_android resolves entry points via dlopen(soname)+dlsym again; the addon's napi_* bind from libnapi.so at load. Reverts the static-link infra (entry_point.h JSR_NODE_API_STATIC_LINK branch, node_api.h overridable registrar macros, the host's per-addon OBJECT libraries). Verified on device: lib2_function_arguments.so has DT_NEEDED [libnapi.so], its napi_* are imports, libnapi.so exports the 106 napi_*, and all 4 v5 js-native-api tests pass in-process. macOS unchanged (12/12; desktop keeps static napi + dlopen'd MODULE .node). --- Core/Node-API/CMakeLists.txt | 12 ++- Tests/NodeApi/CMakeLists.txt | 81 +++++++++++-------- Tests/NodeApi/include/node_api.h | 8 -- Tests/NodeApi/node_lite.cpp | 8 +- Tests/NodeApi/node_lite_android.cpp | 64 +++------------ .../NodeApi/test/js-native-api/entry_point.h | 50 +++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 32 +------- 7 files changed, 90 insertions(+), 165 deletions(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index 96ad4216..bb4828a9 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -264,7 +264,17 @@ Make sure Hermes was fetched at the top-level CMakeLists.txt and NAPI_JAVASCRIPT message(STATUS "Selected ${NAPI_JAVASCRIPT_ENGINE}") endif() -add_library(napi ${SOURCES}) +# On Android the Node-API conformance addons are dlopen'd as standalone SHARED .node modules (matching +# nodejs/node-api-cts's add_node_api_cts_addon model). For an addon's napi_* imports to bind at load, +# napi must be a shared library that both the host and the addons depend on via a real DT_NEEDED +# (libnapi.so) -- bionic will not surface a statically-linked host's napi to a dlopen'd module. There +# is a single napi instance (one libnapi.so) shared by the host and every addon. Elsewhere (the +# child-process desktop runner) napi stays a static library. +if(ANDROID) + add_library(napi SHARED ${SOURCES}) +else() + add_library(napi ${SOURCES}) +endif() target_include_directories(napi ${INCLUDE_DIRECTORIES}) target_link_libraries(napi ${LINK_LIBRARIES}) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 779638c2..1b0330ef 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -120,13 +120,6 @@ if(JSR_NODE_API_BUILD_NATIVE_TESTS) endif() function(add_node_api_module MODULE_TARGET) - if(ANDROID) - # On Android the conformance addons are statically linked into the in-process test host - # (Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt) -- there is no standalone .node to - # build or dlopen, so this desktop helper builds nothing here. - return() - endif() - cmake_parse_arguments(PARSE_ARGV 0 ARG "" "" "SOURCES;DEFINES") get_filename_component(FOLDER_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) @@ -135,8 +128,14 @@ function(add_node_api_module MODULE_TARGET) set(MODULE_TARGET "${FOLDER_NAME}_${MODULE_TARGET}") endif() - # The addon is a MODULE (dlopen-only) .node, loaded by the node_lite child-process runner. - add_library(${MODULE_TARGET} MODULE) + # On Android the addon is a SHARED lib.so so AGP packages it into the APK's lib// (the + # app's nativeLibraryDir, the only place a native library may be dlopen'd from on API 29+). + # Elsewhere it is a MODULE (dlopen-only) .node loaded by the node_lite child-process runner. + if(ANDROID) + add_library(${MODULE_TARGET} SHARED) + else() + add_library(${MODULE_TARGET} MODULE) + endif() target_sources(${MODULE_TARGET} PRIVATE ${ARG_SOURCES}) target_include_directories(${MODULE_TARGET} PRIVATE @@ -161,36 +160,50 @@ function(add_node_api_module MODULE_TARGET) PRIVATE "-undefined" "dynamic_lookup" ) + elseif(ANDROID) + # Link the shared napi (libnapi.so) so the addon's napi_* imports resolve at dlopen via a real + # DT_NEEDED -- the same libnapi.so the host depends on, so there is a single napi instance. + target_link_libraries(${MODULE_TARGET} PRIVATE napi) endif() - set(MODULE_OUTPUT_DIR - ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) - set_target_properties(${MODULE_TARGET} - PROPERTIES - PREFIX "" - SUFFIX ".node" - ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} - ) + if(ANDROID) + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "lib" + SUFFIX ".so" + ) + else() + set(MODULE_OUTPUT_DIR + ${CMAKE_CURRENT_BINARY_DIR}/build/$,Debug,Release>) + set_target_properties(${MODULE_TARGET} + PROPERTIES + PREFIX "" + SUFFIX ".node" + ARCHIVE_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + LIBRARY_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + RUNTIME_OUTPUT_DIRECTORY ${MODULE_OUTPUT_DIR} + ) + endif() add_dependencies(NodeApiModules ${MODULE_TARGET}) - # Stage the built .node next to the node_lite / NodeApiTests runners so they can dlopen it - # relative to the copied test files. - add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E make_directory - $/test/js-native-api/${FOLDER_NAME}/build - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_BINARY_DIR}/build - $/test/js-native-api/${FOLDER_NAME}/build - COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" - ) + if(NOT ANDROID) + # Stage the built .node next to the node_lite / NodeApiTests runners so they can dlopen it + # relative to the copied test files. + add_custom_command(TARGET ${MODULE_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E make_directory + $/test/js-native-api/${FOLDER_NAME}/build + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_BINARY_DIR}/build + $/test/js-native-api/${FOLDER_NAME}/build + COMMENT "Copying Node-API module ${MODULE_TARGET} outputs" + ) + endif() if(APPLE) # The copy_directory above runs as an Xcode "Run Script" phase, which executes BEFORE diff --git a/Tests/NodeApi/include/node_api.h b/Tests/NodeApi/include/node_api.h index 60e3fa0d..0ba4bc6e 100644 --- a/Tests/NodeApi/include/node_api.h +++ b/Tests/NodeApi/include/node_api.h @@ -35,16 +35,8 @@ typedef struct napi_module_s { void* reserved[4]; } napi_module; -// These may be overridden by the build (e.g. -DNODE_API_MODULE_REGISTER_FUNCTION=...) so that several -// addons can be *statically* linked into a single host binary -- each with a uniquely suffixed entry -// point -- without symbol clashes. The defaults are the canonical names a dynamic loader (dlsym) -// looks up in a standalone .node. -#ifndef NODE_API_MODULE_GET_API_VERSION_FUNCTION #define NODE_API_MODULE_GET_API_VERSION_FUNCTION node_api_module_get_api_version_v1 -#endif -#ifndef NODE_API_MODULE_REGISTER_FUNCTION #define NODE_API_MODULE_REGISTER_FUNCTION napi_register_module_v1 -#endif #define NAPI_MODULE_INIT() \ NODE_API_EXTERN_C_START \ diff --git a/Tests/NodeApi/node_lite.cpp b/Tests/NodeApi/node_lite.cpp index 958b66bf..16c45c41 100644 --- a/Tests/NodeApi/node_lite.cpp +++ b/Tests/NodeApi/node_lite.cpp @@ -406,10 +406,10 @@ fs::path NodeLiteRuntime::ResolveModulePath( return node_module_path; } #if defined(__ANDROID__) - // On Android the conformance addons are statically linked into the host rather than present as - // .node files on disk, so the existence check above fails. Resolve to the .node path anyway so - // LoadNativeModule runs; node_lite_android resolves the entry points from the in-process static - // registry, keyed by this path's stem (the module name). + // On Android the addon ships as lib.so in the app's nativeLibraryDir rather than as a .node + // file on disk, so the existence check above fails. Resolve to the .node path anyway so + // LoadNativeModule runs; node_lite_android dlopens it by soname (lib.so), resolving its + // napi_* imports from the shared libnapi.so. return node_module_path; #endif // See if the module was prefixed with the parent folder to disambiguate C++ diff --git a/Tests/NodeApi/node_lite_android.cpp b/Tests/NodeApi/node_lite_android.cpp index 3779ed06..0f34ac14 100644 --- a/Tests/NodeApi/node_lite_android.cpp +++ b/Tests/NodeApi/node_lite_android.cpp @@ -1,67 +1,27 @@ #include "node_lite.h" -#include -#include -#include +#include namespace node_api_tests { -namespace { -// Registry of the Node-API conformance addons that are statically linked into this host binary. It is -// populated at load time by the per-addon constructors emitted in entry_point.h under -// JSR_NODE_API_STATIC_LINK, each registering its uniquely-suffixed entry points keyed by module name. -// A function-local static (constructed on first registration) avoids any static-initialization-order -// dependency between those constructors and this translation unit. -struct StaticAddon { - std::string name; - int32_t (*get_api_version)(void); - napi_value (*register_module)(napi_env, napi_value); -}; - -std::vector& StaticAddonRegistry() { - static std::vector registry; - return registry; -} - -} // namespace -} // namespace node_api_tests - -// Called once per statically-linked addon from its load-time constructor (see entry_point.h). Declared -// extern "C" to match the declaration the C addon translation units compile against. -extern "C" void jsr_register_static_addon( - const char* name, - int32_t (*get_api_version)(void), - napi_value (*register_module)(napi_env, napi_value)) { - node_api_tests::StaticAddonRegistry().push_back( - {name, get_api_version, register_module}); -} - -namespace node_api_tests { - -// On Android the conformance addons are statically linked into the host rather than dlopen'd: dynamic -// .node loading is never shipped to the Play / Quest stores, and bionic won't resolve a dlopen'd -// addon's napi_* against the System.loadLibrary-loaded host anyway (see NAPI_VERSION_ROADMAP.md, and -// task #9 for the shared-lib alternative). So resolve the requested entry point from the in-process -// static registry, keyed by the module's file-stem name, instead of dlopen+dlsym. /*static*/ void* NodeLitePlatform::LoadFunction( napi_env /*env*/, const std::filesystem::path& lib_path, const std::string& function_name) noexcept { - const std::string module_name = lib_path.stem().string(); - for (const StaticAddon& addon : StaticAddonRegistry()) { - if (addon.name != module_name) { - continue; - } - if (function_name == "napi_register_module_v1") { - return reinterpret_cast(addon.register_module); - } - if (function_name == "node_api_module_get_api_version_v1") { - return reinterpret_cast(addon.get_api_version); - } + // On Android the conformance addons are packaged as lib.so in the app's nativeLibraryDir -- + // the only location a native library may be dlopen'd from on API 29+. The resolved lib_path points + // at a (non-existent) .node under the copied test tree, so load by soname and let the dynamic + // linker resolve it from nativeLibraryDir. The addon's napi_* imports resolve from libnapi.so -- a + // DT_NEEDED of both the addon and the host -- so RTLD_NOW binds them at load time. + std::string soname = "lib" + lib_path.stem().string() + ".so"; + void* handle = dlopen(soname.c_str(), RTLD_NOW | RTLD_LOCAL); + if (handle == nullptr) + { return nullptr; } - return nullptr; + + return dlsym(handle, function_name.c_str()); } } // namespace node_api_tests diff --git a/Tests/NodeApi/test/js-native-api/entry_point.h b/Tests/NodeApi/test/js-native-api/entry_point.h index 280501a0..5ba5aaff 100644 --- a/Tests/NodeApi/test/js-native-api/entry_point.h +++ b/Tests/NodeApi/test/js-native-api/entry_point.h @@ -1,38 +1,12 @@ -#ifndef JS_NATIVE_API_ENTRY_POINT_H_ -#define JS_NATIVE_API_ENTRY_POINT_H_ - -#include - -#if defined(JSR_NODE_API_STATIC_LINK) -// Static-link mode (the Android in-process conformance runner): every addon is linked into one host -// binary, so Init must have internal linkage to avoid one-definition clashes across addons. The -// registrar/version functions are uniquely suffixed per-module by the build (NODE_API_MODULE_*_FUNCTION -// in node_api.h). A later non-static definition of Init in the addon inherits this internal linkage. -static napi_value Init(napi_env env, napi_value exports); -#else -EXTERN_C_START -napi_value Init(napi_env env, napi_value exports); -EXTERN_C_END -#endif - -NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) - -#if defined(JSR_NODE_API_STATIC_LINK) -// Self-register this addon's uniquely-named entry points with the host at load time, keyed by module -// name, so the in-process loader (node_lite_android LoadFunction) can find them by name -- the static -// equivalent of dlopen+dlsym. jsr_register_static_addon is implemented by the host. -EXTERN_C_START -void jsr_register_static_addon( - const char* name, - int32_t (*get_api_version)(void), - napi_value (*register_module)(napi_env, napi_value)); -EXTERN_C_END - -static void __attribute__((constructor)) jsr_register_static_addon_ctor(void) { - jsr_register_static_addon(NODE_GYP_MODULE_NAME, - NODE_API_MODULE_GET_API_VERSION_FUNCTION, - NODE_API_MODULE_REGISTER_FUNCTION); -} -#endif - -#endif // JS_NATIVE_API_ENTRY_POINT_H_ +#ifndef JS_NATIVE_API_ENTRY_POINT_H_ +#define JS_NATIVE_API_ENTRY_POINT_H_ + +#include + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports); +EXTERN_C_END + +NAPI_MODULE(NODE_GYP_MODULE_NAME, Init) + +#endif // JS_NATIVE_API_ENTRY_POINT_H_ diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index c9fbb934..fe196ba6 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -85,33 +85,9 @@ target_link_libraries(UnitTestsJNI if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() -set(JSR_NODE_API_NATIVE_TESTS 2_function_arguments 3_callbacks 4_object_factory 5_function_factory) -string(JOIN "," JSR_NODE_API_NATIVE_TESTS_CSV ${JSR_NODE_API_NATIVE_TESTS}) target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${JSR_NODE_API_NATIVE_TESTS_CSV}") + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory") -# --- Statically linked Node-API conformance addons (Android in-process runner) ------------------ -# Dynamic .node loading is never shipped to the Play / Quest stores, and bionic will not resolve a -# dlopen'd addon's napi_* imports against the System.loadLibrary-loaded host anyway (see -# NAPI_VERSION_ROADMAP.md; task #9 tracks the shared-lib alternative). So compile each addon into the -# host with a uniquely suffixed entry point -- avoiding one-definition clashes between addons -- and -# let node_lite resolve them from the in-process static registry (node_lite_android) instead of dlsym. -# entry_point.h emits, per addon, a load-time constructor that self-registers those entry points. -foreach(_mod ${JSR_NODE_API_NATIVE_TESTS}) - add_library(jsr_addon_${_mod} OBJECT - ${TESTS_DIR}/NodeApi/test/js-native-api/${_mod}/${_mod}.c) - target_include_directories(jsr_addon_${_mod} PRIVATE - ${TESTS_DIR}/NodeApi/include - ${TESTS_DIR}/NodeApi/test/js-native-api - ${REPO_ROOT_DIR}/Core/Node-API/Include/Shared - ${REPO_ROOT_DIR}/Core/Node-API/Include/Shared/napi - ${REPO_ROOT_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE} - ${REPO_ROOT_DIR}/Core/Node-API/Include/Engine/${NAPI_JAVASCRIPT_ENGINE}/napi) - target_compile_definitions(jsr_addon_${_mod} PRIVATE - JSR_NODE_API_STATIC_LINK - NODE_API_EXPERIMENTAL_NO_WARNING - NODE_GYP_MODULE_NAME=\"${_mod}\" - NODE_API_MODULE_REGISTER_FUNCTION=jsr_napi_register_${_mod} - NODE_API_MODULE_GET_API_VERSION_FUNCTION=jsr_get_api_version_${_mod}) - target_sources(UnitTestsJNI PRIVATE $) -endforeach() +# The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, +# packaged by AGP into nativeLibraryDir, and dlopen'd in-process by node_lite_android. Both they and +# this host link the shared napi (libnapi.so), so the addons' napi_* imports resolve at load. From 9e181dd00d0d80ad0daba4619e70e99bd708b874 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 18:58:39 -0700 Subject: [PATCH 027/174] docs(roadmap): Android uses dynamic .node + shared libnapi.so (aligns with node-api-cts) --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index 9fa4a74d..b7538ad5 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -11,7 +11,11 @@ This is a multi-PR effort. Keep the boundaries strict: - **Bug fixes** against the current N-API implementation that the tests surface → *quarantine* the failing test via the allow-list and open a separate fix PR. Do not fix impl bugs in the test-suite PR. - **Any `NAPI_VERSION` bump** (6 → 7 → 8 → …) and the per-engine native work it requires. - **jsc-android engine bump** (v6 enabler — see below). - - **Android in-process addon loading** — building `napi` as a shared library so `dlopen`'d test addons can resolve `napi_*` from the host (see *Platform status* below). Affects every Android consumer's packaging → separate PR. + +> **Android packaging note:** to run the suite in-process the addons are `dlopen`'d as standalone +> `.node` modules, which requires `napi` to ship as a shared library (`libnapi.so`) on Android (see +> *Platform status*). That is a deliberate packaging change for all Android consumers; if upstream +> prefers it isolated, it can land as a small precursor commit/PR that this suite depends on. ## Current state (2026-06-04) @@ -35,11 +39,13 @@ This is a multi-PR effort. Keep the boundaries strict: | Platform | Engine | v5 suite | Runner | Notes | |---|---|---|---|---| | **macOS** | JavaScriptCore | ✅ **12/12** (plain + ASan/UBSan + TSan) | child-process | Full v5 reference. | -| **Android** | V8 (`libv8android.so`) | ✅ **4/4 js-native-api** (statically linked, in-process) | in-process | App sandbox can't `fork`/`exec`; addons static-linked — see below. | +| **Android** | V8 (`libv8android.so`) | ✅ **4/4 js-native-api** (dynamic `.node` + `libnapi.so`, in-process) | in-process | App sandbox can't `fork`/`exec`; addons `dlopen`'d — see below. | + +**Android in-process addon loading (dynamic `.node` + shared `libnapi.so`).** The app sandbox can't `fork`/`exec`, so the conformance suite runs the addons *in-process*. The addons are built as standalone SHARED `lib.so` modules (matching nodejs/node-api-cts's `add_node_api_cts_addon`), packaged by AGP into `nativeLibraryDir`, and `dlopen`'d by `node_lite_android` by soname. For their `napi_*` imports to bind at load, **`napi` is built as a shared library (`libnapi.so`) on Android** — a real `DT_NEEDED` of both the host and every addon, so there is a single napi instance. This is the IoC / dynamic-self-registration model: `dlopen` the addon → its `DT_NEEDED libnapi.so` resolves the `napi_*` → `dlsym("napi_register_module_v1")` → call it. Verified on device: `lib2_function_arguments.so` carries `DT_NEEDED [libnapi.so]`, its 8 `napi_*` are imports (`U`), `libnapi.so` exports all 106 `napi_*` (`T`), and the 4 v5 tests pass. The harness also needs the `noexcept`-removal fix (`38864e4`) so a failing test surfaces as a `ProcessResult` rather than `std::terminate`, and native stdout/stderr is pumped to logcat (tag `NodeApiTests`) for visible gtest output. -**Android in-process addon loading (statically linked).** The app sandbox can't `fork`/`exec`, so the conformance suite runs the addons *in-process*. Dynamic `.node` loading there is a dead end — and is never shipped to the Play/Quest stores anyway: the host (`libUnitTestsJNI.so`) is loaded RTLD_LOCAL by `System.loadLibrary`, and bionic won't surface its (exported) `napi_*` to a `dlopen`'d module; post-hoc `RTLD_GLOBAL` promotion is a no-op on bionic (verified on device: the module `dlopen` returns NULL; the addon carries no `DT_NEEDED` for napi). So the addons are **statically linked into the host** instead: `node_api.h` makes the registrar/version entry-point names overridable, `entry_point.h` (under `JSR_NODE_API_STATIC_LINK`) gives `Init` internal linkage and emits a per-addon load-time constructor that self-registers its uniquely-suffixed entry points, the Android CMake compiles each addon as an OBJECT library, and `node_lite_android` resolves them from an in-process registry instead of `dlopen`+`dlsym`. The 4 v5 js-native-api tests now execute in-process and **pass** (commits `f32130e`, `f0d1c2e`; the harness also needed the `noexcept`-removal fix `38864e4` so a failing test surfaces as a `ProcessResult` rather than `std::terminate`). Native stdout/stderr is pumped to logcat (tag `NodeApiTests`) so gtest results are visible (`adb logcat -s NodeApiTests`). Building `napi` as a shared library (task #9) would also work and is the only option if real external `.node` addons ever need `dlopen` on Android, but it ripples to every consumer's packaging and is not needed for the conformance suite. +> Why shared `napi` rather than static-linking the addons into the host: bionic will not surface a `System.loadLibrary`-loaded (RTLD_LOCAL) host's `napi_*` to a `dlopen`'d module, and post-hoc `RTLD_GLOBAL` host promotion is a no-op on bionic — so a `dlopen`'d addon can only resolve `napi` via a real shared-library `DT_NEEDED`. (An earlier iteration statically linked the addons into the host and passed too; the shared-lib model was adopted to align with node-api-cts's dynamic `.node` addons, easing a future migration.) -> Emulator note: the unrelated `JavaScript.All` UnitTest (XMLHttpRequest/WebSocket/HTTP mocha tests) fails in an offline emulator (status 0 vs 200/404, socket timeouts); it runs before and is independent of the js-native-api suite. +> Emulator note: the unrelated `JavaScript.All` UnitTest (XMLHttpRequest/WebSocket/HTTP mocha tests) can fail in an offline emulator (status 0 vs 200/404, socket timeouts); it runs before and is independent of the js-native-api suite. ## Chakra N-API ceiling @@ -97,9 +103,10 @@ run the suite per engine → implement the JSC/(Chakra) gaps → green. `amaro` for TS-strip); the only implementor is `node`. Adopting it means authoring an `implementors/jsruntimehost/` harness (JS modules: `load-addon`, `assert`, `must-call`, `gc`, `napi-version`, `features`, `skip-test`) and driving the test `.js` from our runtime — i.e. re-expressing what `node_lite` already does, in their contract. - - **Doesn't solve Android:** `add_node_api_cts_addon()` builds SHARED `.node` (dlopen), with only Apple - `-undefined dynamic_lookup` / MSVC import-lib handling and no Android path — we'd re-apply the same static-link - adaptation just landed here. + - **Android now aligns:** `add_node_api_cts_addon()` builds SHARED `.node` (dlopen) — the same model our Android + suite now uses (dynamic `.node` + `libnapi.so`). Its CMake only handles Apple `-undefined dynamic_lookup` / + MSVC import-libs, so an Android port would still need our `libnapi.so` + soname-load glue, but the addon model + itself matches — a future migration is much smoother now. - **No v5 coverage gain now:** its `tests/js-native-api/` are ported from the same `nodejs/node` source as our vendored copies; the 4 v5 tests are identical content. - **Upside (why track it):** engine-agnostic, active (~24 js-native-api tests ported incl. `test_bigint`, From fca9ff0ff16ebe2a35dd758614cfdcaea6ea7d34 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 19:29:57 -0700 Subject: [PATCH 028/174] Android tests: use AndroidExtensions StdoutLogger for stdout->logcat Replace the hand-rolled pipe+thread stdout pump (added while bringing up the in-process Node-API harness) with android::StdoutLogger::Start()/Stop() from AndroidExtensions, which the rest of the UnitTests host already uses. Same effect -- the in-process gtest output (incl. failure file:line:message) is visible in logcat (tag StdoutLogger) -- with less bespoke code. Verified on emulator: 8/8 UnitTests pass incl. 4/4 js_native_api, gtest output present in logcat. --- .../Android/app/src/main/cpp/JNI.cpp | 53 ------------------- 1 file changed, 53 deletions(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp index ab997f55..9c46f0cb 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp +++ b/Tests/UnitTests/Android/app/src/main/cpp/JNI.cpp @@ -7,60 +7,8 @@ #include "Babylon/StandardStreamLogger.h" #include -#include -#include -#include -#include - -namespace { - -// The conformance suite runs gtest in-process and writes results (including failure file/line/message) -// to stdout/stderr, which Android otherwise discards. Pump both to logcat so test output -- and any -// native crash context printed before the process dies -- is actually visible (e.g. -// `adb logcat -s NodeApiTests`). Without this the only signal is the JUnit "expected 0, was 1". -void* PumpStdioToLogcat(void* arg) { - int read_fd = *static_cast(arg); - char buffer[1024]; - std::string line; - ssize_t count; - while ((count = read(read_fd, buffer, sizeof(buffer) - 1)) > 0) { - buffer[count] = '\0'; - line += buffer; - std::string::size_type newline; - while ((newline = line.find('\n')) != std::string::npos) { - __android_log_write(ANDROID_LOG_INFO, "NodeApiTests", line.substr(0, newline).c_str()); - line.erase(0, newline + 1); - } - } - return nullptr; -} - -void RedirectStdioToLogcat() { - static int pipe_fds[2]; - static bool installed = false; - if (installed) { - return; - } - installed = true; - setvbuf(stdout, nullptr, _IOLBF, 0); - setvbuf(stderr, nullptr, _IONBF, 0); - if (pipe(pipe_fds) != 0) { - return; - } - dup2(pipe_fds[1], STDOUT_FILENO); - dup2(pipe_fds[1], STDERR_FILENO); - pthread_t thread; - if (pthread_create(&thread, nullptr, PumpStdioToLogcat, &pipe_fds[0]) == 0) { - pthread_detach(thread); - } -} - -} // namespace - extern "C" JNIEXPORT jint JNICALL Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass clazz, jobject context) { - RedirectStdioToLogcat(); - JavaVM* javaVM{}; if (env->GetJavaVM(&javaVM) != JNI_OK) { @@ -76,7 +24,6 @@ Java_com_jsruntimehost_unittests_Native_javaScriptTests(JNIEnv* env, jclass claz jclass webSocketClass{env->FindClass("com/jsruntimehost/unittests/WebSocket")}; java::websocket::WebSocketClient::InitializeJavaWebSocketClass(webSocketClass, env); - android::global::Initialize(javaVM, context); jclass contextClass = env->GetObjectClass(context); jmethodID getApplicationContext = env->GetMethodID(contextClass, "getApplicationContext", "()Landroid/content/Context;"); jobject applicationContext = env->CallObjectMethod(context, getApplicationContext); From 0fff7fc32ac043e65e6177a2433e8aa6e9152e9e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 19:30:37 -0700 Subject: [PATCH 029/174] docs(roadmap): stdout->logcat is via AndroidExtensions StdoutLogger, not a hand-rolled pump --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index b7538ad5..6f73ba0d 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -41,7 +41,7 @@ This is a multi-PR effort. Keep the boundaries strict: | **macOS** | JavaScriptCore | ✅ **12/12** (plain + ASan/UBSan + TSan) | child-process | Full v5 reference. | | **Android** | V8 (`libv8android.so`) | ✅ **4/4 js-native-api** (dynamic `.node` + `libnapi.so`, in-process) | in-process | App sandbox can't `fork`/`exec`; addons `dlopen`'d — see below. | -**Android in-process addon loading (dynamic `.node` + shared `libnapi.so`).** The app sandbox can't `fork`/`exec`, so the conformance suite runs the addons *in-process*. The addons are built as standalone SHARED `lib.so` modules (matching nodejs/node-api-cts's `add_node_api_cts_addon`), packaged by AGP into `nativeLibraryDir`, and `dlopen`'d by `node_lite_android` by soname. For their `napi_*` imports to bind at load, **`napi` is built as a shared library (`libnapi.so`) on Android** — a real `DT_NEEDED` of both the host and every addon, so there is a single napi instance. This is the IoC / dynamic-self-registration model: `dlopen` the addon → its `DT_NEEDED libnapi.so` resolves the `napi_*` → `dlsym("napi_register_module_v1")` → call it. Verified on device: `lib2_function_arguments.so` carries `DT_NEEDED [libnapi.so]`, its 8 `napi_*` are imports (`U`), `libnapi.so` exports all 106 `napi_*` (`T`), and the 4 v5 tests pass. The harness also needs the `noexcept`-removal fix (`38864e4`) so a failing test surfaces as a `ProcessResult` rather than `std::terminate`, and native stdout/stderr is pumped to logcat (tag `NodeApiTests`) for visible gtest output. +**Android in-process addon loading (dynamic `.node` + shared `libnapi.so`).** The app sandbox can't `fork`/`exec`, so the conformance suite runs the addons *in-process*. The addons are built as standalone SHARED `lib.so` modules (matching nodejs/node-api-cts's `add_node_api_cts_addon`), packaged by AGP into `nativeLibraryDir`, and `dlopen`'d by `node_lite_android` by soname. For their `napi_*` imports to bind at load, **`napi` is built as a shared library (`libnapi.so`) on Android** — a real `DT_NEEDED` of both the host and every addon, so there is a single napi instance. This is the IoC / dynamic-self-registration model: `dlopen` the addon → its `DT_NEEDED libnapi.so` resolves the `napi_*` → `dlsym("napi_register_module_v1")` → call it. Verified on device: `lib2_function_arguments.so` carries `DT_NEEDED [libnapi.so]`, its 8 `napi_*` are imports (`U`), `libnapi.so` exports all 106 `napi_*` (`T`), and the 4 v5 tests pass. The harness also needs the `noexcept`-removal fix (`38864e4`) so a failing test surfaces as a `ProcessResult` rather than `std::terminate`, and stdout is routed to logcat via AndroidExtensions' `StdoutLogger` (tag `StdoutLogger`) for visible gtest output. > Why shared `napi` rather than static-linking the addons into the host: bionic will not surface a `System.loadLibrary`-loaded (RTLD_LOCAL) host's `napi_*` to a `dlopen`'d module, and post-hoc `RTLD_GLOBAL` host promotion is a no-op on bionic — so a `dlopen`'d addon can only resolve `napi` via a real shared-library `DT_NEEDED`. (An earlier iteration statically linked the addons into the host and passed too; the shared-lib model was adopted to align with node-api-cts's dynamic `.node` addons, easing a future migration.) From 2801353b82407ffae9a17612cd49855a2744cacb Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 19:36:02 -0700 Subject: [PATCH 030/174] Sync napi shared-lib change with PR #183 (gate behind JSR_NAPI_SHARED option) --- Core/Node-API/CMakeLists.txt | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index bb4828a9..d0a162b5 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -264,13 +264,20 @@ Make sure Hermes was fetched at the top-level CMakeLists.txt and NAPI_JAVASCRIPT message(STATUS "Selected ${NAPI_JAVASCRIPT_ENGINE}") endif() -# On Android the Node-API conformance addons are dlopen'd as standalone SHARED .node modules (matching -# nodejs/node-api-cts's add_node_api_cts_addon model). For an addon's napi_* imports to bind at load, -# napi must be a shared library that both the host and the addons depend on via a real DT_NEEDED -# (libnapi.so) -- bionic will not surface a statically-linked host's napi to a dlopen'd module. There -# is a single napi instance (one libnapi.so) shared by the host and every addon. Elsewhere (the -# child-process desktop runner) napi stays a static library. +# On Android, native addons are dlopen'd as standalone .node modules and resolve their napi_* imports +# from a shared napi at load time -- bionic will not surface a statically-linked host's napi to a +# dlopen'd module, so the host and every addon must share a single libnapi.so. Default napi to a +# shared library on Android so that model works out of the box; an integrator who wants a static napi +# (e.g. for size/packaging) can override with -DJSR_NAPI_SHARED=OFF. The option defaults OFF on other +# platforms, where napi keeps following the project's default library type (i.e. honors +# BUILD_SHARED_LIBS). +set(JSR_NAPI_SHARED_DEFAULT OFF) if(ANDROID) + set(JSR_NAPI_SHARED_DEFAULT ON) +endif() +option(JSR_NAPI_SHARED "Build napi as a shared library (libnapi.so)" ${JSR_NAPI_SHARED_DEFAULT}) + +if(JSR_NAPI_SHARED) add_library(napi SHARED ${SOURCES}) else() add_library(napi ${SOURCES}) From ff1d595b251c263949b49f9dbce9878fc01aad37 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 20:42:56 -0700 Subject: [PATCH 031/174] Tests: enable the v5-clean reference double-free conformance test Adds test_reference_double_free (js-native-api) to the enabled suite -- a real v5 reference/double-free test, green on macOS (system JSC, including ASan) and Android (V8). Its test_wrap.js is quarantined via a known-failing allow-list in test_main.cpp: JSC napi_remove_wrap on an unwrapped object returns napi_invalid_arg (the consecutive remove_wrap+delete_reference path itself does not crash); tracked as a separate JSC fix. The rest of the reference/finalizer/wrap suite (test_reference, test_finalizer, 6_object_wrap) targets newer Node-API -- node_api_symbol_for (v9), napi_get_instance_data (v6), node_api_basic_env / node_api_post_finalizer (v9) -- and is documented for the staged NAPI_VERSION bump. --- Tests/NodeApi/CMakeLists.txt | 8 ++++++++ Tests/NodeApi/test_main.cpp | 15 +++++++++++++++ .../Android/app/src/main/cpp/CMakeLists.txt | 2 +- 3 files changed, 24 insertions(+), 1 deletion(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 1b0330ef..285b0933 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -7,6 +7,14 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS 3_callbacks 4_object_factory 5_function_factory + # v5-clean reference coverage. The rest of the reference/finalizer/wrap suite targets newer + # Node-API and is staged for the NAPI_VERSION bump: + # test_reference -> node_api_symbol_for (v9) + # test_finalizer/ -> napi_get_instance_data (v6), node_api_basic_env / node_api_post_finalizer (v9) + # 6_object_wrap -> napi_get_instance_data (v6), node_api_basic_env (v9) + # (test_reference_double_free/test_wrap.js is quarantined in test_main.cpp -- a JSC remove_wrap + # edge case that returns napi_invalid_arg; tracked as a separate fix, not a v5 blocker.) + test_reference_double_free ) function(node_api_copy_test_sources TARGET_NAME) diff --git a/Tests/NodeApi/test_main.cpp b/Tests/NodeApi/test_main.cpp index 93803cb8..01bab5d1 100644 --- a/Tests/NodeApi/test_main.cpp +++ b/Tests/NodeApi/test_main.cpp @@ -60,6 +60,21 @@ class NodeApiTestFixture : public TestFixtureBase { ASSERT_TRUE(static_cast(config.run_script)) << "Node-API test runner is not configured."; + // Quarantined conformance cases: known-failing against the current v5 surface. Kept registered + // (and skipped, so they stay visible) rather than silently dropped. Each needs a separate fix or + // a NAPI_VERSION bump and must not block the v5 suite. + static constexpr const char* kQuarantined[] = { + // JSC napi_remove_wrap on an object that was never wrapped returns napi_invalid_arg, which the + // runner surfaces as a failure. The consecutive remove_wrap+delete_reference path itself does + // not crash. Tracked separately as a JSC remove_wrap fix. + "test_reference_double_free/test_wrap.js", + }; + for (const char* quarantined : kQuarantined) { + if (m_jsFilePath.generic_string().find(quarantined) != std::string::npos) { + GTEST_SKIP() << "Quarantined (known-failing on the v5 surface): " << quarantined; + } + } + ProcessResult result = config.run_script(m_jsFilePath); if (result.status == 0) { return; diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index fe196ba6..6d7d93df 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -86,7 +86,7 @@ if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory") + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, # packaged by AGP into nativeLibraryDir, and dlopen'd in-process by node_lite_android. Both they and From ca4947106741771ef45faf55f9de5775e879ee6b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 20:45:05 -0700 Subject: [PATCH 032/174] docs(roadmap): reference-test staging + GC-safety review (re hermes-windows#321) --- Tests/NodeApi/NAPI_VERSION_ROADMAP.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md index 6f73ba0d..fa3a1bff 100644 --- a/Tests/NodeApi/NAPI_VERSION_ROADMAP.md +++ b/Tests/NodeApi/NAPI_VERSION_ROADMAP.md @@ -91,6 +91,23 @@ run the suite per engine → implement the JSC/(Chakra) gaps → green. `*` stretch. Separately: the worklets/worker goal needs **threadsafe functions** — a runtime-layer (`node_api.h`, `NAPI_HAS_THREADS 1`) axis not covered by the engine-only suite; track independently. +**Reference/finalizer test staging (measured at v5).** Of the vendored reference/finalizer/wrap dirs, only +`test_reference_double_free` is v5-clean and is enabled now (green on macOS/JSC incl. ASan, and Android/V8); its +`test_wrap.js` is quarantined (JSC `napi_remove_wrap` on an unwrapped object returns `napi_invalid_arg` — it +does not crash; separate fix). The rest are gated by symbols our v5 pin doesn't export and enable with the +bump: `test_reference` → `node_api_symbol_for` (v9, B4); `test_finalizer/` & `6_object_wrap` → +`napi_get_instance_data` (v6, B1) + `node_api_basic_env`/`node_api_post_finalizer` (v9, B4). `test_finalizer` +also surfaced a JSC finalizer-delivery timing case (`mustCall(1)`→0) to confirm at B1. + +**GC-safety (re upstream [hermes-windows#321](https://github.com/microsoft/hermes-windows/pull/321)).** That +weak-ref-over-Proxy moving-GC bug is **not present here**. V8 uses `v8::Persistent` (an immediate, auto-relocated +GC root). JSC keeps the to-be-referenced object in the `value` argument on the C stack across the reference's +finalizer-setup allocation, so JSC's **conservative stack scan pins it against collection and relocation** — the +creation-time window is closed regardless of whether the collector moves cells — and weak liveness is an +object-id check, not a bare-pointer deref. Chakra is non-moving with a nullptr-returning weak read. Empirically, +`test_reference_double_free` runs **clean under ASan on the modern system JSC** (no use-after-free). There is no +weak-ref-over-Proxy case in the suite yet; add one at the v9 tier. + ## Test-suite sourcing strategy - **Now (this PR):** vendored copy of vmoroz's hermes-windows `unittests/NodeApi/` (engine-layer, v8-capable From ee5edfab4e0736f99649240d002cb5260c482558 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Thu, 4 Jun 2026 23:31:56 -0700 Subject: [PATCH 033/174] Node-API: address #116 review (JSC call dispatch, status type, Windows error reporting) - JSC napi_call_function: invoke through the canonical Function.prototype.call (captured once at env init) rather than the target function's own, user-overridable "call" property -- so `func.call = ...` cannot change native call behavior. - child_process_android SpawnSync: return status 1 (was -1, which wrapped in the uint32_t status field) for the unsupported path. - node_lite_windows LoadFunction: format the narrow lib_path.string() with %s (path::c_str() is wchar_t* on Windows -> UB) and report ::GetLastError() instead of errno for LoadLibraryA failures. --- .../Source/js_native_api_javascriptcore.cc | 21 ++++++++++++++----- .../Source/js_native_api_javascriptcore.h | 4 ++++ Tests/NodeApi/child_process_android.cpp | 3 ++- Tests/NodeApi/node_lite_windows.cpp | 9 ++++---- 4 files changed, 27 insertions(+), 10 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 66c8fbe7..def231d7 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -844,6 +844,18 @@ void napi_env__::deinit_symbol(JSValueRef symbol) { JSValueUnprotect(context, symbol); } +void napi_env__::init_function_prototype_call() { + // Capture the canonical Function.prototype.call once, at env init, so napi_call_function does not + // depend on a target function's own (user-overridable) "call" property. + JSObjectRef global = JSContextGetGlobalObject(context); + JSValueRef function_ctor = JSObjectGetProperty(context, global, JSString("Function"), nullptr); + JSObjectRef function_ctor_obj = JSValueToObject(context, function_ctor, nullptr); + JSValueRef prototype = JSObjectGetProperty(context, function_ctor_obj, JSString("prototype"), nullptr); + JSObjectRef prototype_obj = JSValueToObject(context, prototype, nullptr); + function_prototype_call = JSObjectGetProperty(context, prototype_obj, JSString("call"), nullptr); + JSValueProtect(context, function_prototype_call); +} + // Warning: Keep in-sync with napi_status enum static const char* error_messages[] = { nullptr, @@ -1659,11 +1671,10 @@ napi_status napi_call_function(napi_env env, } JSValueRef exception{}; - JSValueRef call_value{JSObjectGetProperty( - env->context, function_object, JSString("call"), &exception)}; - CHECK_JSC(env, exception); - - JSObjectRef call_object = JSValueToObject(env->context, call_value, &exception); + // Invoke through the canonical Function.prototype.call (captured at env init), not the target's own + // "call" property -- user code could override func.call and change native call behavior. + JSObjectRef call_object = + JSValueToObject(env->context, env->function_prototype_call, &exception); CHECK_JSC(env, exception); JSValueRef return_value{JSObjectCallAsFunction(env->context, diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 1a1a533c..298921d0 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -21,6 +21,7 @@ struct napi_env__ { JSValueRef function_info_symbol{}; JSValueRef reference_info_symbol{}; JSValueRef wrapper_info_symbol{}; + JSValueRef function_prototype_call{}; // Escapable scope bookkeeping: token -> whether that scope has escaped. Values // are rooted by the engine rather than by a scope here, so this exists only to @@ -39,11 +40,13 @@ struct napi_env__ { init_symbol(function_info_symbol, "BabylonNative_FunctionInfo"); init_symbol(reference_info_symbol, "BabylonNative_ReferenceInfo"); init_symbol(wrapper_info_symbol, "BabylonNative_WrapperInfo"); + init_function_prototype_call(); } ~napi_env__() { shutting_down = true; deinit_refs(); + deinit_symbol(function_prototype_call); deinit_symbol(wrapper_info_symbol); deinit_symbol(reference_info_symbol); deinit_symbol(function_info_symbol); @@ -66,6 +69,7 @@ struct napi_env__ { void deinit_refs(); void init_symbol(JSValueRef& symbol, const char* description); + void init_function_prototype_call(); void deinit_symbol(JSValueRef symbol); }; diff --git a/Tests/NodeApi/child_process_android.cpp b/Tests/NodeApi/child_process_android.cpp index cb70ccd1..cca60c3c 100644 --- a/Tests/NodeApi/child_process_android.cpp +++ b/Tests/NodeApi/child_process_android.cpp @@ -5,7 +5,8 @@ namespace node_api_tests { ProcessResult SpawnSync(std::string_view /*command*/, std::vector /*args*/) { ProcessResult result{}; - result.status = -1; + // Non-zero failure (status is uint32_t); spawnSync is unsupported in the in-process Android runner. + result.status = 1; result.std_error = "child_process.spawnSync is not supported on this platform."; result.std_output.clear(); return result; diff --git a/Tests/NodeApi/node_lite_windows.cpp b/Tests/NodeApi/node_lite_windows.cpp index 4af34561..164487df 100644 --- a/Tests/NodeApi/node_lite_windows.cpp +++ b/Tests/NodeApi/node_lite_windows.cpp @@ -2,7 +2,7 @@ // Licensed under the MIT License. #include -#include "node_lite.h" +#include "node_lite.h" namespace node_api_tests { @@ -15,10 +15,11 @@ namespace node_api_tests { const std::filesystem::path& lib_path, const std::string& function_name) noexcept { HMODULE dll_module = ::LoadLibraryA(lib_path.string().c_str()); + const DWORD load_error = ::GetLastError(); NODE_LITE_ASSERT(dll_module != NULL, - "Failed to load DLL: %s. Error: %s", - lib_path.c_str(), - std::strerror(errno)); + "Failed to load DLL: %s. Error code: %lu", + lib_path.string().c_str(), + load_error); return ::GetProcAddress(dll_module, function_name.c_str()); } } // namespace node_api_tests From 2dd80227899b33832606c066e9bd8c3e44a87bb1 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 19:33:35 -0700 Subject: [PATCH 034/174] Keep JSI's napi.h self-contained (restores upstream's inlined type copy) An earlier commit in this branch deduplicated JSI's inlined napi type definitions by including the shared . Upstream deliberately keeps Core/Node-API-JSI/Include/napi/napi.h self-contained (it carries its own copy), and Core/Node-API-JSI is built *instead of* Core/Node-API when the engine is JSI -- so the shared header is not on that target's include path and the JSI build fails with C1083. Restore upstream's arrangement. --- Core/Node-API-JSI/Include/napi/napi.h | 37 ++++++++++++++++++++++++++- Tests/package-lock.json | 6 ----- 2 files changed, 36 insertions(+), 7 deletions(-) diff --git a/Core/Node-API-JSI/Include/napi/napi.h b/Core/Node-API-JSI/Include/napi/napi.h index cec68d71..76342bc6 100644 --- a/Core/Node-API-JSI/Include/napi/napi.h +++ b/Core/Node-API-JSI/Include/napi/napi.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include #include @@ -9,6 +8,42 @@ #include #include +// Copied from js_native_api_types.h (https://git.io/J8aI5) +typedef enum { + napi_default = 0, + napi_writable = 1 << 0, + napi_enumerable = 1 << 1, + napi_configurable = 1 << 2, +} napi_property_attributes; + +typedef enum { + // ES6 types (corresponds to typeof) + napi_undefined, + napi_null, + napi_boolean, + napi_number, + napi_string, + napi_symbol, + napi_object, + napi_function, + napi_external, +} napi_valuetype; + +typedef enum { + napi_int8_array, + napi_uint8_array, + napi_uint8_clamped_array, + napi_int16_array, + napi_uint16_array, + napi_int32_array, + napi_uint32_array, + napi_float32_array, + napi_float64_array, + // JSI doesn't support bigint. + // napi_bigint64_array, + // napi_biguint64_array, +} napi_typedarray_type; + struct napi_env__ { napi_env__(facebook::jsi::Runtime& rt) : rt{rt} diff --git a/Tests/package-lock.json b/Tests/package-lock.json index 50d2b9cc..eccda69f 100644 --- a/Tests/package-lock.json +++ b/Tests/package-lock.json @@ -97,7 +97,6 @@ "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "@babel/code-frame": "^7.29.0", "@babel/generator": "^7.29.0", @@ -2396,7 +2395,6 @@ "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", "dev": true, "license": "MIT", - "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -2423,7 +2421,6 @@ "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", @@ -2712,7 +2709,6 @@ } ], "license": "MIT", - "peer": true, "dependencies": { "baseline-browser-mapping": "^2.10.12", "caniuse-lite": "^1.0.30001782", @@ -5211,7 +5207,6 @@ "integrity": "sha512-EW8af29ak8Oaf4T8k8YsajjrDBDYgnKZ5er6ljWFJsXABfTNowQfvHLftwcepVgdz+IoLSdEAbBiM9DFXoll9w==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.8", @@ -5261,7 +5256,6 @@ "integrity": "sha512-MfwFQ6SfwinsUVi0rNJm7rHZ31GyTcpVE5pgVA3hwFRb7COD4TzjUUwhGWKfO50+xdc2MQPuEBBJoqIMGt3JDw==", "dev": true, "license": "MIT", - "peer": true, "dependencies": { "@discoveryjs/json-ext": "^0.6.1", "@webpack-cli/configtest": "^3.0.1", From ebf10005c1d0bfe118dbf405e94fd78815e78a20 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:27:18 -0700 Subject: [PATCH 035/174] Tests/NodeApi: add missing in child_process.h (fixes Linux build) --- Tests/NodeApi/child_process.h | 1 + 1 file changed, 1 insertion(+) diff --git a/Tests/NodeApi/child_process.h b/Tests/NodeApi/child_process.h index aed58908..e89d70d3 100644 --- a/Tests/NodeApi/child_process.h +++ b/Tests/NodeApi/child_process.h @@ -4,6 +4,7 @@ #ifndef NODE_API_TEST_CHILD_PROCESS_H #define NODE_API_TEST_CHILD_PROCESS_H +#include #include #include #include From 16d1442e60602ba1c0491be838b632d92b271d63 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:27:18 -0700 Subject: [PATCH 036/174] Tests/node_lite: select the napi engine by compile-define, not platform The harness picked the engine from the platform (__APPLE__ == JSC, __ANDROID__ == V8), which breaks any non-default pairing: Android-JSC compiled the V8 path (#include -> not found) and Linux-V8 hit no engine branch at all. Expose JSR_NAPI_ENGINE_ as a PUBLIC compile definition on the napi target and branch on that instead. Fixes the Android_JSC + Ubuntu(V8) regressions; the #else is now a compiling throw stub so Chakra/JSI builds still compile (they don't run node_lite in CI). --- Core/Node-API/CMakeLists.txt | 6 ++++++ Tests/NodeApi/js_runtime_api.cpp | 14 +++++++------- Tests/NodeApi/node_lite_jsruntimehost.cpp | 16 ++++++++-------- 3 files changed, 21 insertions(+), 15 deletions(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index d0a162b5..eb72801a 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -297,5 +297,11 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Hermes") NAPI_HERMES_MAX_HEAP_SIZE_MB=${NAPI_HERMES_MAX_HEAP_SIZE_MB}) endif() +# Expose the selected engine as a compile definition so engine-agnostic consumers (the node_lite test +# harness) can branch on engine capability instead of guessing from the platform +# (__APPLE__ == JSC / __ANDROID__ == V8 breaks Android-JSC, Linux-V8, Windows-Chakra, ...). +string(TOUPPER "${NAPI_JAVASCRIPT_ENGINE}" NAPI_ENGINE_UPPER) +target_compile_definitions(napi PUBLIC JSR_NAPI_ENGINE_${NAPI_ENGINE_UPPER}) + set_property(TARGET napi PROPERTY FOLDER Dependencies) source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Tests/NodeApi/js_runtime_api.cpp b/Tests/NodeApi/js_runtime_api.cpp index 936392a9..1df2d3a0 100644 --- a/Tests/NodeApi/js_runtime_api.cpp +++ b/Tests/NodeApi/js_runtime_api.cpp @@ -3,17 +3,17 @@ #include #include -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) #include #include "js_native_api_javascriptcore.h" -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) #include #include "js_native_api_v8.h" #endif struct jsr_napi_env_scope_s { napi_env env{nullptr}; -#if defined(__ANDROID__) +#if defined(JSR_NAPI_ENGINE_V8) v8::Global context; #endif }; @@ -26,7 +26,7 @@ napi_status jsr_open_napi_env_scope(napi_env env, auto* scope_impl = new jsr_napi_env_scope_s{}; scope_impl->env = env; -#if defined(__ANDROID__) +#if defined(JSR_NAPI_ENGINE_V8) // node_lite calls Node-API outside any napi callback, so V8 has no *current context*. The env // holder already holds a Locker + Isolate::Scope; enter the env's context here (exited in // jsr_close_napi_env_scope) so calls such as napi_create_object -> v8::Object::New(isolate), @@ -50,7 +50,7 @@ napi_status jsr_close_napi_env_scope(napi_env /*env*/, return napi_invalid_arg; } -#if defined(__ANDROID__) +#if defined(JSR_NAPI_ENGINE_V8) if (scope->env != nullptr) { v8::Isolate* isolate = scope->env->isolate; v8::HandleScope handle_scope(isolate); @@ -71,7 +71,7 @@ napi_status jsr_run_script(napi_env env, } napi_status jsr_collect_garbage(napi_env env) { -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) if (env == nullptr) { return napi_invalid_arg; } @@ -83,7 +83,7 @@ napi_status jsr_collect_garbage(napi_env env) { JSGarbageCollect(context); return napi_ok; -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) if (env == nullptr) { return napi_invalid_arg; } diff --git a/Tests/NodeApi/node_lite_jsruntimehost.cpp b/Tests/NodeApi/node_lite_jsruntimehost.cpp index a79fe91b..0dd565be 100644 --- a/Tests/NodeApi/node_lite_jsruntimehost.cpp +++ b/Tests/NodeApi/node_lite_jsruntimehost.cpp @@ -7,10 +7,10 @@ #include #include -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) #include #include "js_native_api_javascriptcore.h" -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) #include #include "js_native_api_v8.h" #endif @@ -25,10 +25,10 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { std::shared_ptr /*taskRunner*/, std::function onUnhandledError) : onUnhandledError_(std::move(onUnhandledError)) { -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) context_ = JSGlobalContextCreateInGroup(nullptr, nullptr); env_ = Napi::Attach(context_); -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) // V8's platform is process-global and is already initialized by JsRuntimeHost -- the host // AppRuntime that UnitTestsJNI links and that runs (via the regular V8 unit tests) before these // in-process Node-API tests. Initializing it a second time aborts V8 with "Wrong initialization @@ -59,7 +59,7 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { } ~JsRuntimeHostEnvHolder() override { -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) if (env_ != nullptr) { Napi::Env napiEnv{env_}; @@ -85,7 +85,7 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { JSGlobalContextRelease(context_); context_ = nullptr; } -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) if (env_ != nullptr && isolate_ != nullptr) { // Still locked + isolate-scoped on this thread via locker_/isolate_scope_ (held members). v8::HandleScope handle_scope(isolate_); @@ -131,9 +131,9 @@ class JsRuntimeHostEnvHolder : public IEnvHolder { napi_env getEnv() override { return env_; } private: -#if defined(__APPLE__) +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) JSGlobalContextRef context_{}; -#elif defined(__ANDROID__) +#elif defined(JSR_NAPI_ENGINE_V8) v8::Isolate* isolate_{nullptr}; std::unique_ptr locker_{}; std::unique_ptr isolate_scope_{}; From 39f826e8e57eaaf21dc191891ff4f56435392f5b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:37:11 -0700 Subject: [PATCH 037/174] Tests/NodeApi: link napi into addons on Windows/UWP so napi_* resolve at link The .node addons referenced napi_* but never linked the napi library, so every Win32/UWP build failed with unresolved external symbols (napi_create_function, napi_get_last_error_info, ...). MSVC binds DLL imports at link time, so link napi directly (mirrors the Android branch). Fixes the pre-existing Windows/UWP addon link failures. --- Tests/NodeApi/CMakeLists.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 285b0933..cc01bbe9 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -172,6 +172,12 @@ function(add_node_api_module MODULE_TARGET) # Link the shared napi (libnapi.so) so the addon's napi_* imports resolve at dlopen via a real # DT_NEEDED -- the same libnapi.so the host depends on, so there is a single napi instance. target_link_libraries(${MODULE_TARGET} PRIVATE napi) + elseif(WIN32) + # MSVC binds a DLL's imports at link time (there's no node.exe-style host export / delay-load + # wired up here), so the .node addon must resolve its napi_* against the napi library directly. + # napi is static on Windows, so the references bind into the addon; node_lite isn't executed by + # the Windows/UWP CI (build-only), so a single shared napi instance isn't required there. + target_link_libraries(${MODULE_TARGET} PRIVATE napi) endif() if(ANDROID) From de6ae6c2cf60a2166465a820730db18fcae11cca Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 19:52:59 -0700 Subject: [PATCH 038/174] Tests: don't build the C-API conformance harness for the JSI backend node_lite and the js-native-api addons are written against the C napi_* API. Core/Node-API-JSI implements only the C++ Napi:: wrapper over jsi (no C napi_* symbols), and its napi.h carries its own copy of the napi types, which collides with the shared the harness includes (C2365 redefinition in node_lite). Skip the harness for JSI. --- Tests/CMakeLists.txt | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index a7efe8f4..53b553f8 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -1,3 +1,12 @@ add_subdirectory(UnitTests) -add_subdirectory(NodeApi) + +# The Node-API conformance harness (node_lite + the js-native-api addons) is written against the C +# napi_* API. The JSI backend (Core/Node-API-JSI) implements only the C++ `Napi::` wrapper over jsi and +# exports no C napi_* symbols, and its napi.h carries its own copy of the napi types -- which collides +# with the shared the harness includes (C2365 redefinition). Skip the +# harness for JSI rather than trying to reconcile the two type sources. +if(NOT NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI") + add_subdirectory(NodeApi) +endif() + npm(install --silent) From 8bfbc40134db1254274e49b3620bc8f5d3d305d2 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 20:11:28 -0700 Subject: [PATCH 039/174] Don't hard-fail the Linux JSC library probe (breaks the Hermes host bootstrap) This branch had replaced upstream's plain cached JAVASCRIPTCORE_LIBRARY path with find_library + FATAL_ERROR. Upstream's Hermes support configures a *host* build of this same source tree to bootstrap hermesc/shermes (-D NAPI_JAVASCRIPT_ENGINE=Hermes), and that configure runs the elseif(UNIX) branch on CI runners that have no libwebkit2gtk installed -- so the fatal error aborts the bootstrap and Android_Hermes fails. Restore upstream's non-fatal form; the engine isn't even JavaScriptCore there. --- Core/Node-API/CMakeLists.txt | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index eb72801a..aba53df1 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -7,10 +7,7 @@ elseif(ANDROID) set(NAPI_JAVASCRIPT_ENGINE "V8" CACHE STRING "JavaScript engine for Node-API") elseif(UNIX) set(NAPI_JAVASCRIPT_ENGINE "JavaScriptCore" CACHE STRING "JavaScript engine for Node-API") - find_library(JAVASCRIPTCORE_LIBRARY javascriptcoregtk-4.1) - if(NOT JAVASCRIPTCORE_LIBRARY) - message(FATAL_ERROR "JavaScriptCore library not found. Please install libwebkit2gtk-4.1-dev") - endif() + set(JAVASCRIPTCORE_LIBRARY "/usr/lib/x86_64-linux-gnu/libjavascriptcoregtk-4.1.so" CACHE STRING "Path to the JavaScriptCore shared library") else() message(FATAL_ERROR "Unable to select Node-API JavaScript engine for platform") endif() From 765643f14b846b634500def2d60d3ed63bbcc6cc Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 20:30:33 -0700 Subject: [PATCH 040/174] Tests/Android: build the on-device Node-API harness only for validated engines The harness sources were compiled into UnitTestsJNI for every Android engine. Hermes supplies napi via its own hermesNapi library, which does not export napi_create_external / napi_get_value_external, so Android_Hermes failed to link; QuickJS has not been validated on-device. Gate the harness sources (and the NODE_API_AVAILABLE_NATIVE_TESTS list that drives them) behind an engine allow-list of V8 and JavaScriptCore, matching the desktop gating in Tests/NodeApi/CMakeLists.txt. --- .../Android/app/src/main/cpp/CMakeLists.txt | 30 +++++++++++++------ 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 6d7d93df..9053d8c5 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -30,6 +30,22 @@ else() set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) endif() +# The in-process Node-API conformance harness only builds against engines that export the full C +# napi_* surface it uses. Hermes supplies napi through its own hermesNapi library, which does not +# export e.g. napi_create_external / napi_get_value_external, so linking it fails; QuickJS is likewise +# not validated on-device yet. Opt an engine in here once its harness run is green. +set(JSR_NODE_API_HARNESS_ENGINES V8 JavaScriptCore) +if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_HARNESS_ENGINES) + set(JSR_NODE_API_HARNESS_SRC + ${TESTS_DIR}/NodeApi/node_lite.cpp + ${NODE_LITE_PLATFORM_SRC} + ${NODE_LITE_CHILD_PROCESS_SRC} + ${TESTS_DIR}/NodeApi/node_lite_jsruntimehost.cpp + ${TESTS_DIR}/NodeApi/js_runtime_api.cpp + ${TESTS_DIR}/NodeApi/string_utils.cpp + ${TESTS_DIR}/NodeApi/test_main.cpp) +endif() + add_library(UnitTestsJNI SHARED JNI.cpp ${UNIT_TESTS_DIR}/Shared/DelayedTaskScheduler.cpp @@ -37,13 +53,7 @@ add_library(UnitTestsJNI SHARED ${UNIT_TESTS_DIR}/Shared/TimeoutDispatcher.cpp ${UNIT_TESTS_DIR}/Shared/Shared.h ${UNIT_TESTS_DIR}/Shared/Shared.cpp - ${TESTS_DIR}/NodeApi/node_lite.cpp - ${NODE_LITE_PLATFORM_SRC} - ${NODE_LITE_CHILD_PROCESS_SRC} - ${TESTS_DIR}/NodeApi/node_lite_jsruntimehost.cpp - ${TESTS_DIR}/NodeApi/js_runtime_api.cpp - ${TESTS_DIR}/NodeApi/string_utils.cpp - ${TESTS_DIR}/NodeApi/test_main.cpp) + ${JSR_NODE_API_HARNESS_SRC}) if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") target_sources(UnitTestsJNI PRIVATE ${UNIT_TESTS_DIR}/Shared/V8ForegroundTaskRunner.cpp) @@ -85,8 +95,10 @@ target_link_libraries(UnitTestsJNI if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() -target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") +if(JSR_NODE_API_HARNESS_SRC) + target_compile_definitions(UnitTestsJNI + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") +endif() # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, # packaged by AGP into nativeLibraryDir, and dlopen'd in-process by node_lite_android. Both they and From a101e3baeb0de5298e1158454dbbb754924b81ec Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 20:49:50 -0700 Subject: [PATCH 041/174] Don't default napi to a shared library for the Hermes engine on Android Hermes does not ship a js_native_api_hermes.cc -- its C napi_* functions live in the hermesNapi static library. Building napi as a SHARED library therefore produces a libnapi.so that does not carry those symbols, and everything linking it fails with undefined references (napi_wrap, napi_create_arraybuffer, napi_create_external, ...). The shared-napi default exists so dlopen'd .node addons can resolve napi_* at load; that harness is not built for Hermes, so keep napi static there. --- Core/Node-API/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index aba53df1..9cb3e384 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -269,7 +269,7 @@ endif() # platforms, where napi keeps following the project's default library type (i.e. honors # BUILD_SHARED_LIBS). set(JSR_NAPI_SHARED_DEFAULT OFF) -if(ANDROID) +if(ANDROID AND NOT NAPI_JAVASCRIPT_ENGINE STREQUAL "Hermes") set(JSR_NAPI_SHARED_DEFAULT ON) endif() option(JSR_NAPI_SHARED "Build napi as a shared library (libnapi.so)" ${JSR_NAPI_SHARED_DEFAULT}) From 07525fcb64ec8fb0972f09ee180f4ec4d4594c3e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 02:42:25 -0700 Subject: [PATCH 042/174] Node-API: raise default NAPI_VERSION 5 -> 7 Bump the [BABYLON-NATIVE-ADDITION] default (still -DNAPI_VERSION-overridable) so the v6/v7 surface is exposed. Non-breaking: the enabled conformance addons use only v1-v5, and the JSC/macOS build stays green at v7 (13 pass / 1 skip). V8 implements the full surface for free; JSC/Chakra v6/v7 functions are added incrementally in follow-ups, feature-detect-failing where the engine C API can't express them (BigInt, ArrayBuffer detach). --- Core/Node-API/Include/Shared/napi/js_native_api.h | 2 +- Core/Node-API/Include/Shared/napi/js_native_api_types.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Core/Node-API/Include/Shared/napi/js_native_api.h b/Core/Node-API/Include/Shared/napi/js_native_api.h index 961b30f2..a4f79bdb 100644 --- a/Core/Node-API/Include/Shared/napi/js_native_api.h +++ b/Core/Node-API/Include/Shared/napi/js_native_api.h @@ -3,7 +3,7 @@ // [BABYLON-NATIVE-ADDITION] #ifndef NAPI_VERSION -#define NAPI_VERSION 5 +#define NAPI_VERSION 7 #endif // This file needs to be compatible with C compilers. diff --git a/Core/Node-API/Include/Shared/napi/js_native_api_types.h b/Core/Node-API/Include/Shared/napi/js_native_api_types.h index bea78ecd..4a6cbc33 100644 --- a/Core/Node-API/Include/Shared/napi/js_native_api_types.h +++ b/Core/Node-API/Include/Shared/napi/js_native_api_types.h @@ -3,7 +3,7 @@ // [BABYLON-NATIVE-ADDITION] #ifndef NAPI_VERSION -#define NAPI_VERSION 5 +#define NAPI_VERSION 7 #endif // This file needs to be compatible with C compilers. From cca496dcc9a2774b1cb14bb6b92cc18a2edb81bb Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 03:12:58 -0700 Subject: [PATCH 043/174] JSC: implement napi_set/get_instance_data (N-API v6) Per-env instance data + a finalizer that runs at env teardown. Enables the test_instance_data conformance test, green on JSC/macOS at v7. --- .../Source/js_native_api_javascriptcore.cc | 20 +++++++++++++++++++ .../Source/js_native_api_javascriptcore.h | 8 ++++++++ Tests/NodeApi/CMakeLists.txt | 2 ++ 3 files changed, 30 insertions(+) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index def231d7..2b14ab35 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -1699,6 +1699,26 @@ napi_status napi_get_global(napi_env env, napi_value* result) { return napi_ok; } +// N-API v6: per-environment instance data. The finalizer (if any) runs when the env is torn down +// (see ~napi_env__). +napi_status napi_set_instance_data(napi_env env, + void* data, + napi_finalize finalize_cb, + void* finalize_hint) { + CHECK_ENV(env); + env->instance_data = data; + env->instance_data_finalize_cb = finalize_cb; + env->instance_data_finalize_hint = finalize_hint; + return napi_ok; +} + +napi_status napi_get_instance_data(napi_env env, void** data) { + CHECK_ENV(env); + CHECK_ARG(env, data); + *data = env->instance_data; + return napi_ok; +} + napi_status napi_throw(napi_env env, napi_value error) { CHECK_ENV(env); napi_status status{napi_set_exception(env, ToJSValue(error))}; diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 298921d0..a8bf7d7e 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -17,6 +17,11 @@ struct napi_env__ { std::list strong_refs{}; bool shutting_down{false}; + // napi_set_instance_data / napi_get_instance_data (N-API v6). + void* instance_data{}; + napi_finalize instance_data_finalize_cb{}; + void* instance_data_finalize_hint{}; + JSValueRef constructor_info_symbol{}; JSValueRef function_info_symbol{}; JSValueRef reference_info_symbol{}; @@ -45,6 +50,9 @@ struct napi_env__ { ~napi_env__() { shutting_down = true; + if (instance_data_finalize_cb != nullptr) { + instance_data_finalize_cb(this, instance_data, instance_data_finalize_hint); + } deinit_refs(); deinit_symbol(function_prototype_call); deinit_symbol(wrapper_info_symbol); diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index cc01bbe9..20eb00d6 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -15,6 +15,8 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS # (test_reference_double_free/test_wrap.js is quarantined in test_main.cpp -- a JSC remove_wrap # edge case that returns napi_invalid_arg; tracked as a separate fix, not a v5 blocker.) test_reference_double_free + # v6 + test_instance_data ) function(node_api_copy_test_sources TARGET_NAME) From 50bbb4aacc8a269a5be07c62749ca25babe0d89b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 03:47:35 -0700 Subject: [PATCH 044/174] JSC: implement N-API v6 BigInt + v7 ArrayBuffer detach BigInt: create via the macOS-15+ C API (JSBigIntCreateWith*) with a JS-BigInt-global eval fallback for jsc-android/older; extract (get_value_*) via BigInt.asIntN/asUintN + toString round-trips; typeof reports napi_bigint (kJSTypeBigInt on macOS 15+); create_bigint_words enforces the Node INT_MAX / RangeError size limits before reading the words buffer. Detach: ArrayBuffer.prototype.transfer() (ES2024) with .detached for is_detached; ENOTSUP throw where transfer() is absent. test_bigint green on JSC/macOS. --- .../Source/js_native_api_javascriptcore.cc | 246 +++++++++++++++++- Tests/NodeApi/CMakeLists.txt | 1 + 2 files changed, 246 insertions(+), 1 deletion(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 2b14ab35..5d9e3ab8 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -1,7 +1,10 @@ #include "js_native_api_javascriptcore.h" #include #include +#include #include +#include +#include #include #include #include @@ -1551,7 +1554,6 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) CHECK_ARG(env, value); CHECK_ARG(env, result); - // JSC does not support BigInt JSType valueType = JSValueGetType(env->context, ToJSValue(value)); switch (valueType) { case kJSTypeUndefined: *result = napi_undefined; break; @@ -1560,6 +1562,11 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) case kJSTypeNumber: *result = napi_number; break; case kJSTypeString: *result = napi_string; break; case kJSTypeSymbol: *result = napi_symbol; break; +#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 + // kJSTypeBigInt is macOS 15+/iOS 18+. On older JSC (e.g. jsc-android) a BigInt falls to the + // default branch; a typeof-based fallback is added with the Android bring-up. + case kJSTypeBigInt: *result = napi_bigint; break; +#endif default: JSObjectRef object{ToJSObject(env, value)}; // Consult JSObjectIsConstructor in addition to JSObjectIsFunction: some JSC builds (e.g. @@ -1719,6 +1726,243 @@ napi_status napi_get_instance_data(napi_env env, void** data) { return napi_ok; } +//============================================================================= +// N-API v6 BigInt + v7 ArrayBuffer detach (JavaScriptCore) +// +// The JSC public C API only ships BigInt create functions on macOS 15+/iOS 18+, and ships no +// ArrayBuffer-detach call at all. The JS-level BigInt global, however, has been in JSC since ~2018, +// and ArrayBuffer.prototype.transfer() (ES2024) detaches a buffer -- both reachable through the +// public C API. So: BigInt uses the native C API where available and the JS BigInt global otherwise; +// detach uses transfer(). Extraction (get_value_bigint_*) is always string/round-trip based, since +// the C API has no BigInt readers. +//============================================================================= + +namespace { + +// Call BigInt.asIntN(64, value) / BigInt.asUintN(64, value); yields the low 64 bits as a BigInt. +napi_status BigIntLow64(napi_env env, napi_value value, const char* method, JSValueRef* low) { + JSObjectRef global = JSContextGetGlobalObject(env->context); + JSValueRef exception{}; + JSValueRef bigIntCtor = JSObjectGetProperty(env->context, global, JSString("BigInt"), &exception); + CHECK_JSC(env, exception); + JSObjectRef bigIntObj = JSValueToObject(env->context, bigIntCtor, &exception); + CHECK_JSC(env, exception); + JSValueRef fn = JSObjectGetProperty(env->context, bigIntObj, JSString(method), &exception); + CHECK_JSC(env, exception); + JSObjectRef fnObj = JSValueToObject(env->context, fn, &exception); + CHECK_JSC(env, exception); + JSValueRef args[2] = {JSValueMakeNumber(env->context, 64), ToJSValue(value)}; + *low = JSObjectCallAsFunction(env->context, fnObj, bigIntObj, 2, args, &exception); + CHECK_JSC(env, exception); + return napi_ok; +} + +// value.toString(radix) for a BigInt primitive (boxes the primitive, then calls toString). +napi_status BigIntToString(napi_env env, napi_value value, int radix, std::string* out) { + JSValueRef exception{}; + JSObjectRef boxed = JSValueToObject(env->context, ToJSValue(value), &exception); + CHECK_JSC(env, exception); + JSValueRef toString = JSObjectGetProperty(env->context, boxed, JSString("toString"), &exception); + CHECK_JSC(env, exception); + JSObjectRef toStringFn = JSValueToObject(env->context, toString, &exception); + CHECK_JSC(env, exception); + JSValueRef radixArg = JSValueMakeNumber(env->context, radix); + JSValueRef str = JSObjectCallAsFunction(env->context, toStringFn, boxed, 1, &radixArg, &exception); + CHECK_JSC(env, exception); + JSStringRef jsStr = JSValueToStringCopy(env->context, str, &exception); + CHECK_JSC(env, exception); + size_t cap = JSStringGetMaximumUTF8CStringSize(jsStr); + out->resize(cap); + size_t written = JSStringGetUTF8CString(jsStr, out->data(), cap); + JSStringRelease(jsStr); + if (written > 0) out->resize(written - 1); // drop the trailing NUL + return napi_ok; +} + +// Construct a BigInt from a (controlled) JS source expression; used as the create path where the C +// API is unavailable. Only embeds numeric/hex literals -> no injection surface. +napi_status BigIntFromExpr(napi_env env, const std::string& expr, napi_value* result) { + JSStringRef src = JSStringCreateWithUTF8CString(expr.c_str()); + JSValueRef exception{}; + JSValueRef big = JSEvaluateScript(env->context, src, nullptr, nullptr, 0, &exception); + JSStringRelease(src); + CHECK_JSC(env, exception); + *result = ToNapi(big); + return napi_ok; +} + +} // namespace + +napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result) { + CHECK_ENV(env); + CHECK_ARG(env, result); +#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 + if (__builtin_available(macOS 15.0, *)) { + JSValueRef exception{}; + JSValueRef big = JSBigIntCreateWithInt64(env->context, value, &exception); + CHECK_JSC(env, exception); + *result = ToNapi(big); + return napi_ok; + } +#endif + return BigIntFromExpr(env, "BigInt(\"" + std::to_string(value) + "\")", result); +} + +napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) { + CHECK_ENV(env); + CHECK_ARG(env, result); +#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 + if (__builtin_available(macOS 15.0, *)) { + JSValueRef exception{}; + JSValueRef big = JSBigIntCreateWithUInt64(env->context, value, &exception); + CHECK_JSC(env, exception); + *result = ToNapi(big); + return napi_ok; + } +#endif + return BigIntFromExpr(env, "BigInt(\"" + std::to_string(value) + "\")", result); +} + +napi_status napi_create_bigint_words(napi_env env, + int sign_bit, + size_t word_count, + const uint64_t* words, + napi_value* result) { + CHECK_ENV(env); + CHECK_ARG(env, result); + // Match Node/V8 limits *before* touching the (possibly under-sized) words buffer: beyond INT_MAX + // it's napi_invalid_arg; beyond the engine's BigInt size limit it's a RangeError. + if (word_count > static_cast(INT_MAX)) { + return napi_set_last_error(env, napi_invalid_arg); + } + if (word_count > (static_cast(1) << 24)) { // ~ kMaxBigIntLengthBits / 64 + napi_throw_range_error(env, nullptr, "Maximum BigInt size exceeded"); + return napi_set_last_error(env, napi_pending_exception); + } + if (word_count > 0) { + CHECK_ARG(env, words); + } + // Big-endian hex from the little-endian words (words[0] is the least-significant 64 bits). + std::string hex; + for (size_t i = word_count; i-- > 0;) { + char buf[17]; + snprintf(buf, sizeof(buf), "%016llx", static_cast(words[i])); + hex += buf; + } + if (hex.empty()) { + hex = "0"; + } + std::string expr = (sign_bit ? "-BigInt(\"0x" : "BigInt(\"0x") + hex + "\")"; + return BigIntFromExpr(env, expr, result); +} + +napi_status napi_get_value_bigint_int64(napi_env env, + napi_value value, + int64_t* result, + bool* lossless) { + CHECK_ENV(env); + CHECK_ARG(env, value); + CHECK_ARG(env, result); + CHECK_ARG(env, lossless); + JSValueRef low{}; + CHECK_NAPI(BigIntLow64(env, value, "asIntN", &low)); + std::string decimal; + CHECK_NAPI(BigIntToString(env, ToNapi(low), 10, &decimal)); + *result = static_cast(strtoll(decimal.c_str(), nullptr, 10)); + *lossless = JSValueIsStrictEqual(env->context, ToJSValue(value), low); + return napi_ok; +} + +napi_status napi_get_value_bigint_uint64(napi_env env, + napi_value value, + uint64_t* result, + bool* lossless) { + CHECK_ENV(env); + CHECK_ARG(env, value); + CHECK_ARG(env, result); + CHECK_ARG(env, lossless); + JSValueRef low{}; + CHECK_NAPI(BigIntLow64(env, value, "asUintN", &low)); + std::string decimal; + CHECK_NAPI(BigIntToString(env, ToNapi(low), 10, &decimal)); + *result = static_cast(strtoull(decimal.c_str(), nullptr, 10)); + *lossless = JSValueIsStrictEqual(env->context, ToJSValue(value), low); + return napi_ok; +} + +napi_status napi_get_value_bigint_words(napi_env env, + napi_value value, + int* sign_bit, + size_t* word_count, + uint64_t* words) { + CHECK_ENV(env); + CHECK_ARG(env, value); + CHECK_ARG(env, word_count); + std::string hex; + CHECK_NAPI(BigIntToString(env, value, 16, &hex)); + bool negative = !hex.empty() && hex[0] == '-'; + std::string digits = negative ? hex.substr(1) : hex; + if (digits == "0") { + digits.clear(); + } + size_t needed = (digits.length() + 15) / 16; + if (words == nullptr) { + *word_count = needed; + return napi_ok; + } + if (sign_bit != nullptr) { + *sign_bit = negative ? 1 : 0; + } + size_t capacity = *word_count; + *word_count = needed; + for (size_t w = 0; w < needed && w < capacity; ++w) { + size_t end = digits.length() - w * 16; + size_t start = end >= 16 ? end - 16 : 0; + std::string chunk = digits.substr(start, end - start); + words[w] = static_cast(strtoull(chunk.c_str(), nullptr, 16)); + } + return napi_ok; +} + +napi_status napi_detach_arraybuffer(napi_env env, napi_value arraybuffer) { + CHECK_ENV(env); + CHECK_ARG(env, arraybuffer); + JSObjectRef ab = ToJSObject(env, arraybuffer); + JSValueRef exception{}; + JSValueRef transfer = JSObjectGetProperty(env->context, ab, JSString("transfer"), &exception); + CHECK_JSC(env, exception); + if (!JSValueIsObject(env->context, transfer)) { + // ArrayBuffer.prototype.transfer() (ES2024) is the only public-API detach path; if the engine + // predates it (older jsc-android), throw a catchable ENOTSUP so JS land can polyfill. + napi_throw_error(env, "ENOTSUP", + "ArrayBuffer detach is not supported by the underlying JavaScript engine."); + return napi_set_last_error(env, napi_pending_exception); + } + JSObjectRef transferFn = JSValueToObject(env->context, transfer, &exception); + CHECK_JSC(env, exception); + JSObjectCallAsFunction(env->context, transferFn, ab, 0, nullptr, &exception); // detaches `ab` + CHECK_JSC(env, exception); + return napi_ok; +} + +napi_status napi_is_detached_arraybuffer(napi_env env, napi_value arraybuffer, bool* result) { + CHECK_ENV(env); + CHECK_ARG(env, arraybuffer); + CHECK_ARG(env, result); + JSObjectRef ab = ToJSObject(env, arraybuffer); + JSValueRef exception{}; + JSValueRef detached = JSObjectGetProperty(env->context, ab, JSString("detached"), &exception); + CHECK_JSC(env, exception); + if (JSValueIsBoolean(env->context, detached)) { + *result = JSValueToBoolean(env->context, detached); + } else { + // Pre-ES2024 fallback: a detached buffer has no backing store. + JSValueRef ignored{}; + *result = JSObjectGetArrayBufferBytesPtr(env->context, ab, &ignored) == nullptr; + } + return napi_ok; +} + napi_status napi_throw(napi_env env, napi_value error) { CHECK_ENV(env); napi_status status{napi_set_exception(env, ToJSValue(error))}; diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 20eb00d6..4bca2612 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -17,6 +17,7 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS test_reference_double_free # v6 test_instance_data + test_bigint ) function(node_api_copy_test_sources TARGET_NAME) From 128c8d04b81ce47da5b50aae64986d54b38f826e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 03:52:40 -0700 Subject: [PATCH 045/174] tests: note detach/property_names conformance tests are v9-gated (node_api_basic_env) --- Tests/NodeApi/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 4bca2612..f8b4f95d 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -18,6 +18,8 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS # v6 test_instance_data test_bigint + # NOTE: detach (v7) is implemented + manually verified, but its conformance test (test_typedarray) + # and get_all_property_names (test_object) use v9 APIs (node_api_basic_env); they enable at the v9 bump. ) function(node_api_copy_test_sources TARGET_NAME) From 995ddf2f54034fd795fdfc08c5b9e7eb786491ae Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:07:47 -0700 Subject: [PATCH 046/174] JSC: detect BigInt in napi_typeof on jsc-android (cached typeof predicate) macOS 15+/iOS 18+ use the kJSTypeBigInt fast path; older JSC (jsc-android ~2020) does not surface kJSTypeBigInt through the C API, so fall back to a cached `typeof v === 'bigint'` predicate created at env init. Keeps the v6 BigInt conformance test green on the jsc-android target. --- .../Source/js_native_api_javascriptcore.cc | 32 ++++++++++++++++++- .../Source/js_native_api_javascriptcore.h | 4 +++ 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 5d9e3ab8..907f1237 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -859,6 +859,19 @@ void napi_env__::init_function_prototype_call() { JSValueProtect(context, function_prototype_call); } +void napi_env__::init_is_bigint_function() { + // Cache a `typeof v === 'bigint'` predicate so napi_typeof can detect BigInt on JSC builds whose C + // API does not expose kJSTypeBigInt (e.g. jsc-android). On macOS 15+/iOS 18+ napi_typeof uses the + // kJSTypeBigInt fast path and this predicate is unused. + JSStringRef script = JSStringCreateWithUTF8CString("(function (v) { return typeof v === 'bigint'; })"); + JSValueRef exception = nullptr; + is_bigint_function = JSEvaluateScript(context, script, nullptr, nullptr, 0, &exception); + JSStringRelease(script); + if (is_bigint_function != nullptr) { + JSValueProtect(context, is_bigint_function); + } +} + // Warning: Keep in-sync with napi_status enum static const char* error_messages[] = { nullptr, @@ -1567,7 +1580,23 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) // default branch; a typeof-based fallback is added with the Android bring-up. case kJSTypeBigInt: *result = napi_bigint; break; #endif - default: + default: { +#if !(defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000) + // Older JSC (e.g. jsc-android) does not report kJSTypeBigInt through JSValueGetType, so detect + // BigInt with the cached `typeof v === 'bigint'` predicate before treating value as an object. + if (env->is_bigint_function != nullptr) { + JSValueRef arg = ToJSValue(value); + JSValueRef exception = nullptr; + JSObjectRef predicate = JSValueToObject(env->context, env->is_bigint_function, &exception); + if (exception == nullptr && predicate != nullptr) { + JSValueRef matched = JSObjectCallAsFunction(env->context, predicate, nullptr, 1, &arg, &exception); + if (exception == nullptr && JSValueToBoolean(env->context, matched)) { + *result = napi_bigint; + break; + } + } + } +#endif JSObjectRef object{ToJSObject(env, value)}; // Consult JSObjectIsConstructor in addition to JSObjectIsFunction: some JSC builds (e.g. // libjavascriptcoregtk) report constructors created via JSObjectMakeConstructor -- such as @@ -1585,6 +1614,7 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) } } break; + } } return napi_ok; diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index a8bf7d7e..fa5f6428 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -27,6 +27,7 @@ struct napi_env__ { JSValueRef reference_info_symbol{}; JSValueRef wrapper_info_symbol{}; JSValueRef function_prototype_call{}; + JSValueRef is_bigint_function{}; // Escapable scope bookkeeping: token -> whether that scope has escaped. Values // are rooted by the engine rather than by a scope here, so this exists only to @@ -46,6 +47,7 @@ struct napi_env__ { init_symbol(reference_info_symbol, "BabylonNative_ReferenceInfo"); init_symbol(wrapper_info_symbol, "BabylonNative_WrapperInfo"); init_function_prototype_call(); + init_is_bigint_function(); } ~napi_env__() { @@ -54,6 +56,7 @@ struct napi_env__ { instance_data_finalize_cb(this, instance_data, instance_data_finalize_hint); } deinit_refs(); + deinit_symbol(is_bigint_function); deinit_symbol(function_prototype_call); deinit_symbol(wrapper_info_symbol); deinit_symbol(reference_info_symbol); @@ -78,6 +81,7 @@ struct napi_env__ { void deinit_refs(); void init_symbol(JSValueRef& symbol, const char* description); void init_function_prototype_call(); + void init_is_bigint_function(); void deinit_symbol(JSValueRef symbol); }; From 259c591c67d0e431fabc9959c5b7d1e389039fbf Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:07:47 -0700 Subject: [PATCH 047/174] Chakra/JSI: N-API v6/v7 surface for the cross-engine version bump Chakra: add napi_set/get_instance_data (per-env slot, finalized at env teardown by ~napi_env__) and the BigInt create/get functions as feature-detection stubs that throw a JS-catchable ENOTSUP error -- the Win10 OS edge-mode Chakra predates BigInt and exposes no JsBigInt* API, so there is no value-preserving fallback. JSI (Core/Node-API-JSI) does not implement the v6/v7 C surface, so its conformance addons are gated to the v1-v5 set. V8 + JavaScriptCore execute the v6/v7 tests for real; Chakra links them. --- Core/Node-API/Source/js_native_api_chakra.cc | 73 ++++++++++++++++++++ Core/Node-API/Source/js_native_api_chakra.h | 12 ++++ Tests/NodeApi/CMakeLists.txt | 17 +++-- 3 files changed, 97 insertions(+), 5 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_chakra.cc b/Core/Node-API/Source/js_native_api_chakra.cc index 6e5d3e72..7da499b6 100644 --- a/Core/Node-API/Source/js_native_api_chakra.cc +++ b/Core/Node-API/Source/js_native_api_chakra.cc @@ -2486,6 +2486,79 @@ napi_status napi_run_script(napi_env env, return napi_ok; } +// === N-API v6 / v7 === +// +// napi_set_instance_data / napi_get_instance_data (v6): per-env data slot, finalized at env teardown +// by ~napi_env__ (see js_native_api_chakra.h). +napi_status napi_set_instance_data(napi_env env, + void* data, + napi_finalize finalize_cb, + void* finalize_hint) { + CHECK_ENV(env); + env->instance_data = data; + env->instance_data_finalize_cb = finalize_cb; + env->instance_data_finalize_hint = finalize_hint; + return napi_ok; +} + +napi_status napi_get_instance_data(napi_env env, void** data) { + CHECK_ENV(env); + CHECK_ARG(env, data); + *data = env->instance_data; + return napi_ok; +} + +// BigInt (v6): the Win10 OS edge-mode Chakra (jsrt) predates BigInt and exposes no JsBigInt* API, so +// there is no value-preserving fallback. Per the Node-API feature-detection-by-exception pattern, throw +// a JS-catchable error tagged "ENOTSUP" (so JS land can detect + polyfill) and return a pending +// exception rather than silently failing. (ChakraCore added BigInt behind a flag, but the OS Chakra +// this backend targets did not ship it.) +static napi_status napi_bigint_not_supported(napi_env env) { + CHECK_ENV(env); + CHECK_NAPI(napi_throw_error( + env, "ENOTSUP", + "BigInt is not supported by the underlying JavaScript engine (Chakra).")); + return napi_set_last_error(env, napi_pending_exception); +} + +napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result) { + return napi_bigint_not_supported(env); +} + +napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) { + return napi_bigint_not_supported(env); +} + +napi_status napi_create_bigint_words(napi_env env, + int sign_bit, + size_t word_count, + const uint64_t* words, + napi_value* result) { + return napi_bigint_not_supported(env); +} + +napi_status napi_get_value_bigint_int64(napi_env env, + napi_value value, + int64_t* result, + bool* lossless) { + return napi_bigint_not_supported(env); +} + +napi_status napi_get_value_bigint_uint64(napi_env env, + napi_value value, + uint64_t* result, + bool* lossless) { + return napi_bigint_not_supported(env); +} + +napi_status napi_get_value_bigint_words(napi_env env, + napi_value value, + int* sign_bit, + size_t* word_count, + uint64_t* words) { + return napi_bigint_not_supported(env); +} + napi_status napi_add_finalizer(napi_env env, napi_value js_object, void* native_object, diff --git a/Core/Node-API/Source/js_native_api_chakra.h b/Core/Node-API/Source/js_native_api_chakra.h index 2dfa59de..a5e18d99 100644 --- a/Core/Node-API/Source/js_native_api_chakra.h +++ b/Core/Node-API/Source/js_native_api_chakra.h @@ -24,7 +24,19 @@ struct napi_env__ { size_t next_escapable_scope_token = 0; std::map open_escapable_scopes; + // napi_set_instance_data / napi_get_instance_data (N-API v6). + void* instance_data = nullptr; + napi_finalize instance_data_finalize_cb = nullptr; + void* instance_data_finalize_hint = nullptr; + const std::thread::id thread_id{std::this_thread::get_id()}; + + ~napi_env__() { + // Run the instance-data finalizer at env teardown (env_chakra.cc deletes the env), matching V8/JSC. + if (instance_data_finalize_cb != nullptr) { + instance_data_finalize_cb(this, instance_data, instance_data_finalize_hint); + } + } }; #define RETURN_STATUS_IF_FALSE(env, condition, status) \ diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index f8b4f95d..36390c5c 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -15,13 +15,20 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS # (test_reference_double_free/test_wrap.js is quarantined in test_main.cpp -- a JSC remove_wrap # edge case that returns napi_invalid_arg; tracked as a separate fix, not a v5 blocker.) test_reference_double_free - # v6 - test_instance_data - test_bigint - # NOTE: detach (v7) is implemented + manually verified, but its conformance test (test_typedarray) - # and get_all_property_names (test_object) use v9 APIs (node_api_basic_env); they enable at the v9 bump. ) +# v6/v7 conformance addons. The JSI backend (Core/Node-API-JSI) does not implement the v6/v7 C surface, +# so its addons are omitted (its build links only the v1-v5 set). V8 + JavaScriptCore execute these for +# real; Chakra links them (instance_data works; BigInt throws ENOTSUP via feature-detection). +# NOTE: detach (v7, test_typedarray) + get_all_property_names (v6, test_object) use v9 APIs +# (node_api_basic_env) and enable at the v9 bump. +if(NOT NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI") + list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS + test_instance_data + test_bigint + ) +endif() + function(node_api_copy_test_sources TARGET_NAME) add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory From 1af114d618f7aaeefd7bf87e8d48dc3758939bc0 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 04:57:36 -0700 Subject: [PATCH 048/174] Tests/Android: run test_bigint on V8 only (jsc-android ~2020 BigInt shim not green on-device) test_instance_data (v6) runs on both Android engines; BigInt runs for real on V8. On jsc-android the eval-based BigInt shim fails on-device with no error detail from the in-process runner (macOS JSC + V8 both pass test_bigint), so it's gated to V8 and tracked as a follow-up. --- .../UnitTests/Android/app/src/main/cpp/CMakeLists.txt | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 9053d8c5..6a79ab1d 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -96,8 +96,17 @@ if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() if(JSR_NODE_API_HARNESS_SRC) + # The v1-v5 suite + v6 instance_data run on both Android engines. BigInt runs for real on V8; on + # jsc-android (~2020) the eval-based BigInt shim isn't green yet on-device (the in-process runner gives + # no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a + # follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. + set(_jsr_node_api_tests + "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") + string(APPEND _jsr_node_api_tests ",test_bigint") + endif() target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") endif() # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, From 0b076683968a6db7014e5b49500c018c7f1e762f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 13:11:16 -0700 Subject: [PATCH 049/174] JSC: feature-detect BigInt; throw ENOTSUP where the engine lacks it (jsc-android ~2020) jsc-android (~2020) ships without BigInt -- its parser even rejects `0n` literals -- so the eval-based BigInt shim can't work there. Detect BigInt once at env init (`typeof BigInt === 'function' && typeof BigInt(1) === 'bigint'`, which parses on every JSC) and have the create/get paths throw a JS-catchable ENOTSUP when it's absent, matching the Chakra backend. macOS/iOS JSC (which have BigInt) are unaffected. --- .../Source/js_native_api_javascriptcore.cc | 30 +++++++++++++++++++ .../Source/js_native_api_javascriptcore.h | 3 ++ 2 files changed, 33 insertions(+) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 907f1237..467e2434 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -872,6 +872,19 @@ void napi_env__::init_is_bigint_function() { } } +void napi_env__::init_bigint_supported() { + // Detect BigInt once at env init. jsc-android (~2020) ships without BigInt -- its parser even rejects + // `0n` literals -- so the eval/C-API BigInt paths must feature-detect-fail there. `typeof BigInt` + // parses on every JSC (no literal syntax), and BigInt(1) confirms the global is actually functional. + JSStringRef script = JSStringCreateWithUTF8CString( + "(function () { try { return typeof BigInt === 'function' && typeof BigInt(1) === 'bigint'; }" + " catch (e) { return false; } })()"); + JSValueRef exception = nullptr; + JSValueRef result = JSEvaluateScript(context, script, nullptr, nullptr, 0, &exception); + JSStringRelease(script); + bigint_supported = (exception == nullptr) && (result != nullptr) && JSValueToBoolean(context, result); +} + // Warning: Keep in-sync with napi_status enum static const char* error_messages[] = { nullptr, @@ -1770,7 +1783,18 @@ napi_status napi_get_instance_data(napi_env env, void** data) { namespace { // Call BigInt.asIntN(64, value) / BigInt.asUintN(64, value); yields the low 64 bits as a BigInt. +// Reported when the underlying JSC build has no BigInt (e.g. jsc-android ~2020). Matches the Chakra +// backend: a JS-catchable ENOTSUP error per the Node-API feature-detection pattern. +napi_status napi_bigint_unsupported(napi_env env) { + CHECK_NAPI(napi_throw_error(env, "ENOTSUP", + "BigInt is not supported by the underlying JavaScript engine.")); + return napi_set_last_error(env, napi_pending_exception); +} + napi_status BigIntLow64(napi_env env, napi_value value, const char* method, JSValueRef* low) { + if (!env->bigint_supported) { + return napi_bigint_unsupported(env); + } JSObjectRef global = JSContextGetGlobalObject(env->context); JSValueRef exception{}; JSValueRef bigIntCtor = JSObjectGetProperty(env->context, global, JSString("BigInt"), &exception); @@ -1789,6 +1813,9 @@ napi_status BigIntLow64(napi_env env, napi_value value, const char* method, JSVa // value.toString(radix) for a BigInt primitive (boxes the primitive, then calls toString). napi_status BigIntToString(napi_env env, napi_value value, int radix, std::string* out) { + if (!env->bigint_supported) { + return napi_bigint_unsupported(env); + } JSValueRef exception{}; JSObjectRef boxed = JSValueToObject(env->context, ToJSValue(value), &exception); CHECK_JSC(env, exception); @@ -1812,6 +1839,9 @@ napi_status BigIntToString(napi_env env, napi_value value, int radix, std::strin // Construct a BigInt from a (controlled) JS source expression; used as the create path where the C // API is unavailable. Only embeds numeric/hex literals -> no injection surface. napi_status BigIntFromExpr(napi_env env, const std::string& expr, napi_value* result) { + if (!env->bigint_supported) { + return napi_bigint_unsupported(env); + } JSStringRef src = JSStringCreateWithUTF8CString(expr.c_str()); JSValueRef exception{}; JSValueRef big = JSEvaluateScript(env->context, src, nullptr, nullptr, 0, &exception); diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index fa5f6428..2d16968c 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -28,6 +28,7 @@ struct napi_env__ { JSValueRef wrapper_info_symbol{}; JSValueRef function_prototype_call{}; JSValueRef is_bigint_function{}; + bool bigint_supported{false}; // Escapable scope bookkeeping: token -> whether that scope has escaped. Values // are rooted by the engine rather than by a scope here, so this exists only to @@ -48,6 +49,7 @@ struct napi_env__ { init_symbol(wrapper_info_symbol, "BabylonNative_WrapperInfo"); init_function_prototype_call(); init_is_bigint_function(); + init_bigint_supported(); } ~napi_env__() { @@ -82,6 +84,7 @@ struct napi_env__ { void init_symbol(JSValueRef& symbol, const char* description); void init_function_prototype_call(); void init_is_bigint_function(); + void init_bigint_supported(); void deinit_symbol(JSValueRef symbol); }; From 807241a300ffa261551ee49b438036182c5c8c12 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 13:11:16 -0700 Subject: [PATCH 050/174] Tests/NodeApi: add literal-free test_bigint_unsupported fallback; gate BigInt by engine support The standard test_bigint uses `0n` literals, which don't parse on engines without BigInt (jsc-android ~2020, Win10 Chakra). Add a feature-detection fallback that asserts napi_create_bigint_int64 throws ENOTSUP, and gate it to run exactly where BigInt is absent (Chakra; jsc-android) while the real test_bigint runs on V8 + Apple JSC. Keeps the desktop + Android run-lists in sync. --- Tests/NodeApi/CMakeLists.txt | 14 ++++-- .../test_bigint_unsupported/CMakeLists.txt | 4 ++ .../test_bigint_unsupported/binding.gyp | 10 ++++ .../test_bigint_unsupported/test.js | 18 +++++++ .../test_bigint_unsupported.c | 30 +++++++++++ .../Android/app/src/main/cpp/CMakeLists.txt | 50 ++++++++----------- 6 files changed, 93 insertions(+), 33 deletions(-) create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint_unsupported/CMakeLists.txt create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint_unsupported/binding.gyp create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test.js create mode 100644 Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test_bigint_unsupported.c diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 36390c5c..1a4acd0f 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -23,10 +23,16 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS # NOTE: detach (v7, test_typedarray) + get_all_property_names (v6, test_object) use v9 APIs # (node_api_basic_env) and enable at the v9 bump. if(NOT NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI") - list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS - test_instance_data - test_bigint - ) + list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_instance_data) + # BigInt: the real conformance test where the engine has BigInt; an ENOTSUP feature-detection + # fallback where it doesn't -- the Win10 OS Chakra, and jsc-android (~2020), whose parser rejects + # `0n` literals so the standard test_bigint can't even be parsed there. + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Chakra" OR + (NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore" AND ANDROID)) + list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_bigint_unsupported) + else() + list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_bigint) + endif() endif() function(node_api_copy_test_sources TARGET_NAME) diff --git a/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/CMakeLists.txt b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/CMakeLists.txt new file mode 100644 index 00000000..8ef5603d --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/CMakeLists.txt @@ -0,0 +1,4 @@ +add_node_api_module(test_bigint_unsupported + SOURCES + test_bigint_unsupported.c +) diff --git a/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/binding.gyp b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/binding.gyp new file mode 100644 index 00000000..897ff4bb --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/binding.gyp @@ -0,0 +1,10 @@ +{ + "targets": [ + { + "target_name": "test_bigint_unsupported", + "sources": [ + "test_bigint_unsupported.c" + ] + } + ] +} diff --git a/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test.js b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test.js new file mode 100644 index 00000000..fe550dd0 --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test.js @@ -0,0 +1,18 @@ +'use strict'; +const common = require('../../common'); +const assert = require('assert'); +const { + CreateBigIntExpectThrow, +} = require(`./build/${common.buildType}/test_bigint_unsupported`); + +// On engines without BigInt (jsc-android ~2020, Win10 Chakra) the BigInt create API throws a +// JS-catchable ENOTSUP. The standard test_bigint can't run on these engines at all -- its `0n` +// literals raise a SyntaxError at parse time -- so this is the feature-detection fallback. +let threw = false; +try { + CreateBigIntExpectThrow(); +} catch (err) { + threw = true; + assert.strictEqual(err.code, 'ENOTSUP'); +} +assert.strictEqual(threw, true, 'expected napi_create_bigint_int64 to throw ENOTSUP'); diff --git a/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test_bigint_unsupported.c b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test_bigint_unsupported.c new file mode 100644 index 00000000..75fa35fc --- /dev/null +++ b/Tests/NodeApi/test/js-native-api/test_bigint_unsupported/test_bigint_unsupported.c @@ -0,0 +1,30 @@ +#include +#include "../common.h" +#include "../entry_point.h" + +// Feature-detection fallback for the standard test_bigint. Engines without BigInt (jsc-android ~2020, +// whose parser even rejects `0n` literals, and the Win10 OS Chakra) must report the capability gap via +// a JS-catchable ENOTSUP exception from the BigInt create API rather than failing silently or crashing. +static napi_value CreateBigIntExpectThrow(napi_env env, napi_callback_info info) { + (void)info; + napi_value result = NULL; + // On a BigInt-less engine this throws ENOTSUP (a pending exception); let it propagate to JS land, + // where test.js asserts on the error code. (No `0n` literal here, so the script itself parses.) + napi_create_bigint_int64(env, 42, &result); + (void)result; + return NULL; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor properties[] = { + DECLARE_NODE_API_PROPERTY("CreateBigIntExpectThrow", CreateBigIntExpectThrow), + }; + + NODE_API_CALL(env, + napi_define_properties( + env, exports, sizeof(properties) / sizeof(*properties), properties)); + + return exports; +} +EXTERN_C_END diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 6a79ab1d..5d1de22c 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -30,22 +30,6 @@ else() set(NODE_LITE_CHILD_PROCESS_SRC ${TESTS_DIR}/NodeApi/child_process_posix.cpp) endif() -# The in-process Node-API conformance harness only builds against engines that export the full C -# napi_* surface it uses. Hermes supplies napi through its own hermesNapi library, which does not -# export e.g. napi_create_external / napi_get_value_external, so linking it fails; QuickJS is likewise -# not validated on-device yet. Opt an engine in here once its harness run is green. -set(JSR_NODE_API_HARNESS_ENGINES V8 JavaScriptCore) -if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_HARNESS_ENGINES) - set(JSR_NODE_API_HARNESS_SRC - ${TESTS_DIR}/NodeApi/node_lite.cpp - ${NODE_LITE_PLATFORM_SRC} - ${NODE_LITE_CHILD_PROCESS_SRC} - ${TESTS_DIR}/NodeApi/node_lite_jsruntimehost.cpp - ${TESTS_DIR}/NodeApi/js_runtime_api.cpp - ${TESTS_DIR}/NodeApi/string_utils.cpp - ${TESTS_DIR}/NodeApi/test_main.cpp) -endif() - add_library(UnitTestsJNI SHARED JNI.cpp ${UNIT_TESTS_DIR}/Shared/DelayedTaskScheduler.cpp @@ -53,7 +37,13 @@ add_library(UnitTestsJNI SHARED ${UNIT_TESTS_DIR}/Shared/TimeoutDispatcher.cpp ${UNIT_TESTS_DIR}/Shared/Shared.h ${UNIT_TESTS_DIR}/Shared/Shared.cpp - ${JSR_NODE_API_HARNESS_SRC}) + ${TESTS_DIR}/NodeApi/node_lite.cpp + ${NODE_LITE_PLATFORM_SRC} + ${NODE_LITE_CHILD_PROCESS_SRC} + ${TESTS_DIR}/NodeApi/node_lite_jsruntimehost.cpp + ${TESTS_DIR}/NodeApi/js_runtime_api.cpp + ${TESTS_DIR}/NodeApi/string_utils.cpp + ${TESTS_DIR}/NodeApi/test_main.cpp) if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") target_sources(UnitTestsJNI PRIVATE ${UNIT_TESTS_DIR}/Shared/V8ForegroundTaskRunner.cpp) @@ -95,19 +85,21 @@ target_link_libraries(UnitTestsJNI if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() -if(JSR_NODE_API_HARNESS_SRC) - # The v1-v5 suite + v6 instance_data run on both Android engines. BigInt runs for real on V8; on - # jsc-android (~2020) the eval-based BigInt shim isn't green yet on-device (the in-process runner gives - # no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a - # follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. - set(_jsr_node_api_tests - "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") - string(APPEND _jsr_node_api_tests ",test_bigint") - endif() - target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") +# The v1-v5 suite + v6 instance_data run on both Android engines. BigInt runs for real on V8; on +# jsc-android (~2020) the eval-based BigInt shim isn't green yet on-device (the in-process runner gives +# no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a +# follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. +set(_jsr_node_api_tests + "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") +# BigInt runs for real on V8. jsc-android (~2020) has no BigInt (its parser rejects `0n`), so it runs +# the ENOTSUP feature-detection fallback (test_bigint_unsupported) instead. +if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") + string(APPEND _jsr_node_api_tests ",test_bigint") +else() + string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") endif() +target_compile_definitions(UnitTestsJNI + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, # packaged by AGP into nativeLibraryDir, and dlopen'd in-process by node_lite_android. Both they and From 62739d59a31cb8d7b10bdbeae091473039ab7e29 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Fri, 5 Jun 2026 13:11:16 -0700 Subject: [PATCH 051/174] Tests/Android: surface in-process node_lite failure detail to logcat The in-process runner keeps the assertion/exception message + stack in ProcessResult.std_error, which never reached the device log -- making on-device conformance failures undebuggable (a 0 ms FAILED with no detail). Log it on non-zero status. This is what surfaced the jsc-android BigInt SyntaxError. --- Tests/UnitTests/Shared/Shared.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 5aa57847..2e35678f 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -191,7 +191,16 @@ namespace callbacks.stderr_callback = [](const std::string& message) { __android_log_write(ANDROID_LOG_ERROR, "NodeApiTests", message.c_str()); }; - return node_api_tests::RunNodeLiteScript(baseDir, script, std::move(callbacks)); + auto result = node_api_tests::RunNodeLiteScript(baseDir, script, std::move(callbacks)); + // Surface the in-process failure detail to logcat. The runner keeps the assertion / + // exception message + stack in result.std_error; without this it never reaches the + // device log, making on-device conformance failures undebuggable. + if (result.status != 0) { + std::string detail = result.std_error.empty() ? "(no std_error captured)" : result.std_error; + __android_log_write(ANDROID_LOG_ERROR, "NodeApiTests", + ("[node_lite status=" + std::to_string(result.status) + "] " + detail).c_str()); + } + return result; }; config.enabled_native_suites = ParseNativeSuiteList(); From 4fbae5d066facffb8d7079cffae767212629376d Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 19:33:46 -0700 Subject: [PATCH 052/174] Tests/NodeApi: gate the v6/v7 conformance addons by an engine allow-list The addons were enabled for every engine except JSI, so the backends upstream has added since (QuickJS, Hermes) picked up addons whose napi_* symbols they do not export and failed at link -- QuickJS has napi_create_bigint_int64 but no napi_create_bigint_words / napi_get_value_bigint_words, and no napi_add_finalizer (test_instance_data). Switch to an allow-list of the engines whose v6/v7 surface is implemented and which the suite has actually been run against (V8, JavaScriptCore, Chakra), so a newly added backend is opted in deliberately rather than by default. --- Tests/NodeApi/CMakeLists.txt | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 1a4acd0f..9a337b33 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -17,12 +17,17 @@ set(JSR_NODE_API_NATIVE_TEST_DIRS test_reference_double_free ) -# v6/v7 conformance addons. The JSI backend (Core/Node-API-JSI) does not implement the v6/v7 C surface, -# so its addons are omitted (its build links only the v1-v5 set). V8 + JavaScriptCore execute these for -# real; Chakra links them (instance_data works; BigInt throws ENOTSUP via feature-detection). +# v6/v7 conformance addons, enabled per engine by what that engine actually implements. +# +# This is an ALLOW-list on purpose: upstream keeps adding backends (QuickJS, Hermes, JSI), and each new +# one otherwise silently picks up addons whose napi_* symbols it does not export, failing at link +# (e.g. QuickJS has napi_create_bigint_int64 but no *_words and no napi_add_finalizer). Add an engine +# here only once its v6/v7 surface is implemented and the suite has been run against it. +# # NOTE: detach (v7, test_typedarray) + get_all_property_names (v6, test_object) use v9 APIs # (node_api_basic_env) and enable at the v9 bump. -if(NOT NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI") +set(JSR_NODE_API_V6_V7_ENGINES V8 JavaScriptCore Chakra) +if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_V6_V7_ENGINES) list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_instance_data) # BigInt: the real conformance test where the engine has BigInt; an ENOTSUP feature-detection # fallback where it doesn't -- the Win10 OS Chakra, and jsc-android (~2020), whose parser rejects From 4db0d033b041be234cbffe00c296e8d027a94ef2 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 19:53:53 -0700 Subject: [PATCH 053/174] Tests/Android: apply the same v6/v7 engine allow-list to the on-device suite The Android app carries its own NODE_API_AVAILABLE_NATIVE_TESTS list, which gave every non-V8 engine test_instance_data plus the ENOTSUP BigInt fallback. On QuickJS that is wrong twice over: it has no napi_add_finalizer (test_instance_data), and it *does* have BigInt, so the ENOTSUP fallback fails. Restrict the v6/v7 suites to V8 + JavaScriptCore, matching Tests/NodeApi/CMakeLists.txt. --- .../Android/app/src/main/cpp/CMakeLists.txt | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 5d1de22c..7825eabb 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -90,14 +90,23 @@ endif() # no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a # follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. set(_jsr_node_api_tests - "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") -# BigInt runs for real on V8. jsc-android (~2020) has no BigInt (its parser rejects `0n`), so it runs -# the ENOTSUP feature-detection fallback (test_bigint_unsupported) instead. -if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") - string(APPEND _jsr_node_api_tests ",test_bigint") -else() - string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") + "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") + +# v6/v7 suites, per engine -- keep in sync with the allow-list in Tests/NodeApi/CMakeLists.txt. Only +# engines whose v6/v7 surface is actually implemented run these; a backend added upstream later (e.g. +# QuickJS, which has napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted +# in deliberately rather than inheriting them by default. +if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" OR NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") + string(APPEND _jsr_node_api_tests ",test_instance_data") + # BigInt runs for real on V8; jsc-android (~2020) has no BigInt at all (its parser rejects `0n`), + # so it runs the ENOTSUP feature-detection fallback instead. + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") + string(APPEND _jsr_node_api_tests ",test_bigint") + else() + string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") + endif() endif() + target_compile_definitions(UnitTestsJNI PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") From 94cad116b67f6401218962b352d25bc59ee32d5f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 31 Aug 2026 20:31:37 -0700 Subject: [PATCH 054/174] Tests/Android: keep the v6/v7 test list inside the harness guard The NODE_API_AVAILABLE_NATIVE_TESTS list is only meaningful when the in-process harness sources are actually compiled, which is now gated to the validated engines (V8, JavaScriptCore). --- .../Android/app/src/main/cpp/CMakeLists.txt | 38 ++++++++++--------- 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 7825eabb..dd2e0582 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -89,26 +89,28 @@ endif() # jsc-android (~2020) the eval-based BigInt shim isn't green yet on-device (the in-process runner gives # no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a # follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. -set(_jsr_node_api_tests - "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") - -# v6/v7 suites, per engine -- keep in sync with the allow-list in Tests/NodeApi/CMakeLists.txt. Only -# engines whose v6/v7 surface is actually implemented run these; a backend added upstream later (e.g. -# QuickJS, which has napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted -# in deliberately rather than inheriting them by default. -if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" OR NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") - string(APPEND _jsr_node_api_tests ",test_instance_data") - # BigInt runs for real on V8; jsc-android (~2020) has no BigInt at all (its parser rejects `0n`), - # so it runs the ENOTSUP feature-detection fallback instead. - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") - string(APPEND _jsr_node_api_tests ",test_bigint") - else() - string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") +if(JSR_NODE_API_HARNESS_SRC) + set(_jsr_node_api_tests + "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") + + # v6/v7 suites, per engine -- keep in sync with the allow-list in Tests/NodeApi/CMakeLists.txt. Only + # engines whose v6/v7 surface is actually implemented run these; a backend added upstream later (e.g. + # QuickJS, which has napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted + # in deliberately rather than inheriting them by default. + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" OR NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") + string(APPEND _jsr_node_api_tests ",test_instance_data") + # BigInt runs for real on V8; jsc-android (~2020) has no BigInt at all (its parser rejects `0n`), + # so it runs the ENOTSUP feature-detection fallback instead. + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") + string(APPEND _jsr_node_api_tests ",test_bigint") + else() + string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") + endif() endif() -endif() -target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") + target_compile_definitions(UnitTestsJNI + PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") +endif() # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, # packaged by AGP into nativeLibraryDir, and dlopen'd in-process by node_lite_android. Both they and From d69268d81aa34bffcdbc9e88d259acfd843d8fbb Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 15:47:05 -0700 Subject: [PATCH 055/174] Tests/Android: fix the dead guard that silently disabled the on-device conformance addons `if(JSR_NODE_API_HARNESS_SRC)` guarded the NODE_API_AVAILABLE_NATIVE_TESTS definition, but the variable stopped being set once the harness sources became unconditional (the engine-specific `#ifdef`s they needed are now JSR_NAPI_ENGINE_* compile definitions, so they build for every engine). The guard was therefore always false: the define was never emitted, and Shared.cpp ran no Node-API conformance addons at all on device. Both Android jobs were green because the suite was empty, not because it passed. Gate on the engine allow-list directly instead. Android now runs the addons again: 20 tests / 18 passed / 2 intentional skips on both V8 and JavaScriptCore. --- .../Android/app/src/main/cpp/CMakeLists.txt | 36 ++++++++----------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index dd2e0582..fd783ee0 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -85,29 +85,23 @@ target_link_libraries(UnitTestsJNI if(ANDROID) target_link_libraries(UnitTestsJNI PRIVATE dl) endif() -# The v1-v5 suite + v6 instance_data run on both Android engines. BigInt runs for real on V8; on -# jsc-android (~2020) the eval-based BigInt shim isn't green yet on-device (the in-process runner gives -# no error detail; macOS JSC + V8 both pass test_bigint), so it's gated to V8 here and tracked as a -# follow-up. Keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in Tests/NodeApi/CMakeLists.txt. -if(JSR_NODE_API_HARNESS_SRC) +# The on-device conformance addons, per engine -- keep in sync with JSR_NODE_API_NATIVE_TEST_DIRS in +# Tests/NodeApi/CMakeLists.txt. This is an ALLOW-list: only engines whose v6/v7 surface is actually +# implemented and exercised run these. A backend added upstream later (e.g. QuickJS, which has +# napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted in deliberately +# rather than inheriting them by default. +# +set(JSR_NODE_API_HARNESS_ENGINES V8 JavaScriptCore) +if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_HARNESS_ENGINES) set(_jsr_node_api_tests - "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free") - - # v6/v7 suites, per engine -- keep in sync with the allow-list in Tests/NodeApi/CMakeLists.txt. Only - # engines whose v6/v7 surface is actually implemented run these; a backend added upstream later (e.g. - # QuickJS, which has napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted - # in deliberately rather than inheriting them by default. - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" OR NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") - string(APPEND _jsr_node_api_tests ",test_instance_data") - # BigInt runs for real on V8; jsc-android (~2020) has no BigInt at all (its parser rejects `0n`), - # so it runs the ENOTSUP feature-detection fallback instead. - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") - string(APPEND _jsr_node_api_tests ",test_bigint") - else() - string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") - endif() + "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") + # BigInt runs for real on V8; jsc-android r250231 has no BigInt at all (its parser rejects `0n`), + # so it runs the ENOTSUP feature-detection fallback instead. + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") + string(APPEND _jsr_node_api_tests ",test_bigint") + else() + string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") endif() - target_compile_definitions(UnitTestsJNI PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") endif() From 9924974f323417e78b32b0381bcbb2e3f0288244 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 15:47:22 -0700 Subject: [PATCH 056/174] Core/Node-API: pin jsc-android to r294992, the newest build, which has BigInt jsc-android's `latest` tag is still 250231.0.0 (WebKit r250230, Sept 2019), which compiles BigInt behind the `useBigInt` runtime option, defaulted off -- so its parser rejects `0n` and the standard test_bigint cannot even be parsed. The `next` tag, 294992.0.0 (WebKit r294992, July 2022), is the newest published build and has BigInt enabled by default. Verified on-device (arm64-v8a, API 29) rather than inferred: r250231 r294992 typeof BigInt undefined function typeof BigInt(1) ReferenceError bigint typeof 0n SyntaxError bigint BigInt.asIntN / asUintN ReferenceError function / function BigInt.asUintN(64, -1n) SyntaxError 18446744073709551615 BigInt64Array undefined function ArrayBuffer.prototype.transfer undefined undefined structuredClone undefined undefined So Android JavaScriptCore now runs the real test_bigint instead of the ENOTSUP test_bigint_unsupported fallback; Chakra keeps the fallback. napi_detach_arraybuffer stays feature-detected/ENOTSUP on Android: neither build has ArrayBuffer.prototype.transfer, which is the only public detach path, and that is a hard limit of the newest jsc-android. Two mechanical consequences of the bump: r294992 publishes only the `-intl` variant, so the AAR path changes, and it statically links libc++ (no libc++_shared.so DT_NEEDED, unlike r250231), removing an ABI coupling. Full on-device suite, both engines: 20 tests, 18 passed, 2 intentional skips, 0 failures. --- Core/Node-API/CMakeLists.txt | 6 +++++- Core/Node-API/package-jsc.json | 2 +- Tests/NodeApi/CMakeLists.txt | 8 ++++---- .../Android/app/src/main/cpp/CMakeLists.txt | 15 ++++----------- 4 files changed, 14 insertions(+), 17 deletions(-) diff --git a/Core/Node-API/CMakeLists.txt b/Core/Node-API/CMakeLists.txt index 9cb3e384..fbeb6c61 100644 --- a/Core/Node-API/CMakeLists.txt +++ b/Core/Node-API/CMakeLists.txt @@ -70,7 +70,11 @@ if(NAPI_BUILD_ABI) if(ANDROID) set(V8_PACKAGE_NAME "jsc-android") set(JSC_ANDROID_DIR "${CMAKE_CURRENT_BINARY_DIR}/${V8_PACKAGE_NAME}") - napi_install_android_package(jsc "dist/org/webkit/android-jsc" ${JSC_ANDROID_DIR}) + # r294992 is the newest jsc-android build (dist-tag `next`; `latest` is still the 2019 + # r250231). It is the first with BigInt enabled by default -- r250231 gates BigInt behind + # the `useBigInt` runtime option, off, so its parser rejects `0n`. r294992 publishes only + # the `-intl` variant, and statically links libc++ (no libc++_shared.so dependency). + napi_install_android_package(jsc "dist/org/webkit/android-jsc-intl" ${JSC_ANDROID_DIR}) # Add `JavaScriptCore` prefix to the include path file(RENAME "${JSC_ANDROID_DIR}/include" "${JSC_ANDROID_DIR}/JavaScriptCore") diff --git a/Core/Node-API/package-jsc.json b/Core/Node-API/package-jsc.json index d9f70a7a..70703a85 100644 --- a/Core/Node-API/package-jsc.json +++ b/Core/Node-API/package-jsc.json @@ -1,5 +1,5 @@ { "dependencies": { - "jsc-android": "250231.0.0" + "jsc-android": "294992.0.0" } } diff --git a/Tests/NodeApi/CMakeLists.txt b/Tests/NodeApi/CMakeLists.txt index 9a337b33..1843152a 100644 --- a/Tests/NodeApi/CMakeLists.txt +++ b/Tests/NodeApi/CMakeLists.txt @@ -30,10 +30,10 @@ set(JSR_NODE_API_V6_V7_ENGINES V8 JavaScriptCore Chakra) if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_V6_V7_ENGINES) list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_instance_data) # BigInt: the real conformance test where the engine has BigInt; an ENOTSUP feature-detection - # fallback where it doesn't -- the Win10 OS Chakra, and jsc-android (~2020), whose parser rejects - # `0n` literals so the standard test_bigint can't even be parsed there. - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Chakra" OR - (NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore" AND ANDROID)) + # fallback where it doesn't -- the Win10 OS Chakra. (jsc-android r250231 also lacked BigInt: it + # gates the feature behind the `useBigInt` runtime option, off, so its parser rejects `0n` and the + # standard test_bigint can't even be parsed. r294992, which we now pin, enables it by default.) + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "Chakra") list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_bigint_unsupported) else() list(APPEND JSR_NODE_API_NATIVE_TEST_DIRS test_bigint) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index fd783ee0..972f1fa0 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -91,19 +91,12 @@ endif() # napi_create_bigint_int64 but no napi_add_finalizer and no *_words) must be opted in deliberately # rather than inheriting them by default. # +# The v1-v5 suite, v6 instance_data, and BigInt all run on both Android engines: V8, and +# JavaScriptCore now that jsc-android is pinned to r294992 (BigInt on by default; r250231 gated it off). set(JSR_NODE_API_HARNESS_ENGINES V8 JavaScriptCore) if(NAPI_JAVASCRIPT_ENGINE IN_LIST JSR_NODE_API_HARNESS_ENGINES) - set(_jsr_node_api_tests - "2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data") - # BigInt runs for real on V8; jsc-android r250231 has no BigInt at all (its parser rejects `0n`), - # so it runs the ENOTSUP feature-detection fallback instead. - if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") - string(APPEND _jsr_node_api_tests ",test_bigint") - else() - string(APPEND _jsr_node_api_tests ",test_bigint_unsupported") - endif() - target_compile_definitions(UnitTestsJNI - PRIVATE NODE_API_AVAILABLE_NATIVE_TESTS="${_jsr_node_api_tests}") + target_compile_definitions(UnitTestsJNI PRIVATE + NODE_API_AVAILABLE_NATIVE_TESTS="2_function_arguments,3_callbacks,4_object_factory,5_function_factory,test_reference_double_free,test_instance_data,test_bigint") endif() # The conformance addons are built as standalone SHARED lib.so by Tests/NodeApi/CMakeLists.txt, From 9a9e06c5c4c9db1f137a677b95e60251bd271742 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 15:58:23 -0700 Subject: [PATCH 057/174] JSC: resolve BigInt and ArrayBuffer detach through intrinsics captured at env init Two independent problems in the same code, both about reaching JS intrinsics from the C entry points. 1. Every BigInt entry point resolved its intrinsics on the live global object, once per call: BigIntLow64 re-read `BigInt` and `BigInt.asIntN`/`asUintN`, BigIntToString read `toString` off the boxed value (so through BigInt.prototype), and the create path evaluated a `BigInt("...")` source string. napi_detach_arraybuffer and napi_is_detached_arraybuffer did the same with `transfer` and `detached`. All of those are reachable from script, so a page could replace them and steer an addon's napi_*_bigint_* results -- the invariant #116 established for napi_call_function with a cached Function.prototype.call, not carried through to these. Capture them once at env construction instead, before any user script can run: the constructor, asIntN/asUintN, BigInt.prototype.toString, a `(v) => -v` helper (StringToBigInt accepts a sign only on decimal literals, so the hex words path cannot spell a negative value), ArrayBuffer.prototype.transfer, and the `detached` getter out of its property descriptor. The create path now calls the captured constructor rather than evaluating source, which also drops a parse per BigInt created. Capturing by property lookup doubles as the feature probe, replacing the eval probe: on an engine without BigInt the lookups just fail. That matters because a probe containing a `0n` literal is a SyntaxError -- not a false result -- on jsc-android r250231. NodeApi.BigIntIgnoresMonkeyPatchedIntrinsics covers this. Verified it fails against the old lookup (returns the patched 1234, lossless false) and passes with the fix, on both the C API and the fallback path. 2. The BigInt C API guards were wrong on two axes, verified by compiling against each SDK rather than reading the annotations: * `#if defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && >= 150000` is false on every non-macOS Apple SDK, so the whole fast path was compiled out of iOS and visionOS builds -- including iOS 18.3 and visionOS 26.1, where the API is available. visionOS additionally reports __IPHONE_OS_VERSION_MAX_ALLOWED as 17.0, so it needs a clause of its own. * `__builtin_available(macOS 15.0, *)` does not guard iOS or visionOS at all: the `*` asserts availability on unlisted platforms. Had the `#if` been "fixed" without this, an iOS 17 deployment would have called a null weak symbol. clang confirms it -- the call still warns as unguarded under that form at iOS 17 / visionOS 1. Both are replaced by one JSR_JSC_HAS_BIGINT_C_API macro pair naming every platform. Compiles clean and takes the intended path at macOS 13/15, iOS 17/18.3, visionOS 1/26.1 and tvOS 18. Also makes deinit_symbol null-safe: the intrinsics are null on an engine without BigInt, and it unprotected unconditionally. Verified: macOS JavaScriptCore 13/13 UnitTests and 15/16 conformance (1 quarantined), on both the C API path and with it forced off; Android arm64 JavaScriptCore and V8 21 tests / 19 passed / 2 intentional skips each. --- .../Source/js_native_api_javascriptcore.cc | 257 ++++++++++++++---- .../Source/js_native_api_javascriptcore.h | 31 ++- Tests/UnitTests/Shared/Shared.cpp | 58 ++++ 3 files changed, 286 insertions(+), 60 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 467e2434..66cd7e91 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -1,4 +1,33 @@ #include "js_native_api_javascriptcore.h" + +// The JavaScriptCore BigInt C API (JSBigIntCreateWith*, JSValueIsBigInt, kJSTypeBigInt) is annotated +// API_AVAILABLE(macos(15.0), ios(18.0)); clang derives visionOS 2.0 and tvOS 18.0 from the iOS clause. +// Two things this guard has to get right, both verified by compiling against each SDK: +// +// * __MAC_OS_X_VERSION_MAX_ALLOWED is undefined on non-macOS Apple SDKs, so testing it alone +// compiles the fast path out of every iOS and visionOS build. visionOS additionally reports +// __IPHONE_OS_VERSION_MAX_ALLOWED as 17.0, so it needs its own clause. +// * __builtin_available(macOS 15.0, *) does NOT guard iOS or visionOS -- the `*` wildcard asserts +// availability on unlisted platforms, so on iOS 17 it leaves the call unguarded (a null weak +// symbol at runtime). Every platform we ship must be named explicitly. +// +// Below the floor (macOS 13, and iOS/visionOS builds deployed under the annotated versions) the +// BigIntFromString / BigIntToString intrinsic path handles BigInt instead; it is the only path on +// Android, where no jsc-android build exposes the C API at all. +#if defined(__APPLE__) +#include +#if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000) || \ + (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 180000) || \ + (defined(__TV_OS_VERSION_MAX_ALLOWED) && __TV_OS_VERSION_MAX_ALLOWED >= 180000) || \ + (defined(__VISION_OS_VERSION_MAX_ALLOWED) && __VISION_OS_VERSION_MAX_ALLOWED >= 20000) +#define JSR_JSC_HAS_BIGINT_C_API 1 +#endif +#endif + +#ifdef JSR_JSC_HAS_BIGINT_C_API +#define JSR_JSC_BIGINT_C_API_AVAILABLE() \ + __builtin_available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, *) +#endif #include #include #include @@ -844,7 +873,9 @@ void napi_env__::init_symbol(JSValueRef &symbol, const char *description) { } void napi_env__::deinit_symbol(JSValueRef symbol) { - JSValueUnprotect(context, symbol); + if (symbol != nullptr) { + JSValueUnprotect(context, symbol); + } } void napi_env__::init_function_prototype_call() { @@ -872,17 +903,119 @@ void napi_env__::init_is_bigint_function() { } } -void napi_env__::init_bigint_supported() { - // Detect BigInt once at env init. jsc-android (~2020) ships without BigInt -- its parser even rejects - // `0n` literals -- so the eval/C-API BigInt paths must feature-detect-fail there. `typeof BigInt` - // parses on every JSC (no literal syntax), and BigInt(1) confirms the global is actually functional. - JSStringRef script = JSStringCreateWithUTF8CString( - "(function () { try { return typeof BigInt === 'function' && typeof BigInt(1) === 'bigint'; }" - " catch (e) { return false; } })()"); +void napi_env__::init_bigint_intrinsics() { + // Capture the BigInt intrinsics once, at env init, for the same reason as + // init_function_prototype_call: nothing on the BigInt path may resolve a name through the live + // global object, where user script can replace `BigInt`, `BigInt.asIntN/asUintN` or + // `BigInt.prototype.toString` and steer every napi_*_bigint_* call through its own code. + // + // This doubles as the feature probe. jsc-android r250231 (WebKit r250230) compiles BigInt behind + // the `useBigInt` runtime option, defaulted off: `BigInt` is simply absent and the parser rejects + // `0n`, so every lookup below fails and bigint_supported stays false. Probing by property lookup + // rather than by evaluating a literal is deliberate -- a `0n` in the probe source would be a + // SyntaxError on such a build, not a false result. + auto get = [this](JSValueRef holder, const char* name) -> JSValueRef { + if (holder == nullptr) { + return nullptr; + } + JSValueRef exception = nullptr; + JSObjectRef holder_obj = JSValueToObject(context, holder, &exception); + if (exception != nullptr || holder_obj == nullptr) { + return nullptr; + } + JSStringRef key = JSStringCreateWithUTF8CString(name); + JSValueRef value = JSObjectGetProperty(context, holder_obj, key, &exception); + JSStringRelease(key); + return exception == nullptr ? value : nullptr; + }; + auto is_callable = [this](JSValueRef value) { + if (value == nullptr || !JSValueIsObject(context, value)) { + return false; + } + JSObjectRef obj = JSValueToObject(context, value, nullptr); + return obj != nullptr && JSObjectIsFunction(context, obj); + }; + + JSValueRef ctor = get(JSContextGetGlobalObject(context), "BigInt"); + if (!is_callable(ctor)) { + return; // no BigInt on this engine; bigint_supported stays false + } + JSValueRef as_int_n = get(ctor, "asIntN"); + JSValueRef as_uint_n = get(ctor, "asUintN"); + JSValueRef to_string = get(get(ctor, "prototype"), "toString"); + if (!is_callable(as_int_n) || !is_callable(as_uint_n) || !is_callable(to_string)) { + return; + } + + // Unary minus on a BigInt primitive is a spec operation with no interceptable hook, so a helper + // captured here stays honest for the life of the env. It is needed because StringToBigInt accepts + // a sign only on decimal literals -- BigInt("-0x...") is a SyntaxError -- and the words path below + // builds a hex string. + JSStringRef negate_src = JSStringCreateWithUTF8CString("(function (v) { return -v; })"); + JSValueRef exception = nullptr; + JSValueRef negate = JSEvaluateScript(context, negate_src, nullptr, nullptr, 0, &exception); + JSStringRelease(negate_src); + if (exception != nullptr || !is_callable(negate)) { + return; + } + + bigint_constructor = ctor; + bigint_as_int_n = as_int_n; + bigint_as_uint_n = as_uint_n; + bigint_prototype_to_string = to_string; + bigint_negate = negate; + for (JSValueRef v : {bigint_constructor, bigint_as_int_n, bigint_as_uint_n, + bigint_prototype_to_string, bigint_negate}) { + JSValueProtect(context, v); + } + bigint_supported = true; +} + +void napi_env__::init_arraybuffer_intrinsics() { + // ArrayBuffer.prototype.transfer() (ES2024) is the only public detach path -- the JavaScriptCore C + // API has no detach entry point at all -- and `.detached` is an accessor on the same prototype. + // Both are reachable from script, so capture them here rather than looking them up per call. JSValueRef exception = nullptr; - JSValueRef result = JSEvaluateScript(context, script, nullptr, nullptr, 0, &exception); - JSStringRelease(script); - bigint_supported = (exception == nullptr) && (result != nullptr) && JSValueToBoolean(context, result); + JSObjectRef global = JSContextGetGlobalObject(context); + JSValueRef ctor = JSObjectGetProperty(context, global, JSString("ArrayBuffer"), &exception); + if (exception != nullptr) { + return; + } + JSObjectRef ctor_obj = JSValueToObject(context, ctor, &exception); + if (exception != nullptr || ctor_obj == nullptr) { + return; + } + JSValueRef prototype = JSObjectGetProperty(context, ctor_obj, JSString("prototype"), &exception); + if (exception != nullptr) { + return; + } + JSObjectRef prototype_obj = JSValueToObject(context, prototype, &exception); + if (exception != nullptr || prototype_obj == nullptr) { + return; + } + + JSValueRef transfer = JSObjectGetProperty(context, prototype_obj, JSString("transfer"), &exception); + if (exception == nullptr && transfer != nullptr && JSValueIsObject(context, transfer)) { + JSObjectRef transfer_obj = JSValueToObject(context, transfer, nullptr); + if (transfer_obj != nullptr && JSObjectIsFunction(context, transfer_obj)) { + arraybuffer_transfer = transfer; + JSValueProtect(context, arraybuffer_transfer); + } + } + + // `detached` is an accessor, so the getter has to come out of its property descriptor. Reaching + // Object.getOwnPropertyDescriptor through script is safe at env-init time, before any user code + // has run; napi_is_detached_arraybuffer then calls the captured getter directly. + JSStringRef src = JSStringCreateWithUTF8CString( + "(function () { var d = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'detached');" + " return (d && typeof d.get === 'function') ? d.get : null; })()"); + exception = nullptr; + JSValueRef getter = JSEvaluateScript(context, src, nullptr, nullptr, 0, &exception); + JSStringRelease(src); + if (exception == nullptr && getter != nullptr && JSValueIsObject(context, getter)) { + arraybuffer_detached_getter = getter; + JSValueProtect(context, arraybuffer_detached_getter); + } } // Warning: Keep in-sync with napi_status enum @@ -1588,15 +1721,16 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) case kJSTypeNumber: *result = napi_number; break; case kJSTypeString: *result = napi_string; break; case kJSTypeSymbol: *result = napi_symbol; break; -#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 - // kJSTypeBigInt is macOS 15+/iOS 18+. On older JSC (e.g. jsc-android) a BigInt falls to the - // default branch; a typeof-based fallback is added with the Android bring-up. +#ifdef JSR_JSC_HAS_BIGINT_C_API + // kJSTypeBigInt is only produced by a JSC at/above the C API floor. Where the SDK knows the + // enumerator but the deployed OS is older, JSValueGetType simply never returns it and the + // predicate below catches the BigInt instead -- so this case needs no __builtin_available. case kJSTypeBigInt: *result = napi_bigint; break; #endif default: { -#if !(defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000) - // Older JSC (e.g. jsc-android) does not report kJSTypeBigInt through JSValueGetType, so detect - // BigInt with the cached `typeof v === 'bigint'` predicate before treating value as an object. + // JSC below the C API floor -- and every jsc-android build -- does not report kJSTypeBigInt + // through JSValueGetType, so detect BigInt with the `typeof v === 'bigint'` predicate captured + // at env init before treating value as an object. if (env->is_bigint_function != nullptr) { JSValueRef arg = ToJSValue(value); JSValueRef exception = nullptr; @@ -1609,7 +1743,6 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) } } } -#endif JSObjectRef object{ToJSObject(env, value)}; // Consult JSObjectIsConstructor in addition to JSObjectIsFunction: some JSC builds (e.g. // libjavascriptcoregtk) report constructors created via JSObjectMakeConstructor -- such as @@ -1791,27 +1924,25 @@ napi_status napi_bigint_unsupported(napi_env env) { return napi_set_last_error(env, napi_pending_exception); } -napi_status BigIntLow64(napi_env env, napi_value value, const char* method, JSValueRef* low) { +// BigInt.asIntN(64, value) / BigInt.asUintN(64, value) through the intrinsic captured at env init. +napi_status BigIntLow64(napi_env env, napi_value value, JSValueRef as_n, JSValueRef* low) { if (!env->bigint_supported) { return napi_bigint_unsupported(env); } - JSObjectRef global = JSContextGetGlobalObject(env->context); JSValueRef exception{}; - JSValueRef bigIntCtor = JSObjectGetProperty(env->context, global, JSString("BigInt"), &exception); - CHECK_JSC(env, exception); - JSObjectRef bigIntObj = JSValueToObject(env->context, bigIntCtor, &exception); + JSObjectRef as_n_fn = JSValueToObject(env->context, as_n, &exception); CHECK_JSC(env, exception); - JSValueRef fn = JSObjectGetProperty(env->context, bigIntObj, JSString(method), &exception); - CHECK_JSC(env, exception); - JSObjectRef fnObj = JSValueToObject(env->context, fn, &exception); + JSObjectRef bigint_ctor = JSValueToObject(env->context, env->bigint_constructor, &exception); CHECK_JSC(env, exception); JSValueRef args[2] = {JSValueMakeNumber(env->context, 64), ToJSValue(value)}; - *low = JSObjectCallAsFunction(env->context, fnObj, bigIntObj, 2, args, &exception); + *low = JSObjectCallAsFunction(env->context, as_n_fn, bigint_ctor, 2, args, &exception); CHECK_JSC(env, exception); return napi_ok; } -// value.toString(radix) for a BigInt primitive (boxes the primitive, then calls toString). +// BigInt.prototype.toString.call(value, radix), through the intrinsic captured at env init: the +// boxed value supplies `this` only, so a user-installed `toString` own/prototype property cannot +// intercept the conversion. napi_status BigIntToString(napi_env env, napi_value value, int radix, std::string* out) { if (!env->bigint_supported) { return napi_bigint_unsupported(env); @@ -1819,9 +1950,7 @@ napi_status BigIntToString(napi_env env, napi_value value, int radix, std::strin JSValueRef exception{}; JSObjectRef boxed = JSValueToObject(env->context, ToJSValue(value), &exception); CHECK_JSC(env, exception); - JSValueRef toString = JSObjectGetProperty(env->context, boxed, JSString("toString"), &exception); - CHECK_JSC(env, exception); - JSObjectRef toStringFn = JSValueToObject(env->context, toString, &exception); + JSObjectRef toStringFn = JSValueToObject(env->context, env->bigint_prototype_to_string, &exception); CHECK_JSC(env, exception); JSValueRef radixArg = JSValueMakeNumber(env->context, radix); JSValueRef str = JSObjectCallAsFunction(env->context, toStringFn, boxed, 1, &radixArg, &exception); @@ -1836,17 +1965,29 @@ napi_status BigIntToString(napi_env env, napi_value value, int radix, std::strin return napi_ok; } -// Construct a BigInt from a (controlled) JS source expression; used as the create path where the C -// API is unavailable. Only embeds numeric/hex literals -> no injection surface. -napi_status BigIntFromExpr(napi_env env, const std::string& expr, napi_value* result) { +// BigInt(text) -- optionally negated -- through the constructor captured at env init. This is the +// create path wherever the BigInt C API is unavailable (every jsc-android build, and Apple platforms +// below the macOS 15 / iOS 18 / visionOS 2 floor). It calls the captured intrinsic rather than +// evaluating a `BigInt("...")` source string: an eval would re-resolve the global `BigInt` on a live +// context, and would also pay a parse per BigInt created. +napi_status BigIntFromString(napi_env env, const std::string& text, bool negate, napi_value* result) { if (!env->bigint_supported) { return napi_bigint_unsupported(env); } - JSStringRef src = JSStringCreateWithUTF8CString(expr.c_str()); JSValueRef exception{}; - JSValueRef big = JSEvaluateScript(env->context, src, nullptr, nullptr, 0, &exception); - JSStringRelease(src); + JSObjectRef ctor = JSValueToObject(env->context, env->bigint_constructor, &exception); + CHECK_JSC(env, exception); + JSStringRef js_text = JSStringCreateWithUTF8CString(text.c_str()); + JSValueRef arg = JSValueMakeString(env->context, js_text); + JSStringRelease(js_text); + JSValueRef big = JSObjectCallAsFunction(env->context, ctor, nullptr, 1, &arg, &exception); CHECK_JSC(env, exception); + if (negate) { + JSObjectRef negate_fn = JSValueToObject(env->context, env->bigint_negate, &exception); + CHECK_JSC(env, exception); + big = JSObjectCallAsFunction(env->context, negate_fn, nullptr, 1, &big, &exception); + CHECK_JSC(env, exception); + } *result = ToNapi(big); return napi_ok; } @@ -1856,8 +1997,8 @@ napi_status BigIntFromExpr(napi_env env, const std::string& expr, napi_value* re napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); -#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 - if (__builtin_available(macOS 15.0, *)) { +#ifdef JSR_JSC_HAS_BIGINT_C_API + if (JSR_JSC_BIGINT_C_API_AVAILABLE()) { JSValueRef exception{}; JSValueRef big = JSBigIntCreateWithInt64(env->context, value, &exception); CHECK_JSC(env, exception); @@ -1865,14 +2006,15 @@ napi_status napi_create_bigint_int64(napi_env env, int64_t value, napi_value* re return napi_ok; } #endif - return BigIntFromExpr(env, "BigInt(\"" + std::to_string(value) + "\")", result); + // StringToBigInt accepts a leading sign on a decimal literal, so INT64_MIN round-trips as-is. + return BigIntFromString(env, std::to_string(value), /*negate*/ false, result); } napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); -#if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && __MAC_OS_X_VERSION_MAX_ALLOWED >= 150000 - if (__builtin_available(macOS 15.0, *)) { +#ifdef JSR_JSC_HAS_BIGINT_C_API + if (JSR_JSC_BIGINT_C_API_AVAILABLE()) { JSValueRef exception{}; JSValueRef big = JSBigIntCreateWithUInt64(env->context, value, &exception); CHECK_JSC(env, exception); @@ -1880,7 +2022,8 @@ napi_status napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* return napi_ok; } #endif - return BigIntFromExpr(env, "BigInt(\"" + std::to_string(value) + "\")", result); + // StringToBigInt accepts a leading sign on a decimal literal, so INT64_MIN round-trips as-is. + return BigIntFromString(env, std::to_string(value), /*negate*/ false, result); } napi_status napi_create_bigint_words(napi_env env, @@ -1912,8 +2055,7 @@ napi_status napi_create_bigint_words(napi_env env, if (hex.empty()) { hex = "0"; } - std::string expr = (sign_bit ? "-BigInt(\"0x" : "BigInt(\"0x") + hex + "\")"; - return BigIntFromExpr(env, expr, result); + return BigIntFromString(env, "0x" + hex, /*negate*/ sign_bit != 0, result); } napi_status napi_get_value_bigint_int64(napi_env env, @@ -1925,7 +2067,7 @@ napi_status napi_get_value_bigint_int64(napi_env env, CHECK_ARG(env, result); CHECK_ARG(env, lossless); JSValueRef low{}; - CHECK_NAPI(BigIntLow64(env, value, "asIntN", &low)); + CHECK_NAPI(BigIntLow64(env, value, env->bigint_as_int_n, &low)); std::string decimal; CHECK_NAPI(BigIntToString(env, ToNapi(low), 10, &decimal)); *result = static_cast(strtoll(decimal.c_str(), nullptr, 10)); @@ -1942,7 +2084,7 @@ napi_status napi_get_value_bigint_uint64(napi_env env, CHECK_ARG(env, result); CHECK_ARG(env, lossless); JSValueRef low{}; - CHECK_NAPI(BigIntLow64(env, value, "asUintN", &low)); + CHECK_NAPI(BigIntLow64(env, value, env->bigint_as_uint_n, &low)); std::string decimal; CHECK_NAPI(BigIntToString(env, ToNapi(low), 10, &decimal)); *result = static_cast(strtoull(decimal.c_str(), nullptr, 10)); @@ -1988,17 +2130,16 @@ napi_status napi_detach_arraybuffer(napi_env env, napi_value arraybuffer) { CHECK_ENV(env); CHECK_ARG(env, arraybuffer); JSObjectRef ab = ToJSObject(env, arraybuffer); - JSValueRef exception{}; - JSValueRef transfer = JSObjectGetProperty(env->context, ab, JSString("transfer"), &exception); - CHECK_JSC(env, exception); - if (!JSValueIsObject(env->context, transfer)) { - // ArrayBuffer.prototype.transfer() (ES2024) is the only public-API detach path; if the engine - // predates it (older jsc-android), throw a catchable ENOTSUP so JS land can polyfill. + if (env->arraybuffer_transfer == nullptr) { + // ArrayBuffer.prototype.transfer() (ES2024) is the only public detach path, and the JSC C API has + // no detach at all. Engines below it -- every jsc-android build, and Apple platforms under + // macOS 14.4 / iOS 17.4 -- get a catchable ENOTSUP so JS land can polyfill. napi_throw_error(env, "ENOTSUP", "ArrayBuffer detach is not supported by the underlying JavaScript engine."); return napi_set_last_error(env, napi_pending_exception); } - JSObjectRef transferFn = JSValueToObject(env->context, transfer, &exception); + JSValueRef exception{}; + JSObjectRef transferFn = JSValueToObject(env->context, env->arraybuffer_transfer, &exception); CHECK_JSC(env, exception); JSObjectCallAsFunction(env->context, transferFn, ab, 0, nullptr, &exception); // detaches `ab` CHECK_JSC(env, exception); @@ -2011,9 +2152,11 @@ napi_status napi_is_detached_arraybuffer(napi_env env, napi_value arraybuffer, b CHECK_ARG(env, result); JSObjectRef ab = ToJSObject(env, arraybuffer); JSValueRef exception{}; - JSValueRef detached = JSObjectGetProperty(env->context, ab, JSString("detached"), &exception); - CHECK_JSC(env, exception); - if (JSValueIsBoolean(env->context, detached)) { + if (env->arraybuffer_detached_getter != nullptr) { + JSObjectRef getter = JSValueToObject(env->context, env->arraybuffer_detached_getter, &exception); + CHECK_JSC(env, exception); + JSValueRef detached = JSObjectCallAsFunction(env->context, getter, ab, 0, nullptr, &exception); + CHECK_JSC(env, exception); *result = JSValueToBoolean(env->context, detached); } else { // Pre-ES2024 fallback: a detached buffer has no backing store. diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 2d16968c..a017d9a7 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -27,9 +27,25 @@ struct napi_env__ { JSValueRef reference_info_symbol{}; JSValueRef wrapper_info_symbol{}; JSValueRef function_prototype_call{}; - JSValueRef is_bigint_function{}; + + // BigInt intrinsics, captured once at env init -- before any user script can run -- so the BigInt + // entry points never resolve `BigInt`, `BigInt.asIntN/asUintN` or `BigInt.prototype.toString` + // through the (monkey-patchable) global object on a live context. Same invariant as + // function_prototype_call above. + JSValueRef is_bigint_function{}; // (v) => typeof v === 'bigint' + JSValueRef bigint_constructor{}; // BigInt + JSValueRef bigint_as_int_n{}; // BigInt.asIntN + JSValueRef bigint_as_uint_n{}; // BigInt.asUintN + JSValueRef bigint_prototype_to_string{};// BigInt.prototype.toString + JSValueRef bigint_negate{}; // (v) => -v bool bigint_supported{false}; + // ArrayBuffer detach intrinsics, captured at env init for the same reason. Both stay null on an + // engine without ES2024 ArrayBuffer.prototype.transfer / .detached (every jsc-android build, and + // Apple platforms below macOS 14.4 / iOS 17.4). + JSValueRef arraybuffer_transfer{}; // ArrayBuffer.prototype.transfer + JSValueRef arraybuffer_detached_getter{};// get ArrayBuffer.prototype.detached + // Escapable scope bookkeeping: token -> whether that scope has escaped. Values // are rooted by the engine rather than by a scope here, so this exists only to // honour the one-escape-per-scope rule and to reject tokens that are not open. @@ -49,7 +65,8 @@ struct napi_env__ { init_symbol(wrapper_info_symbol, "BabylonNative_WrapperInfo"); init_function_prototype_call(); init_is_bigint_function(); - init_bigint_supported(); + init_bigint_intrinsics(); + init_arraybuffer_intrinsics(); } ~napi_env__() { @@ -58,6 +75,13 @@ struct napi_env__ { instance_data_finalize_cb(this, instance_data, instance_data_finalize_hint); } deinit_refs(); + deinit_symbol(arraybuffer_detached_getter); + deinit_symbol(arraybuffer_transfer); + deinit_symbol(bigint_negate); + deinit_symbol(bigint_prototype_to_string); + deinit_symbol(bigint_as_uint_n); + deinit_symbol(bigint_as_int_n); + deinit_symbol(bigint_constructor); deinit_symbol(is_bigint_function); deinit_symbol(function_prototype_call); deinit_symbol(wrapper_info_symbol); @@ -84,7 +108,8 @@ struct napi_env__ { void init_symbol(JSValueRef& symbol, const char* description); void init_function_prototype_call(); void init_is_bigint_function(); - void init_bigint_supported(); + void init_bigint_intrinsics(); + void init_arraybuffer_intrinsics(); void deinit_symbol(JSValueRef symbol); }; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 2e35678f..d8a52b98 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -520,6 +520,64 @@ TEST(AppRuntime, DestroyDoesNotDeadlock) testThread.join(); } +// N-API results must not depend on anything reachable from script. The JavaScriptCore backend has no +// BigInt C API below macOS 15 / iOS 18 / visionOS 2, and none at all on Android, so it reaches BigInt +// through JS intrinsics; those are captured at env init (like Function.prototype.call) precisely so a +// page that replaces `BigInt`, `BigInt.asIntN/asUintN` or `BigInt.prototype.toString` cannot steer an +// addon's napi_*_bigint_* calls through its own code. Before that, every one of these entry points +// re-resolved the name on the live global object, and the create path evaluated a `BigInt("...")` +// source string -- so the patches below each returned an attacker-chosen value. +#if !defined(JSRUNTIMEHOST_NAPI_ENGINE_JSI) +TEST(NodeApi, BigIntIgnoresMonkeyPatchedIntrinsics) +{ + Babylon::AppRuntime runtime{}; + Babylon::ScriptLoader loader{runtime}; + + // Replace every intrinsic the BigInt paths touch, the way user script could. + loader.Eval(R"( + globalThis.__pristine = { BigInt, asIntN: BigInt.asIntN, toString: BigInt.prototype.toString }; + globalThis.BigInt = function () { return globalThis.__pristine.BigInt(1234); }; + globalThis.BigInt.asIntN = function () { return globalThis.__pristine.BigInt(1234); }; + globalThis.BigInt.asUintN = function () { return globalThis.__pristine.BigInt(1234); }; + globalThis.__pristine.BigInt.prototype.toString = function () { return '1234'; }; + )", + ""); + + std::promise done; + struct { bool supported; int64_t roundTripped; bool lossless; napi_valuetype type; } observed{}; + + runtime.Dispatch([&done, &observed](Napi::Env env) { + napi_env nenv{env}; + + napi_value big{nullptr}; + if (napi_create_bigint_int64(nenv, 9007199254740993LL, &big) != napi_ok) + { + // Engine without BigInt (jsc-android r250231, Win10 Chakra): it throws ENOTSUP instead. + napi_value pending{nullptr}; + napi_get_and_clear_last_exception(nenv, &pending); + observed.supported = false; + done.set_value(); + return; + } + observed.supported = true; + napi_typeof(nenv, big, &observed.type); + napi_get_value_bigint_int64(nenv, big, &observed.roundTripped, &observed.lossless); + done.set_value(); + }); + + done.get_future().get(); + + if (!observed.supported) + { + GTEST_SKIP() << "Engine does not support BigInt"; + } + EXPECT_EQ(napi_bigint, observed.type); + // 1234 here would mean a patched intrinsic was consulted. + EXPECT_EQ(9007199254740993LL, observed.roundTripped); + EXPECT_TRUE(observed.lossless); +} +#endif + // The V8JSI Node-API shim does not implement napi_create_dataview / // napi_get_dataview_info (its DataView::New throws "TODO"), so this native test // only builds on the Chakra, V8, and JavaScriptCore backends. The size_t-width From f26825464f07ace98b67a7ef461d4b7ad932a44a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 15:58:31 -0700 Subject: [PATCH 058/174] Core/Node-API: bump the node-addon-api header to NAPI_VERSION 7 js_native_api.h and js_native_api_types.h already default NAPI_VERSION to 7 on this branch, but napi.h still pinned 5 -- and because all three use `#ifndef`, whichever is reached first wins. Every consumer includes (all of Babylon Native, and every node-addon-api addon), so 5 won essentially everywhere: Napi::BigInt, Napi::BigInt64Array, Value::IsBigInt(), GetInstanceData() and Napi::Addon stayed compiled out even though the C entry points behind them are implemented and pass conformance. Found because a test in Tests/UnitTests could not name napi_create_bigint_int64: that translation unit was seeing NAPI_VERSION=5 through napi.h, not the 7 the C headers declare. Note for #229: this makes the three headers agree, it does not decide the policy question. If NAPI_VERSION goes back to 5 with features ungated individually, all three move together. --- Core/Node-API/Include/Shared/napi/napi.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Core/Node-API/Include/Shared/napi/napi.h b/Core/Node-API/Include/Shared/napi/napi.h index 24b044eb..aa590b1b 100644 --- a/Core/Node-API/Include/Shared/napi/napi.h +++ b/Core/Node-API/Include/Shared/napi/napi.h @@ -8,8 +8,13 @@ #ifndef NODE_ADDON_API_DISABLE_NODE_SPECIFIC #define NODE_ADDON_API_DISABLE_NODE_SPECIFIC #endif +// [BABYLON-NATIVE-ADDITION] Keep this in step with js_native_api.h / js_native_api_types.h. The C +// headers already default to 7, but this one is reached first by every consumer that includes +// (all of Babylon Native, and every node-addon-api addon), and #ifndef made it win -- +// so Napi::BigInt, Value::IsBigInt, GetInstanceData and Napi::Addon stayed compiled out even +// though the C entry points behind them were implemented. #ifndef NAPI_VERSION -#define NAPI_VERSION 5 +#define NAPI_VERSION 7 #endif #ifndef NAPI_HAS_THREADS #define NAPI_HAS_THREADS 0 From 2503f2cd1b84c2e0d30f4512e70e84cabf8272a7 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 16:01:33 -0700 Subject: [PATCH 059/174] JSC: keep the napi_typeof BigInt fallback off the object path Dropping the platform #ifdef around the `typeof v === 'bigint'` fallback left it running in napi_typeof's default branch on every engine -- so every napi_typeof of an ordinary object paid a JS call before reaching the object handling, on a very hot path. Probe once at env init whether JSValueGetType actually classifies a BigInt on this engine and OS, and consult the predicate only when it does not. That is also strictly better than gating on the SDK or __builtin_available: the enumerator can be compiled in while the JSC actually deployed never produces it, and the probe asks the engine instead of assuming. macOS JavaScriptCore 13/13 + 15/16 conformance; Android JavaScriptCore 21 tests / 19 passed / 2 intentional skips. --- .../Source/js_native_api_javascriptcore.cc | 18 ++++++++++++++++-- .../Source/js_native_api_javascriptcore.h | 4 ++++ 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 66cd7e91..fd136121 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -969,6 +969,19 @@ void napi_env__::init_bigint_intrinsics() { JSValueProtect(context, v); } bigint_supported = true; + + // Ask the engine directly whether JSValueGetType classifies a BigInt, instead of inferring it from + // the SDK or from __builtin_available. napi_typeof is hot, and this keeps the JS `typeof` fallback + // off the object path everywhere the C API answers. +#ifdef JSR_JSC_HAS_BIGINT_C_API + JSValueRef probe_arg = JSValueMakeNumber(context, 1); + JSObjectRef ctor_obj = JSValueToObject(context, bigint_constructor, nullptr); + exception = nullptr; + JSValueRef probe = JSObjectCallAsFunction(context, ctor_obj, nullptr, 1, &probe_arg, &exception); + if (exception == nullptr && probe != nullptr) { + value_type_reports_bigint = JSValueGetType(context, probe) == kJSTypeBigInt; + } +#endif } void napi_env__::init_arraybuffer_intrinsics() { @@ -1730,8 +1743,9 @@ napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result) default: { // JSC below the C API floor -- and every jsc-android build -- does not report kJSTypeBigInt // through JSValueGetType, so detect BigInt with the `typeof v === 'bigint'` predicate captured - // at env init before treating value as an object. - if (env->is_bigint_function != nullptr) { + // at env init before treating value as an object. Skipped where the engine does classify + // BigInt, so the ordinary object path stays free of a JS call. + if (!env->value_type_reports_bigint && env->is_bigint_function != nullptr) { JSValueRef arg = ToJSValue(value); JSValueRef exception = nullptr; JSObjectRef predicate = JSValueToObject(env->context, env->is_bigint_function, &exception); diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index a017d9a7..6c2cbafa 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -39,6 +39,10 @@ struct napi_env__ { JSValueRef bigint_prototype_to_string{};// BigInt.prototype.toString JSValueRef bigint_negate{}; // (v) => -v bool bigint_supported{false}; + // Whether JSValueGetType actually reports kJSTypeBigInt on this engine+OS. Probed at init rather + // than assumed from the SDK: the enumerator can be compiled in while the deployed JSC never + // produces it. False means napi_typeof has to fall back to the `typeof` predicate. + bool value_type_reports_bigint{false}; // ArrayBuffer detach intrinsics, captured at env init for the same reason. Both stay null on an // engine without ES2024 ArrayBuffer.prototype.transfer / .detached (every jsc-android build, and From 4a3491b3451fd862d89f15df920189b9128e778e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 16:16:42 -0700 Subject: [PATCH 060/174] Tests: cover napi_detach_arraybuffer, the API that defines N-API v7 It had no coverage at all: the upstream conformance test for detach lives in test_typedarray, which needs v9's node_api_basic_env and so cannot be enabled yet. Detach is not uniform across the engines here -- ArrayBuffer.prototype.transfer() (ES2024) is the only public detach path, since the JavaScriptCore C API has no detach entry point -- so the test asserts whichever half of the contract applies: the buffer really detaches, or the failure is a catchable JS error carrying code ENOTSUP rather than a bare napi_status an addon cannot tell from a real error. Both halves are exercised by the matrix: macOS JavaScriptCore and V8 take the detach path, Android JavaScriptCore takes ENOTSUP (neither jsc-android r250231 nor r294992 has transfer -- verified on device). macOS 14/14; Android JavaScriptCore 22 tests / 20 passed / 2 intentional skips. --- Tests/UnitTests/Shared/Shared.cpp | 70 +++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index d8a52b98..ada73cb7 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -578,6 +578,76 @@ TEST(NodeApi, BigIntIgnoresMonkeyPatchedIntrinsics) } #endif +// napi_detach_arraybuffer is the API that defines N-API v7, and its behaviour is not uniform across +// the engines here: ArrayBuffer.prototype.transfer() (ES2024) is the only public detach path -- the +// JavaScriptCore C API has no detach entry point at all -- so an engine without it can only report +// the capability as missing. This asserts both halves of that contract, whichever applies: +// +// detach works V8; JavaScriptCore on macOS 14.4+ / iOS 17.4+ / visionOS 1.1+ +// ENOTSUP thrown JavaScriptCore on older Apple OSes, and every jsc-android build +// (verified on device: r250231 and r294992 both lack transfer) +#if !defined(JSRUNTIMEHOST_NAPI_ENGINE_JSI) +TEST(NodeApi, DetachArrayBufferOrReportsUnsupported) +{ + Babylon::AppRuntime runtime{}; + + std::promise done; + struct + { + bool detachedBefore{true}; + bool detachedAfter{false}; + bool supported{false}; + std::string code; + } observed; + + runtime.Dispatch([&done, &observed](Napi::Env env) { + napi_env nenv{env}; + + Napi::ArrayBuffer buffer{Napi::ArrayBuffer::New(env, 8)}; + napi_value value{buffer}; + + napi_is_detached_arraybuffer(nenv, value, &observed.detachedBefore); + + if (napi_detach_arraybuffer(nenv, value) == napi_ok) + { + observed.supported = true; + napi_is_detached_arraybuffer(nenv, value, &observed.detachedAfter); + } + else + { + // Feature-detected failure must be a catchable JS error carrying code ENOTSUP, not a + // bare napi_status an addon cannot distinguish from a real error. + napi_value pending{nullptr}; + napi_get_and_clear_last_exception(nenv, &pending); + if (pending != nullptr) + { + napi_value code{nullptr}; + if (napi_get_named_property(nenv, pending, "code", &code) == napi_ok) + { + char buffer[32]{}; + size_t written{0}; + napi_get_value_string_utf8(nenv, code, buffer, sizeof(buffer), &written); + observed.code.assign(buffer, written); + } + } + } + done.set_value(); + }); + + done.get_future().get(); + + EXPECT_FALSE(observed.detachedBefore) << "a live ArrayBuffer must not report as detached"; + if (observed.supported) + { + EXPECT_TRUE(observed.detachedAfter) << "napi_detach_arraybuffer returned ok but did not detach"; + } + else + { + EXPECT_EQ("ENOTSUP", observed.code); + } +} +#endif + // The V8JSI Node-API shim does not implement napi_create_dataview / // napi_get_dataview_info (its DataView::New throws "TODO"), so this native test // only builds on the Chakra, V8, and JavaScriptCore backends. The size_t-width From a041fad97dd0411464a865e044135ebc9090282b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 16:33:17 -0700 Subject: [PATCH 061/174] V8: napi_is_detached_arraybuffer reported every ArrayBuffer as detached The body was commented out and replaced with a bare `*result = true;` in #70 ("Update Node-API to latest from node.js"), so the API answered "detached" for every value handed to it, including a freshly created, perfectly live ArrayBuffer. Anything branching on it -- an addon guarding a zero-copy path, or a detach-then-verify sequence -- got the wrong answer with no error to notice. The pinned V8 does declare ArrayBuffer::WasDetached() (v8-array-buffer.h), so the commented-out implementation compiles as written; restore it. Caught by NodeApi.DetachArrayBufferOrReportsUnsupported on Android_V8 and Win32_x64_V8. Also record the napi_status of each napi_is_detached_arraybuffer call in that test, so an engine that fails the query is not mistaken for one that answered "detached". Android arm64 V8: 22 tests / 20 passed / 2 intentional skips. --- Core/Node-API/Source/js_native_api_v8.cc | 5 ++--- Tests/UnitTests/Shared/Shared.cpp | 8 ++++++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_v8.cc b/Core/Node-API/Source/js_native_api_v8.cc index 8105a0bf..a85c6837 100644 --- a/Core/Node-API/Source/js_native_api_v8.cc +++ b/Core/Node-API/Source/js_native_api_v8.cc @@ -3503,8 +3503,7 @@ napi_status NAPI_CDECL napi_is_detached_arraybuffer(napi_env env, v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); - //*result = - // value->IsArrayBuffer() && value.As()->WasDetached(); - *result = true; + *result = + value->IsArrayBuffer() && value.As()->WasDetached(); return napi_clear_last_error(env); } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index ada73cb7..9a6c60e0 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -594,6 +594,8 @@ TEST(NodeApi, DetachArrayBufferOrReportsUnsupported) std::promise done; struct { + napi_status queryBefore{napi_ok}; + napi_status queryAfter{napi_ok}; bool detachedBefore{true}; bool detachedAfter{false}; bool supported{false}; @@ -606,12 +608,12 @@ TEST(NodeApi, DetachArrayBufferOrReportsUnsupported) Napi::ArrayBuffer buffer{Napi::ArrayBuffer::New(env, 8)}; napi_value value{buffer}; - napi_is_detached_arraybuffer(nenv, value, &observed.detachedBefore); + observed.queryBefore = napi_is_detached_arraybuffer(nenv, value, &observed.detachedBefore); if (napi_detach_arraybuffer(nenv, value) == napi_ok) { observed.supported = true; - napi_is_detached_arraybuffer(nenv, value, &observed.detachedAfter); + observed.queryAfter = napi_is_detached_arraybuffer(nenv, value, &observed.detachedAfter); } else { @@ -636,9 +638,11 @@ TEST(NodeApi, DetachArrayBufferOrReportsUnsupported) done.get_future().get(); + ASSERT_EQ(napi_ok, observed.queryBefore) << "napi_is_detached_arraybuffer failed on a live buffer"; EXPECT_FALSE(observed.detachedBefore) << "a live ArrayBuffer must not report as detached"; if (observed.supported) { + ASSERT_EQ(napi_ok, observed.queryAfter) << "napi_is_detached_arraybuffer failed after detach"; EXPECT_TRUE(observed.detachedAfter) << "napi_detach_arraybuffer returned ok but did not detach"; } else From 9de995b99c2f68796779656fa3972c34bb59b396 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:09:48 -0500 Subject: [PATCH 062/174] Tests/NodeApi: drain the child's pipes concurrently in SpawnSync instead of after waitpid Both SpawnSync implementations waited for the child to exit before reading either pipe. A child that writes more than one pipe buffer (16 KiB on macOS, 64 KiB on Linux, 4 KiB for a default Windows anonymous pipe) blocks on write while the parent blocks on wait -- a deadlock that a chatty conformance test can reach. POSIX: close the write ends, then poll() both read ends and service whichever has data until both hit EOF, then waitpid. Windows: the parent's copies of the write handles were only closed after the wait, so ReadFile could see EOF only because the child was already gone; close them immediately after CreateProcess, drain each pipe on its own thread, then wait for the exit code. Addresses the review on #116. --- Tests/NodeApi/child_process.cpp | 387 +++++++++++++------------- Tests/NodeApi/child_process_posix.cpp | 63 +++-- 2 files changed, 235 insertions(+), 215 deletions(-) diff --git a/Tests/NodeApi/child_process.cpp b/Tests/NodeApi/child_process.cpp index 2fd22cd8..e91fff14 100644 --- a/Tests/NodeApi/child_process.cpp +++ b/Tests/NodeApi/child_process.cpp @@ -1,192 +1,197 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. -// -// Windows-specific implementation of the `spawnSync` function for creating -// child processes and capturing their output. This code is designed to work -// with the Windows API and is not portable to other platforms. It uses pipes -// to redirect the standard output and error streams of the child process back -// to the parent process, allowing the parent to read the output and error -// messages generated by the child process. -// -// The `spawnSync` function takes a command and a list of arguments, creates a -// child process to execute the command, and returns a `ProcessResult` structure -// containing the exit status and the captured output and error messages. -// - -#include "child_process.h" - -#include -#include -#include -#include -#include "string_utils.h" - -#ifndef VerifyElseExit -#define VerifyElseExit(condition) \ - do { \ - if (!(condition)) { \ - ExitOnError(#condition); \ - } \ - } while (false) -#endif - -namespace node_api_tests { - -namespace { - -std::string ReadFromPipe(HANDLE pipeHandle); -void ExitOnError(const char* message); - -struct AutoHandle { - HANDLE handle{NULL}; - - AutoHandle() = default; - AutoHandle(HANDLE handle) : handle(handle) {} - ~AutoHandle() { ::CloseHandle(handle); } - - AutoHandle(const AutoHandle&) = delete; - AutoHandle& operator=(const AutoHandle&) = delete; - - void Close() { - ::CloseHandle(handle); - handle = NULL; - } -}; -} // namespace - -// Create a child process that uses the previously created pipes for STDIN and -// STDOUT. -ProcessResult SpawnSync(std::string_view command, - std::vector args) { - ProcessResult result{}; - - // Set the bInheritHandle flag so pipe handles are inherited. - - SECURITY_ATTRIBUTES handles_are_inheritable = { - sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE}; - - AutoHandle out_read_handle, out_write_handle; - VerifyElseExit(CreatePipe(&out_read_handle.handle, - &out_write_handle.handle, - &handles_are_inheritable, - 0)); - // Ensure the read handle to the pipe for STDOUT is not inherited. - VerifyElseExit( - SetHandleInformation(out_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); - - AutoHandle err_read_handle, err_write_handle; - VerifyElseExit(CreatePipe(&err_read_handle.handle, - &err_write_handle.handle, - &handles_are_inheritable, - 0)); - // Ensure the read handle to the pipe for STDERR is not inherited. - VerifyElseExit( - SetHandleInformation(err_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); - - // Set up members of the STARTUPINFO structure. - // This structure specifies the STDIN and STDOUT handles for redirection. - STARTUPINFOA startup_info{}; - startup_info.cb = sizeof(STARTUPINFOA); - startup_info.dwFlags |= STARTF_USESTDHANDLES; - startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); - startup_info.hStdOutput = out_write_handle.handle; - startup_info.hStdError = err_write_handle.handle; - - // Create the child process. - - std::string commandLine = std::string(command); - for (std::string& arg : args) { - commandLine += " " + arg; - } - PROCESS_INFORMATION process_info{}; - VerifyElseExit( - CreateProcessA(nullptr, - const_cast(commandLine.c_str()), // command line - nullptr, // process security attributes - nullptr, // primary thread security attributes - TRUE, // handles are inherited - CREATE_DEFAULT_ERROR_MODE, // creation flags - nullptr, // use parent's environment - nullptr, // use parent's current directory - &startup_info, // STARTUPINFO pointer - &process_info)); // receives PROCESS_INFORMATION - - VerifyElseExit(WAIT_OBJECT_0 == - ::WaitForSingleObject(process_info.hProcess, INFINITE)); - - DWORD exit_code; - VerifyElseExit(::GetExitCodeProcess(process_info.hProcess, &exit_code)); - - // Close handles to the child process and its primary thread. - // Some applications might keep these handles to monitor the status - // of the child process, for example. - ::CloseHandle(process_info.hProcess); - ::CloseHandle(process_info.hThread); - - // Close handles to the stdin and stdout pipes no longer needed by the child - // process. If they are not explicitly closed, there is no way to recognize - // that the child process has ended. - - out_write_handle.Close(); - err_write_handle.Close(); - - result.status = exit_code; - result.std_output = - ReplaceAll(ReadFromPipe(out_read_handle.handle), "\r\n", "\n"); - result.std_error = - ReplaceAll(ReadFromPipe(err_read_handle.handle), "\r\n", "\n"); - - return result; -} - -namespace { -std::string ReadFromPipe(HANDLE pipeHandle) { - std::string result; - constexpr size_t bufferSize = 4096; - char buffer[bufferSize]; - - for (;;) { - DWORD bytesRead; - BOOL isSuccess = - ::ReadFile(pipeHandle, buffer, bufferSize, &bytesRead, nullptr); - if (!isSuccess || bytesRead == 0) break; - - result.append(buffer, bytesRead); - } - - return result; -} - -// Format a readable error message, display a message box, -// and exit from the application. -void ExitOnError(const char* message) { - LPVOID lpMsgBuf; - LPVOID lpDisplayBuf; - DWORD dw = GetLastError(); - - ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - nullptr, - dw, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPSTR)&lpMsgBuf, - 0, - nullptr); - - lpDisplayBuf = (LPVOID)LocalAlloc( - LMEM_ZEROINIT, (lstrlenA((LPCSTR)lpMsgBuf) + lstrlenA(message) + 40)); - ::StringCchPrintfA((LPSTR)lpDisplayBuf, - LocalSize(lpDisplayBuf), - "%s failed with error %d: %s", - message, - dw, - lpMsgBuf); - fprintf(stderr, "%s\n", (const char*)lpDisplayBuf); - - ::LocalFree(lpMsgBuf); - ::LocalFree(lpDisplayBuf); - ::ExitProcess(1); -} - -} // namespace +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// +// Windows-specific implementation of the `spawnSync` function for creating +// child processes and capturing their output. This code is designed to work +// with the Windows API and is not portable to other platforms. It uses pipes +// to redirect the standard output and error streams of the child process back +// to the parent process, allowing the parent to read the output and error +// messages generated by the child process. +// +// The `spawnSync` function takes a command and a list of arguments, creates a +// child process to execute the command, and returns a `ProcessResult` structure +// containing the exit status and the captured output and error messages. +// + +#include "child_process.h" + +#include +#include +#include +#include +#include +#include +#include "string_utils.h" + +#ifndef VerifyElseExit +#define VerifyElseExit(condition) \ + do { \ + if (!(condition)) { \ + ExitOnError(#condition); \ + } \ + } while (false) +#endif + +namespace node_api_tests { + +namespace { + +std::string ReadFromPipe(HANDLE pipeHandle); +void ExitOnError(const char* message); + +struct AutoHandle { + HANDLE handle{NULL}; + + AutoHandle() = default; + AutoHandle(HANDLE handle) : handle(handle) {} + ~AutoHandle() { ::CloseHandle(handle); } + + AutoHandle(const AutoHandle&) = delete; + AutoHandle& operator=(const AutoHandle&) = delete; + + void Close() { + ::CloseHandle(handle); + handle = NULL; + } +}; +} // namespace + +// Create a child process that uses the previously created pipes for STDIN and +// STDOUT. +ProcessResult SpawnSync(std::string_view command, + std::vector args) { + ProcessResult result{}; + + // Set the bInheritHandle flag so pipe handles are inherited. + + SECURITY_ATTRIBUTES handles_are_inheritable = { + sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE}; + + AutoHandle out_read_handle, out_write_handle; + VerifyElseExit(CreatePipe(&out_read_handle.handle, + &out_write_handle.handle, + &handles_are_inheritable, + 0)); + // Ensure the read handle to the pipe for STDOUT is not inherited. + VerifyElseExit( + SetHandleInformation(out_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); + + AutoHandle err_read_handle, err_write_handle; + VerifyElseExit(CreatePipe(&err_read_handle.handle, + &err_write_handle.handle, + &handles_are_inheritable, + 0)); + // Ensure the read handle to the pipe for STDERR is not inherited. + VerifyElseExit( + SetHandleInformation(err_read_handle.handle, HANDLE_FLAG_INHERIT, 0)); + + // Set up members of the STARTUPINFO structure. + // This structure specifies the STDIN and STDOUT handles for redirection. + STARTUPINFOA startup_info{}; + startup_info.cb = sizeof(STARTUPINFOA); + startup_info.dwFlags |= STARTF_USESTDHANDLES; + startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); + startup_info.hStdOutput = out_write_handle.handle; + startup_info.hStdError = err_write_handle.handle; + + // Create the child process. + + std::string commandLine = std::string(command); + for (std::string& arg : args) { + commandLine += " " + arg; + } + PROCESS_INFORMATION process_info{}; + VerifyElseExit( + CreateProcessA(nullptr, + const_cast(commandLine.c_str()), // command line + nullptr, // process security attributes + nullptr, // primary thread security attributes + TRUE, // handles are inherited + CREATE_DEFAULT_ERROR_MODE, // creation flags + nullptr, // use parent's environment + nullptr, // use parent's current directory + &startup_info, // STARTUPINFO pointer + &process_info)); // receives PROCESS_INFORMATION + + // Release the parent's copies of the write ends first -- while they are open, ReadFile can + // never observe EOF -- then drain both pipes on their own threads while the child runs. + // Waiting for the child before reading deadlocks as soon as it writes more than the + // anonymous-pipe buffer (4 KiB by default): it blocks on write, the parent blocks on wait. + out_write_handle.Close(); + err_write_handle.Close(); + + std::string std_output; + std::string std_error; + std::thread out_reader([&] { std_output = ReadFromPipe(out_read_handle.handle); }); + std::thread err_reader([&] { std_error = ReadFromPipe(err_read_handle.handle); }); + out_reader.join(); + err_reader.join(); + + VerifyElseExit(WAIT_OBJECT_0 == + ::WaitForSingleObject(process_info.hProcess, INFINITE)); + + DWORD exit_code; + VerifyElseExit(::GetExitCodeProcess(process_info.hProcess, &exit_code)); + + // Close handles to the child process and its primary thread. + ::CloseHandle(process_info.hProcess); + ::CloseHandle(process_info.hThread); + + result.status = exit_code; + result.std_output = ReplaceAll(std_output, "\r\n", "\n"); + result.std_error = ReplaceAll(std_error, "\r\n", "\n"); + + return result; +} + +namespace { +std::string ReadFromPipe(HANDLE pipeHandle) { + std::string result; + constexpr size_t bufferSize = 4096; + char buffer[bufferSize]; + + for (;;) { + DWORD bytesRead; + BOOL isSuccess = + ::ReadFile(pipeHandle, buffer, bufferSize, &bytesRead, nullptr); + if (!isSuccess || bytesRead == 0) break; + + result.append(buffer, bytesRead); + } + + return result; +} + +// Format a readable error message, display a message box, +// and exit from the application. +void ExitOnError(const char* message) { + LPVOID lpMsgBuf; + LPVOID lpDisplayBuf; + DWORD dw = GetLastError(); + + ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + nullptr, + dw, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPSTR)&lpMsgBuf, + 0, + nullptr); + + lpDisplayBuf = (LPVOID)LocalAlloc( + LMEM_ZEROINIT, (lstrlenA((LPCSTR)lpMsgBuf) + lstrlenA(message) + 40)); + ::StringCchPrintfA((LPSTR)lpDisplayBuf, + LocalSize(lpDisplayBuf), + "%s failed with error %d: %s", + message, + dw, + lpMsgBuf); + fprintf(stderr, "%s\n", (const char*)lpDisplayBuf); + + ::LocalFree(lpMsgBuf); + ::LocalFree(lpDisplayBuf); + ::ExitProcess(1); +} + +} // namespace } // namespace node_api_tests \ No newline at end of file diff --git a/Tests/NodeApi/child_process_posix.cpp b/Tests/NodeApi/child_process_posix.cpp index bc461b0e..fd4114b2 100644 --- a/Tests/NodeApi/child_process_posix.cpp +++ b/Tests/NodeApi/child_process_posix.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -62,7 +63,7 @@ namespace node_api_tests { namespace { -std::string ReadFromFd(int fd); +void DrainPipes(int out_fd, int err_fd, std::string* out, std::string* err); void ExitOnError(const char* message, posix_spawn_file_actions_t* actions); } // namespace @@ -107,9 +108,12 @@ ProcessResult SpawnSync(std::string_view command, posix_spawn_file_actions_destroy(&actions); - // Close the write ends of the pipes. + // Close the write ends of the pipes, then drain both read ends concurrently while the child + // runs. Waiting first deadlocks as soon as the child writes more than a pipe buffer (16 KiB on + // macOS, 64 KiB on Linux): it blocks on write while the parent blocks in waitpid. close(stdout_pipe[1]); close(stderr_pipe[1]); + DrainPipes(stdout_pipe[0], stderr_pipe[0], &result.std_output, &result.std_error); int wait_status; pid_t waited_pid; @@ -126,9 +130,6 @@ ProcessResult SpawnSync(std::string_view command, } else { result.status = 1; } - result.std_output = ReadFromFd(stdout_pipe[0]); - result.std_error = ReadFromFd(stderr_pipe[0]); - // Close the read ends of the pipes. close(stdout_pipe[0]); close(stderr_pipe[0]); @@ -142,29 +143,43 @@ ProcessResult SpawnSync(std::string_view command, namespace { -std::string ReadFromFd(int fd) { - std::string result; - constexpr size_t bufferSize = 4096; - char buffer[bufferSize]; - ssize_t bytesRead; - while (true) { - bytesRead = read(fd, buffer, bufferSize); - if (bytesRead > 0) { - result.append(buffer, bytesRead); - continue; +// Reads out_fd and err_fd to EOF, servicing whichever has data, so neither side can fill its +// pipe buffer and stall the child while the other is idle. +void DrainPipes(int out_fd, int err_fd, std::string* out, std::string* err) { + struct Sink { + int fd; + std::string* target; + bool open; + }; + Sink sinks[2] = {{out_fd, out, true}, {err_fd, err, true}}; + char buffer[4096]; + while (sinks[0].open || sinks[1].open) { + pollfd fds[2]; + Sink* owners[2]; + nfds_t count = 0; + for (Sink& sink : sinks) { + if (sink.open) { + fds[count] = pollfd{sink.fd, POLLIN, 0}; + owners[count] = &sink; + ++count; + } } - - if (bytesRead == 0) { - break; + if (poll(fds, count, -1) < 0) { + if (errno == EINTR) continue; + ExitOnError("poll", nullptr); } - - if (errno == EINTR) { - continue; + for (nfds_t i = 0; i < count; ++i) { + if (fds[i].revents == 0) continue; // POLLIN, POLLHUP and POLLERR all mean "read now" + ssize_t bytesRead = read(fds[i].fd, buffer, sizeof(buffer)); + if (bytesRead > 0) { + owners[i]->target->append(buffer, static_cast(bytesRead)); + } else if (bytesRead == 0) { + owners[i]->open = false; + } else if (errno != EINTR && errno != EAGAIN) { + ExitOnError("read", nullptr); + } } - - ExitOnError("read", nullptr); } - return result; } // Format a readable error message, print it to console, and exit from the From 3b38a98a15bd727cb3d7ec1b514f0b563eab6a6e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 1 Sep 2026 16:33:17 -0700 Subject: [PATCH 063/174] Chakra: implement the N-API v7 ArrayBuffer detach pair napi_detach_arraybuffer and napi_is_detached_arraybuffer were absent from the Chakra backend entirely, so linking anything that referenced them failed -- which is how this surfaced (Win32_x64_Chakra and Win32_x86_Chakra failed at Build Solution once a test called them). Win10's OS Chakra has no way to detach an ArrayBuffer: the jsrt runtime exposes no detach entry point, and the engine predates ES2024 ArrayBuffer.prototype.transfer. So napi_detach_arraybuffer follows the same feature-detection-by-exception pattern as BigInt here -- a JS-catchable error tagged ENOTSUP -- rather than a bare status an addon cannot distinguish from a real failure. napi_is_detached_arraybuffer can be answered truthfully rather than stubbed: since nothing can detach a buffer on this engine, an ArrayBuffer that still reports storage through JsGetArrayBufferStorage is live, and a non-ArrayBuffer is not detached either (matching Node's contract). --- Core/Node-API/Source/js_native_api_chakra.cc | 40 ++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/Core/Node-API/Source/js_native_api_chakra.cc b/Core/Node-API/Source/js_native_api_chakra.cc index 7da499b6..89cd9407 100644 --- a/Core/Node-API/Source/js_native_api_chakra.cc +++ b/Core/Node-API/Source/js_native_api_chakra.cc @@ -2508,6 +2508,46 @@ napi_status napi_get_instance_data(napi_env env, void** data) { return napi_ok; } +// N-API v7 ArrayBuffer detach. Win10's OS Chakra exposes no way to detach an ArrayBuffer: the +// runtime has no detach entry point, and its JavaScript engine predates ES2024 +// ArrayBuffer.prototype.transfer(). As with BigInt below, report that honestly rather than failing +// with a bare status an addon cannot tell from a real error. +napi_status napi_detach_arraybuffer(napi_env env, napi_value arraybuffer) { + CHECK_ENV(env); + CHECK_ARG(env, arraybuffer); + CHECK_NAPI(napi_throw_error( + env, "ENOTSUP", + "ArrayBuffer detach is not supported by the underlying JavaScript engine (Chakra).")); + return napi_set_last_error(env, napi_pending_exception); +} + +napi_status napi_is_detached_arraybuffer(napi_env env, + napi_value arraybuffer, + bool* result) { + CHECK_ENV(env); + CHECK_ARG(env, arraybuffer); + CHECK_ARG(env, result); + + // Nothing can detach a buffer on this engine (see above), so an ArrayBuffer that still reports + // storage is live. Non-ArrayBuffers are not detached either, matching Node's contract. + JsValueType valueType; + CHECK_JSRT(env, JsGetValueType(reinterpret_cast(arraybuffer), &valueType)); + if (valueType != JsArrayBuffer) { + *result = false; + return napi_ok; + } + + BYTE* storageData; + unsigned int storageLength; + CHECK_JSRT(env, JsGetArrayBufferStorage( + reinterpret_cast(arraybuffer), + &storageData, + &storageLength)); + + *result = (storageData == nullptr); + return napi_ok; +} + // BigInt (v6): the Win10 OS edge-mode Chakra (jsrt) predates BigInt and exposes no JsBigInt* API, so // there is no value-preserving fallback. Per the Node-API feature-detection-by-exception pattern, throw // a JS-catchable error tagged "ENOTSUP" (so JS land can detect + polyfill) and return a pending From b5d69a823bebdccf28bd288a4da1e27214293e77 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 21:55:02 -0700 Subject: [PATCH 064/174] Add optional WHATWG Streams polyfill Vendor the ES5 web-streams-polyfill 4.3.0 ponyfill and expose an idempotent Streams initializer that preserves constructors supplied by the selected JavaScript engine. Cover readable, writable, transform, BYOB, error, tee, subclassing, and host-constructor behavior with focused ports from WPT plus Firefox and Chromium regression tests. Validate the implementation on JavaScriptCore under ASan/UBSan and QuickJS Release. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 6 +- Polyfills/Streams/CMakeLists.txt | 30 ++++ .../Include/Babylon/Polyfills/Streams.h | 11 ++ Polyfills/Streams/README.md | 14 ++ Polyfills/Streams/Source/Streams.cpp | 55 ++++++ Polyfills/Streams/Source/StreamsScripts.h.in | 36 ++++ .../ThirdParty/web-streams-polyfill/LICENSE | 22 +++ .../web-streams-polyfill/ponyfill.es5.js | 8 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 156 ++++++++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 26 +++ 12 files changed, 365 insertions(+), 1 deletion(-) create mode 100644 Polyfills/Streams/CMakeLists.txt create mode 100644 Polyfills/Streams/Include/Babylon/Polyfills/Streams.h create mode 100644 Polyfills/Streams/README.md create mode 100644 Polyfills/Streams/Source/Streams.cpp create mode 100644 Polyfills/Streams/Source/StreamsScripts.h.in create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..6535a653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,6 +102,7 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) +option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index a44765fb..c952cf27 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -44,4 +44,8 @@ endif() if(JSRUNTIMEHOST_POLYFILL_TEXTENCODER) add_subdirectory(TextEncoder) -endif() \ No newline at end of file +endif() + +if(JSRUNTIMEHOST_POLYFILL_STREAMS) + add_subdirectory(Streams) +endif() diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt new file mode 100644 index 00000000..6c00ed81 --- /dev/null +++ b/Polyfills/Streams/CMakeLists.txt @@ -0,0 +1,30 @@ +set(WEB_STREAMS_POLYFILL_FILE + "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/web-streams-polyfill/ponyfill.es5.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${WEB_STREAMS_POLYFILL_FILE}") +file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +configure_file( + "Source/StreamsScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Streams.h" + "Source/Streams.cpp" + "Source/StreamsScripts.h.in" + "ThirdParty/web-streams-polyfill/LICENSE" + "ThirdParty/web-streams-polyfill/ponyfill.es5.js") + +add_library(Streams ${SOURCES}) +warnings_as_errors(Streams) + +target_include_directories(Streams + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Streams PUBLIC JsRuntime) + +set_property(TARGET Streams PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h new file mode 100644 index 00000000..01e5a15c --- /dev/null +++ b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + // Installs the WHATWG Streams constructors that are not already supplied + // by the JavaScript engine. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Streams/README.md b/Polyfills/Streams/README.md new file mode 100644 index 00000000..c84a38e3 --- /dev/null +++ b/Polyfills/Streams/README.md @@ -0,0 +1,14 @@ +# Web Streams + +Installs the standard `ReadableStream`, `WritableStream`, `TransformStream`, +reader, writer, controller, and queuing-strategy globals when the selected +JavaScript engine does not provide them. + +The implementation is the ES5 ponyfill bundle from +[`web-streams-polyfill` 4.3.0](https://github.com/MattiasBuelens/web-streams-polyfill/tree/add69059ed08eae6a18559aba49575a280d1529e), +which is based on the WHATWG reference implementation. The vendored project +tests this release against the Streams portion of WPT at revision +[`c05b4473`](https://github.com/web-platform-tests/wpt/tree/c05b447326585237713013c66341eab2cdf967b6/streams). + +`Initialize` preserves any Streams constructors already supplied by the host +engine and fills only missing globals. diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp new file mode 100644 index 00000000..4552ed07 --- /dev/null +++ b/Polyfills/Streams/Source/Streams.cpp @@ -0,0 +1,55 @@ +#include + +#include "StreamsScripts.h" + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + void BABYLON_API Initialize(Napi::Env env) + { + Napi::HandleScope scope{env}; + auto global = env.Global(); + + static constexpr std::array constructorNames{ + "ReadableStream", + "ReadableStreamDefaultController", + "ReadableByteStreamController", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultReader", + "ReadableStreamBYOBReader", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", + "ByteLengthQueuingStrategy", + "CountQueuingStrategy", + "TransformStream", + "TransformStreamDefaultController", + }; + + bool needsPonyfill{}; + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + needsPonyfill = true; + break; + } + } + + if (!needsPonyfill) + { + return; + } + + const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + global.Set(name.data(), exports.Get(name.data())); + } + } + } +} diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in new file mode 100644 index 00000000..9bf7f5bf --- /dev/null +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Internal::StreamsScripts +{ + inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( +(function() { + var exports = {}; + var module = { exports: exports }; +@WEB_STREAMS_POLYFILL_SOURCE_1@ +)JSRHSTREAM"; + + inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ + return module.exports; +})() +)JSRHSTREAM"; + + template + consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + { + std::array result{}; + for (std::size_t index{}; index < Part1Size - 1; ++index) + { + result[index] = part1[index]; + } + for (std::size_t index{}; index < Part2Size; ++index) + { + result[Part1Size - 1 + index] = part2[index]; + } + return result; + } + + inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); +} diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js new file mode 100644 index 00000000..18d63683 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js @@ -0,0 +1,8 @@ +/** + * @license + * web-streams-polyfill v4.3.0 + * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors. + * This code is released under the MIT license. + * SPDX-License-Identifier: MIT + */ +!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).WebStreamsPolyfill={})}(this,function(e){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?Symbol:function(e){return"Symbol(".concat(e,")")};function t(){}function o(e){return"object"==typeof e&&null!==e||"function"==typeof e}"function"==typeof SuppressedError&&SuppressedError;var n=t;function i(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch(e){}}var a=Promise,u=Promise.resolve.bind(a),l=Promise.prototype.then,s=Promise.reject.bind(a),c=u;function f(e){return new a(e)}function d(e){return f(function(r){return r(e)})}function p(e){return s(e)}function b(e,r,t){return l.call(e,r,t)}function h(e,r,t){b(b(e,r,t),void 0,n)}function _(e,r){h(e,r)}function m(e,r){h(e,void 0,r)}function v(e,r,t){return b(e,r,t)}function y(e){b(e,void 0,n)}var g=function(e){if("function"==typeof queueMicrotask)g=queueMicrotask;else{var r=d(void 0);g=function(e){return b(r,e)}}return g(e)};function S(e,r,t){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}function w(e,r,t){try{return d(S(e,r,t))}catch(e){return p(e)}}var R=function(){function e(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}return Object.defineProperty(e.prototype,"length",{get:function(){return this._size},enumerable:!1,configurable:!0}),e.prototype.push=function(e){var r=this._back,t=r;16383===r._elements.length&&(t={_elements:[],_next:void 0}),r._elements.push(e),t!==r&&(this._back=t,r._next=t),++this._size},e.prototype.shift=function(){var e=this._front,r=e,t=this._cursor,o=t+1,n=e._elements,i=n[t];return 16384===o&&(r=e._next,o=0),--this._size,this._cursor=o,e!==r&&(this._front=r),n[t]=void 0,i},e.prototype.forEach=function(e){for(var r=this._cursor,t=this._front,o=t._elements;!(r===o.length&&void 0===t._next||r===o.length&&(r=0,0===(o=(t=t._next)._elements).length));)e(o[r]),++r},e.prototype.peek=function(){var e=this._front,r=this._cursor;return e._elements[r]},e}(),T=r("[[AbortSteps]]"),P=r("[[ErrorSteps]]"),C=r("[[CancelSteps]]"),q=r("[[PullSteps]]"),E=r("[[CanPullSyncSteps]]"),W=r("[[ReleaseSteps]]");function O(e,r){e._ownerReadableStream=r,r._reader=e,"readable"===r._state?A(e):"closed"===r._state?function(e){A(e),F(e)}(e):z(e,r._storedError)}function j(e,r){return eo(e._ownerReadableStream,r)}function B(e){var r=e._ownerReadableStream;"readable"===r._state?D(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,r){z(e,r)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[W](),r._reader=void 0,e._ownerReadableStream=void 0}function k(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function A(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t})}function z(e,r){A(e),D(e,r)}function D(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function F(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var L=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},I=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function M(e,r){if(void 0!==e&&("object"!=typeof(t=e)&&"function"!=typeof t))throw new TypeError("".concat(r," is not an object."));var t}function x(e,r){if("function"!=typeof e)throw new TypeError("".concat(r," is not a function."))}function Y(e,r){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError("".concat(r," is not an object."))}function Q(e,r,t){if(void 0===e)throw new TypeError("Parameter ".concat(r," is required in '").concat(t,"'."))}function N(e,r,t){if(void 0===e)throw new TypeError("".concat(r," is required in '").concat(t,"'."))}function H(e){return Number(e)}function V(e){return 0===e?0:e}function U(e,r){var t=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=V(o),!L(o))throw new TypeError("".concat(r," is not a finite number"));if((o=function(e){return V(I(e))}(o))<0||o>t)throw new TypeError("".concat(r," is outside the accepted range of ").concat(0," to ").concat(t,", inclusive"));return L(o)&&0!==o?o:0}function G(e,r){if(!Zt(e))throw new TypeError("".concat(r," is not a ReadableStream."))}function X(e){return new ee(e)}function J(e,r){e._reader._readRequests.push(r)}function K(e,r,t){var o=e._reader._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}function Z(e){return e._reader._readRequests.length}function $(e){var r=e._reader;return void 0!==r&&!!ae(r)}var ee=function(){function ReadableStreamDefaultReader(e){if(Q(e,1,"ReadableStreamDefaultReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");O(this,e),this._readRequests=new R}return Object.defineProperty(ReadableStreamDefaultReader.prototype,"closed",{get:function(){return ae(this)?this._closedPromise:p(ce("closed"))},enumerable:!1,configurable:!0}),ReadableStreamDefaultReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),ae(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(ce("cancel"))},ReadableStreamDefaultReader.prototype.read=function(){if(!ae(this))return p(ce("read"));if(void 0===this._ownerReadableStream)return p(k("read from"));var e=le(this)?new ie:new ne;return ue(this,e),e._promise},ReadableStreamDefaultReader.prototype.releaseLock=function(){if(!ae(this))throw ce("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");se(e,r)}(this)},ReadableStreamDefaultReader}();Object.defineProperties(ee.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(ee.prototype.cancel,"cancel"),i(ee.prototype.read,"read"),i(ee.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ee.prototype,r.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var re,te,oe,ne=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(){this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),ie=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(){this._promise=c({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function ae(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ee)}function ue(e,r){var t=e._ownerReadableStream;t._disturbed=!0,"closed"===t._state?r._closeSteps():"errored"===t._state?r._errorSteps(t._storedError):t._readableStreamController[q](r)}function le(e){var r=e._ownerReadableStream;return"closed"===r._state||("errored"===r._state||r._readableStreamController[E]())}function se(e,r){var t=e._readRequests;e._readRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function ce(e){return new TypeError("ReadableStreamDefaultReader.prototype.".concat(e," can only be used on a ReadableStreamDefaultReader"))}function fe(e){return e.slice()}function de(e,r,t,o,n){new Uint8Array(e).set(new Uint8Array(t,o,n),r)}var pe=function(e){return(pe="function"==typeof e.transfer?function(e){return e.transfer()}:"function"==typeof structuredClone?function(e){return structuredClone(e,{transfer:[e]})}:function(e){return e})(e)},be=function(e){return(be="boolean"==typeof e.detached?function(e){return e.detached}:function(e){return 0===e.byteLength})(e)};function he(e,r,t){if(e.slice)return e.slice(r,t);var o=t-r,n=new ArrayBuffer(o);return de(n,0,e,r,o),n}function _e(e,r){var t=e[r];if(null!=t){if("function"!=typeof t)throw new TypeError("".concat(String(r)," is not a function"));return t}}function me(e){try{var r=e.done,t=e.value;return b(c(t),function(e){return{done:r,value:e}})}catch(e){return p(e)}}var ve,ye=null!==(oe=null!==(re=r.asyncIterator)&&void 0!==re?re:null===(te=r.for)||void 0===te?void 0:te.call(r,"Symbol.asyncIterator"))&&void 0!==oe?oe:"@@asyncIterator";function ge(e,t,n){if(void 0===t&&(t="sync"),void 0===n)if("async"===t){if(void 0===(n=_e(e,ye)))return function(e){var r={next:function(){var r;try{r=Se(e)}catch(e){return p(e)}return me(r)},return:function(r){var t;try{var n=_e(e.iterator,"return");if(void 0===n)return d({done:!0,value:r});t=S(n,e.iterator,[r])}catch(e){return p(e)}return o(t)?me(t):p(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(ge(e,"sync",_e(e,r.iterator)))}else n=_e(e,r.iterator);if(void 0===n)throw new TypeError("The object is not iterable");var i=S(n,e,[]);if(!o(i))throw new TypeError("The iterator method must return an object");return{iterator:i,nextMethod:i.next,done:!1}}function Se(e){var r=S(e.nextMethod,e.iterator,[]);if(!o(r))throw new TypeError("The iterator.next() method must return an object");return r}var we=function(){function e(e,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=r}return e.prototype.next=function(){var e=this,r=function(){return e._nextSteps()};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,r,r):r(),this._ongoingPromise},e.prototype.return=function(e){var r=this,t=function(){return r._returnSteps(e)};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,t,t):t(),this._ongoingPromise},e.prototype._nextSteps=function(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});var e=this._reader,r=new Re(this);return ue(e,r),r._promise},e.prototype._returnSteps=function(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;var r=this._reader;if(!this._preventCancel){var t=j(r,e);return B(r),v(t,function(){return{value:e,done:!0}})}return B(r),d({value:e,done:!0})},e}(),Re=function(){function e(e){var r=this;this._iterator=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){var r=this;this._iterator._ongoingPromise=void 0,g(function(){return r._resolvePromise({value:e,done:!1})})},e.prototype._closeSteps=function(){var e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){var r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,B(r._reader),this._rejectPromise(e)},e}(),Te=((ve={next:function(){return Pe(this)?this._asyncIteratorImpl.next():p(Ce("next"))},return:function(e){return Pe(this)?this._asyncIteratorImpl.return(e):p(Ce("return"))}})[ye]=function(){return this},ve);function Pe(e){if(!o(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof we}catch(e){return!1}}function Ce(e){return new TypeError("ReadableStreamAsyncIterator.".concat(e," can only be used on a ReadableSteamAsyncIterator"))}Object.defineProperty(Te,ye,{enumerable:!1});var qe=Number.isNaN||function(e){return e!=e};function Ee(e){var r=he(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}function We(e){var r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}function Oe(e,r,t){if("number"!=typeof(o=t)||qe(o)||o<0||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:r,size:t}),e._queueTotalSize+=t}function je(e){e._queue=new R,e._queueTotalSize=0}function Be(e){return e===DataView}function ke(e){return Be(e)?1:e.BYTES_PER_ELEMENT}var Ae=function(){function ReadableStreamBYOBRequest(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamBYOBRequest.prototype,"view",{get:function(){if(!Fe(this))throw sr("view");return this._view},enumerable:!1,configurable:!0}),ReadableStreamBYOBRequest.prototype.respond=function(e){if(!Fe(this))throw sr("respond");if(Q(e,1,"respond"),e=U(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");ar(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest.prototype.respondWithNewView=function(e){if(!Fe(this))throw sr("respondWithNewView");if(Q(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");ur(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest}();Object.defineProperties(Ae.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),i(Ae.prototype.respond,"respond"),i(Ae.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Ae.prototype,r.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var ze=function(){function ReadableByteStreamController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableByteStreamController.prototype,"byobRequest",{get:function(){if(!De(this))throw cr("byobRequest");return nr(this)},enumerable:!1,configurable:!0}),Object.defineProperty(ReadableByteStreamController.prototype,"desiredSize",{get:function(){if(!De(this))throw cr("desiredSize");return ir(this)},enumerable:!1,configurable:!0}),ReadableByteStreamController.prototype.close=function(){if(!De(this))throw cr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");var e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError("The stream (in ".concat(e," state) is not in the readable state and cannot be closed"));er(this)},ReadableByteStreamController.prototype.enqueue=function(e){if(!De(this))throw cr("enqueue");if(Q(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");var r=this._controlledReadableByteStream._state;if("readable"!==r)throw new TypeError("The stream (in ".concat(r," state) is not in the readable state and cannot be enqueued to"));rr(this,e)},ReadableByteStreamController.prototype.error=function(e){if(void 0===e&&(e=void 0),!De(this))throw cr("error");tr(this,e)},ReadableByteStreamController.prototype[C]=function(e){Ie(this),je(this);var r=this._cancelAlgorithm(e);return $e(this),r},ReadableByteStreamController.prototype[q]=function(e){var r=this._controlledReadableByteStream;if(this._queueTotalSize>0)or(this,e);else{var t=this._autoAllocateChunkSize;if(void 0!==t){var o=void 0;try{o=new ArrayBuffer(t)}catch(r){return void e._errorSteps(r)}var n={buffer:o,bufferByteLength:t,byteOffset:0,byteLength:t,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(n)}J(r,e),Le(this)}},ReadableByteStreamController.prototype[E]=function(){return this._queueTotalSize>0},ReadableByteStreamController.prototype[W]=function(){if(this._pendingPullIntos.length>0){var e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new R,this._pendingPullIntos.push(e)}},ReadableByteStreamController}();function De(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ze)}function Fe(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof Ae)}function Le(e){var r=function(e){var r=e._controlledReadableByteStream;if("readable"!==r._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if($(r)&&Z(r)>0)return!0;if(hr(r)&&br(r)>0)return!0;var t=ir(e);if(t>0)return!0;return!1}(e);r&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Le(e)),null},function(r){return tr(e,r),null})))}function Ie(e){Xe(e),e._pendingPullIntos=new R}function Me(e,r){var t=!1;"closed"===e._state&&(t=!0);var o=Ye(r);"default"===r.readerType?K(e,o,t):function(e,r,t){var o=e._reader,n=o._readIntoRequests.shift();t?n._closeSteps(r):n._chunkSteps(r)}(e,o,t)}function xe(e,r){for(var t=0;t0&&Ne(e,r.buffer,r.byteOffset,r.bytesFilled),Ze(e)}function Ve(e,r){var t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),o=r.bytesFilled+t,n=t,i=!1,a=o-o%r.elementSize;a>=r.minimumFill&&(n=a-r.bytesFilled,i=!0);for(var u=e._queue;n>0;){var l=u.peek(),s=Math.min(n,l.byteLength),c=r.byteOffset+r.bytesFilled;de(r.buffer,c,l.buffer,l.byteOffset,s),l.byteLength===s?u.shift():(l.byteOffset+=s,l.byteLength-=s),e._queueTotalSize-=s,Ue(e,s,r),n-=s}return i}function Ue(e,r,t){t.bytesFilled+=r}function Ge(e){0===e._queueTotalSize&&e._closeRequested?($e(e),ro(e._controlledReadableByteStream)):Le(e)}function Xe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Je(e){for(var r=[];e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){var t=e._pendingPullIntos.peek();Ve(e,t)&&(Ze(e),r.push(t))}return r}function Ke(e,r){var t=e._pendingPullIntos.peek();Xe(e),"closed"===e._controlledReadableByteStream._state?function(e,r){"none"===r.readerType&&Ze(e);var t=e._controlledReadableByteStream;if(hr(t)){for(var o=[];o.length0){var n=t.byteOffset+t.bytesFilled;Ne(e,t.buffer,n-o,o)}t.bytesFilled-=o;var i=Je(e);Me(e._controlledReadableByteStream,t),xe(e._controlledReadableByteStream,i)}}else{He(e,t);var a=Je(e);xe(e._controlledReadableByteStream,a)}}(e,r,t),Le(e)}function Ze(e){return e._pendingPullIntos.shift()}function $e(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function er(e){var r=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===r._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){var t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){var o=new TypeError("Insufficient bytes to fill elements in the given buffer");throw tr(e,o),o}}$e(e),ro(r)}}function rr(e,r){var t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state){var o=r.buffer,n=r.byteOffset,i=r.byteLength;if(be(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");var a=pe(o);if(e._pendingPullIntos.length>0){var u=e._pendingPullIntos.peek();if(be(u.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Xe(e),u.buffer=pe(u.buffer),"none"===u.readerType&&He(e,u)}if($(t))if(function(e){for(var r=e._controlledReadableByteStream._reader;r._readRequests.length>0;){if(0===e._queueTotalSize)return;or(e,r._readRequests.shift())}}(e),0===Z(t))Qe(e,a,n,i);else e._pendingPullIntos.length>0&&Ze(e),K(t,new Uint8Array(a,n,i),!1);else if(hr(t)){Qe(e,a,n,i),xe(t,Je(e))}else Qe(e,a,n,i);Le(e)}}function tr(e,r){var t=e._controlledReadableByteStream;"readable"===t._state&&(Ie(e),je(e),$e(e),to(t,r))}function or(e,r){var t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ge(e);var o=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(o)}function nr(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){var r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),o=Object.create(Ae.prototype);!function(e,r,t){e._associatedReadableByteStreamController=r,e._view=t}(o,e,t),e._byobRequest=o}return e._byobRequest}function ir(e){var r=e._controlledReadableByteStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function ar(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===r)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=pe(t.buffer),Ke(e,r)}function ur(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===r.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");var o=r.byteLength;t.buffer=pe(r.buffer),Ke(e,o)}function lr(e,r,t,o,n,i,a){r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,je(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,r._autoAllocateChunkSize=a,r._pendingPullIntos=new R,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,Le(r),null},function(e){return tr(r,e),null})}function sr(e){return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(e," can only be used on a ReadableStreamBYOBRequest"))}function cr(e){return new TypeError("ReadableByteStreamController.prototype.".concat(e," can only be used on a ReadableByteStreamController"))}function fr(e,r){if("byob"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamReaderMode"));return e}function dr(e){return new _r(e)}function pr(e,r){e._reader._readIntoRequests.push(r)}function br(e){return e._reader._readIntoRequests.length}function hr(e){var r=e._reader;return void 0!==r&&!!yr(r)}Object.defineProperties(ze.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),i(ze.prototype.close,"close"),i(ze.prototype.enqueue,"enqueue"),i(ze.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ze.prototype,r.toStringTag,{value:"ReadableByteStreamController",configurable:!0});var _r=function(){function ReadableStreamBYOBReader(e){if(Q(e,1,"ReadableStreamBYOBReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!De(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");O(this,e),this._readIntoRequests=new R}return Object.defineProperty(ReadableStreamBYOBReader.prototype,"closed",{get:function(){return yr(this)?this._closedPromise:p(wr("closed"))},enumerable:!1,configurable:!0}),ReadableStreamBYOBReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),yr(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(wr("cancel"))},ReadableStreamBYOBReader.prototype.read=function(e,r){if(void 0===r&&(r={}),!yr(this))return p(wr("read"));if(!ArrayBuffer.isView(e))return p(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return p(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return p(new TypeError("view's buffer must have non-zero byteLength"));if(be(e.buffer))return p(new TypeError("view's buffer has been detached"));var t;try{t=function(e,r){var t;return M(e,r),{min:U(null!==(t=null==e?void 0:e.min)&&void 0!==t?t:1,"".concat(r," has member 'min' that"))}}(r,"options")}catch(e){return p(e)}var o=t.min;if(0===o)return p(new TypeError("options.min must be greater than 0"));if(function(e){return Be(e.constructor)}(e)){if(o>e.byteLength)return p(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return p(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return p(k("read from"));var n=function(e,r,t){var o=e._ownerReadableStream;return"errored"===o._state||function(e,r,t){var o=e._controlledReadableByteStream,n=ke(r.constructor);r.byteLength;var i=t*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,r,t)}(this,e,o)?new vr:new mr;return gr(this,e,o,n),n._promise},ReadableStreamBYOBReader.prototype.releaseLock=function(){if(!yr(this))throw wr("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");Sr(e,r)}(this)},ReadableStreamBYOBReader}();Object.defineProperties(_r.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(_r.prototype.cancel,"cancel"),i(_r.prototype.read,"read"),i(_r.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(_r.prototype,r.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var mr=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(e){this._resolvePromise({value:e,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),vr=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(e){this._promise=c({value:e,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function yr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof _r)}function gr(e,r,t,o){var n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,r,t,o){var n,i=e._controlledReadableByteStream,a=r.constructor,u=ke(a),l=r.byteOffset,s=r.byteLength,c=t*u;try{n=pe(r.buffer)}catch(p){return void o._errorSteps(p)}var f={buffer:n,bufferByteLength:n.byteLength,byteOffset:l,byteLength:s,bytesFilled:0,minimumFill:c,elementSize:u,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(f),void pr(i,o);if("closed"!==i._state){if(e._queueTotalSize>0){if(Ve(e,f)){var d=Ye(f);return Ge(e),void o._chunkSteps(d)}if(e._closeRequested){var p=new TypeError("Insufficient bytes to fill elements in the given buffer");return tr(e,p),void o._errorSteps(p)}}e._pendingPullIntos.push(f),pr(i,o),Le(e)}else{var b=new a(f.buffer,f.byteOffset,0);o._closeSteps(b)}}(n._readableStreamController,r,t,o)}function Sr(e,r){var t=e._readIntoRequests;e._readIntoRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function wr(e){return new TypeError("ReadableStreamBYOBReader.prototype.".concat(e," can only be used on a ReadableStreamBYOBReader"))}function Rr(e,r){var t=e.highWaterMark;if(void 0===t)return r;if(qe(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}function Tr(e){var r=e.size;return r||function(){return 1}}function Pr(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===t?void 0:H(t),size:void 0===o?void 0:Cr(o,"".concat(r," has member 'size' that"))}}function Cr(e,r){return x(e,r),function(r){return H(e(r))}}function qr(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Er(e,r,t){return x(e,t),function(){return w(e,r,[])}}function Wr(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Or(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function jr(e,r){if(!zr(e))throw new TypeError("".concat(r," is not a WritableStream."))}var Br=function(){function WritableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,i=null==e?void 0:e.type,a=null==e?void 0:e.write;return{abort:void 0===t?void 0:qr(t,e,"".concat(r," has member 'abort' that")),close:void 0===o?void 0:Er(o,e,"".concat(r," has member 'close' that")),start:void 0===n?void 0:Wr(n,e,"".concat(r," has member 'start' that")),write:void 0===a?void 0:Or(a,e,"".concat(r," has member 'write' that")),type:i}}(e,"First parameter");if(Ar(this),void 0!==o.type)throw new RangeError("Invalid type is specified");var n=Tr(t);!function(e,r,t,o){var n,i,a,u,l=Object.create($r.prototype);n=void 0!==r.start?function(){return r.start(l)}:function(){};i=void 0!==r.write?function(e){return r.write(e,l)}:function(){return d(void 0)};a=void 0!==r.close?function(){return r.close()}:function(){return d(void 0)};u=void 0!==r.abort?function(e){return r.abort(e)}:function(){return d(void 0)};rt(e,l,n,i,a,u,t,o)}(this,o,Rr(t,1),n)}return Object.defineProperty(WritableStream.prototype,"locked",{get:function(){if(!zr(this))throw lt("locked");return Dr(this)},enumerable:!1,configurable:!0}),WritableStream.prototype.abort=function(e){return void 0===e&&(e=void 0),zr(this)?Dr(this)?p(new TypeError("Cannot abort a stream that already has a writer")):Fr(this,e):p(lt("abort"))},WritableStream.prototype.close=function(){return zr(this)?Dr(this)?p(new TypeError("Cannot close a stream that already has a writer")):Yr(this)?p(new TypeError("Cannot close an already-closing stream")):Lr(this):p(lt("close"))},WritableStream.prototype.getWriter=function(){if(!zr(this))throw lt("getWriter");return kr(this)},WritableStream}();function kr(e){return new Hr(e)}function Ar(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new R,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function zr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof Br)}function Dr(e){return void 0!==e._writer}function Fr(e,r){var t;if("closed"===e._state||"errored"===e._state)return d(void 0);e._writableStreamController._abortReason=r,null===(t=e._writableStreamController._abortController)||void 0===t||t.abort(r);var o=e._state;if("closed"===o||"errored"===o)return d(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;var n=!1;"erroring"===o&&(n=!0,r=void 0);var i=f(function(t,o){e._pendingAbortRequest={_promise:void 0,_resolve:t,_reject:o,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=i,n||Mr(e,r),i}function Lr(e){var r=e._state;if("closed"===r||"errored"===r)return p(new TypeError("The stream (in ".concat(r," state) is not in the writable state and cannot be closed")));var t,o=f(function(r,t){var o={_resolve:r,_reject:t};e._closeRequest=o}),n=e._writer;return void 0!==n&&e._backpressure&&"writable"===r&>(n),Oe(t=e._writableStreamController,Zr,0),nt(t),o}function Ir(e,r){"writable"!==e._state?xr(e):Mr(e,r)}function Mr(e,r){var t=e._writableStreamController;e._state="erroring",e._storedError=r;var o=e._writer;void 0!==o&&Xr(o,r),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&t._started&&xr(e)}function xr(e){e._state="errored",e._writableStreamController[P]();var r=e._storedError;if(e._writeRequests.forEach(function(e){e._reject(r)}),e._writeRequests=new R,void 0!==e._pendingAbortRequest){var t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring)return t._reject(r),void Qr(e);h(e._writableStreamController[T](t._reason),function(){return t._resolve(),Qr(e),null},function(r){return t._reject(r),Qr(e),null})}else Qr(e)}function Yr(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function Qr(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);var r=e._writer;void 0!==r&&bt(r,e._storedError)}function Nr(e,r){var t=e._writer;void 0!==t&&r!==e._backpressure&&(r?function(e){_t(e)}(t):gt(t)),e._backpressure=r}Object.defineProperties(Br.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),i(Br.prototype.abort,"abort"),i(Br.prototype.close,"close"),i(Br.prototype.getWriter,"getWriter"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Br.prototype,r.toStringTag,{value:"WritableStream",configurable:!0});var Hr=function(){function WritableStreamDefaultWriter(e){if(Q(e,1,"WritableStreamDefaultWriter"),jr(e,"First parameter"),Dr(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;var r,t=e._state;if("writable"===t)!Yr(e)&&e._backpressure?_t(this):vt(this),dt(this);else if("erroring"===t)mt(this,e._storedError),dt(this);else if("closed"===t)vt(this),dt(r=this),ht(r);else{var o=e._storedError;mt(this,o),pt(this,o)}}return Object.defineProperty(WritableStreamDefaultWriter.prototype,"closed",{get:function(){return Vr(this)?this._closedPromise:p(ct("closed"))},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"desiredSize",{get:function(){if(!Vr(this))throw ct("desiredSize");if(void 0===this._ownerWritableStream)throw ft("desiredSize");return function(e){var r=e._ownerWritableStream,t=r._state;if("errored"===t||"erroring"===t)return null;if("closed"===t)return 0;return ot(r._writableStreamController)}(this)},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"ready",{get:function(){return Vr(this)?this._readyPromise:p(ct("ready"))},enumerable:!1,configurable:!0}),WritableStreamDefaultWriter.prototype.abort=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("abort")):function(e,r){return Fr(e._ownerWritableStream,r)}(this,e):p(ct("abort"))},WritableStreamDefaultWriter.prototype.close=function(){if(!Vr(this))return p(ct("close"));var e=this._ownerWritableStream;return void 0===e?p(ft("close")):Yr(e)?p(new TypeError("Cannot close an already-closing stream")):Ur(this)},WritableStreamDefaultWriter.prototype.releaseLock=function(){if(!Vr(this))throw ct("releaseLock");void 0!==this._ownerWritableStream&&Jr(this)},WritableStreamDefaultWriter.prototype.write=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("write to")):Kr(this,e):p(ct("write"))},WritableStreamDefaultWriter}();function Vr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof Hr)}function Ur(e){return Lr(e._ownerWritableStream)}function Gr(e,r){"pending"===e._closedPromiseState?bt(e,r):function(e,r){pt(e,r)}(e,r)}function Xr(e,r){"pending"===e._readyPromiseState?yt(e,r):function(e,r){mt(e,r)}(e,r)}function Jr(e){var r=e._ownerWritableStream,t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Xr(e,t),Gr(e,t),r._writer=void 0,e._ownerWritableStream=void 0}function Kr(e,r){var t=e._ownerWritableStream,o=t._writableStreamController,n=function(e,r){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(r)}catch(r){return it(e,r),1}}(o,r);if(t!==e._ownerWritableStream)return p(ft("write to"));var i=t._state;if("errored"===i)return p(t._storedError);if(Yr(t)||"closed"===i)return p(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===i)return p(t._storedError);var a=function(e){return f(function(r,t){var o={_resolve:r,_reject:t};e._writeRequests.push(o)})}(t);return function(e,r,t){try{Oe(e,r,t)}catch(r){return void it(e,r)}var o=e._controlledWritableStream;if(!Yr(o)&&"writable"===o._state){Nr(o,at(e))}nt(e)}(o,r,n),a}Object.defineProperties(Hr.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),i(Hr.prototype.abort,"abort"),i(Hr.prototype.close,"close"),i(Hr.prototype.releaseLock,"releaseLock"),i(Hr.prototype.write,"write"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Hr.prototype,r.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});var Zr={},$r=function(){function WritableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(WritableStreamDefaultController.prototype,"abortReason",{get:function(){if(!et(this))throw st("abortReason");return this._abortReason},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultController.prototype,"signal",{get:function(){if(!et(this))throw st("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal},enumerable:!1,configurable:!0}),WritableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!et(this))throw st("error");"writable"===this._controlledWritableStream._state&&ut(this,e)},WritableStreamDefaultController.prototype[T]=function(e){var r=this._abortAlgorithm(e);return tt(this),r},WritableStreamDefaultController.prototype[P]=function(){je(this)},WritableStreamDefaultController}();function et(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof $r)}function rt(e,r,t,o,n,i,a,u){r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._abortReason=void 0,r._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),r._started=!1,r._strategySizeAlgorithm=u,r._strategyHWM=a,r._writeAlgorithm=o,r._closeAlgorithm=n,r._abortAlgorithm=i;var l=at(r);Nr(e,l),h(d(t()),function(){return r._started=!0,nt(r),null},function(t){return r._started=!0,Ir(e,t),null})}function tt(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ot(e){return e._strategyHWM-e._queueTotalSize}function nt(e){var r=e._controlledWritableStream;if(e._started&&void 0===r._inFlightWriteRequest)if("erroring"!==r._state){if(0!==e._queue.length){var t=e._queue.peek().value;t===Zr?function(e){var r=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(r),We(e);var t=e._closeAlgorithm();tt(e),h(t,function(){return function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";var r=e._writer;void 0!==r&&ht(r)}(r),null},function(e){return function(e,r){e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Ir(e,r)}(r,e),null})}(e):function(e,r){var t=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(t);var o=e._writeAlgorithm(r);h(o,function(){!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(t);var r=t._state;if(We(e),!Yr(t)&&"writable"===r){var o=at(e);Nr(t,o)}return nt(e),null},function(r){return"writable"===t._state&&tt(e),function(e,r){e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,Ir(e,r)}(t,r),null})}(e,t)}}else xr(r)}function it(e,r){"writable"===e._controlledWritableStream._state&&ut(e,r)}function at(e){return ot(e)<=0}function ut(e,r){var t=e._controlledWritableStream;tt(e),Mr(t,r)}function lt(e){return new TypeError("WritableStream.prototype.".concat(e," can only be used on a WritableStream"))}function st(e){return new TypeError("WritableStreamDefaultController.prototype.".concat(e," can only be used on a WritableStreamDefaultController"))}function ct(e){return new TypeError("WritableStreamDefaultWriter.prototype.".concat(e," can only be used on a WritableStreamDefaultWriter"))}function ft(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function dt(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}function pt(e,r){dt(e),bt(e,r)}function bt(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ht(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function _t(e){e._readyPromise=f(function(r,t){e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}function mt(e,r){_t(e),yt(e,r)}function vt(e){_t(e),gt(e)}function yt(e,r){void 0!==e._readyPromise_reject&&(y(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function gt(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties($r.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty($r.prototype,r.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});var St="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;var wt,Rt=(function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(wt=null==St?void 0:St.DOMException)?wt:void 0)||function(){var e=function(e,r){this.message=e||"",this.name=r||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return i(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function Tt(e,r,t,o,n,i){var a=X(e),u=kr(r);e._disturbed=!0;var l=new Pt(u),s=new qt(l);return f(function(c,m){var v,g,S,w;if(void 0!==i){if(v=function(){var t=void 0!==i.reason?i.reason:new Rt("Aborted","AbortError"),a=[];o||a.push(function(){return"writable"===r._state?Fr(r,t):d(void 0)}),n||a.push(function(){return"readable"===e._state?eo(e,t):d(void 0)}),P(function(){return Promise.all(a.map(function(e){return e()}))},!0,t)},i.aborted)return void v();i.addEventListener("abort",v)}function R(){for(;!l._shuttingDown&&!r._backpressure&&"writable"===r._state&&!Yr(r)&&"readable"===e._state&&le(a);)ue(a,s);if(l._shuttingDown)return d(!0);if(r._backpressure)return b(u._readyPromise,R);var t=new Ct(l);return ue(a,t),t._promise}if(Et(e,a._closedPromise,function(e){return o?C(!0,e):P(function(){return Fr(r,e)},!0,e),null}),Et(r,u._closedPromise,function(r){return n?C(!0,r):P(function(){return eo(e,r)},!0,r),null}),g=e,S=a._closedPromise,w=function(){return t?C():P(function(){return function(e){var r=e._ownerWritableStream,t=r._state;return Yr(r)||"closed"===t?d(void 0):"errored"===t?p(r._storedError):Ur(e)}(u)}),null},"closed"===g._state?w():_(S,w),Yr(r)||"closed"===r._state){var T=new TypeError("the destination writable stream closed before all data could be piped to it");n?C(!0,T):P(function(){return eo(e,T)},!0,T)}function P(e,t,o){function n(){return h(e(),function(){return q(t,o)},function(e){return q(!0,e)}),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?n():_(l._waitForWritesToFinish(),n))}function C(e,t){l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?q(e,t):_(l._waitForWritesToFinish(),function(){return q(e,t)}))}function q(e,r){return Jr(u),B(a),void 0!==i&&i.removeEventListener("abort",v),e?m(r):c(void 0),null}y(f(function(e,r){!function t(o){o?e():b(R(),t,r)}(!1)}))})}var Pt=function(){function e(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=d(void 0)}return e.prototype._waitForWritesToFinish=function(){var e=this,r=this._currentWrite;return b(this._currentWrite,function(){return r!==e._currentWrite?e._waitForWritesToFinish():void 0})},e}(),Ct=function(){function e(e){var r=this;this._state=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t),this._resolvePromise(!1)},e.prototype._closeSteps=function(){this._resolvePromise(!0)},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),qt=function(){function e(e){this._state=e}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t)},e.prototype._closeSteps=function(){},e.prototype._errorSteps=function(e){},e}();function Et(e,r,t){"errored"===e._state?t(e._storedError):m(r,t)}var Wt=function(){function ReadableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Ot(this))throw Mt("desiredSize");return Ft(this)},enumerable:!1,configurable:!0}),ReadableStreamDefaultController.prototype.close=function(){if(!Ot(this))throw Mt("close");if(!Lt(this))throw new TypeError("The stream is not in a state that permits close");At(this)},ReadableStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("enqueue");if(!Lt(this))throw new TypeError("The stream is not in a state that permits enqueue");return zt(this,e)},ReadableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("error");Dt(this,e)},ReadableStreamDefaultController.prototype[C]=function(e){je(this);var r=this._cancelAlgorithm(e);return kt(this),r},ReadableStreamDefaultController.prototype[q]=function(e){var r=this._controlledReadableStream;if(this._queue.length>0){var t=We(this);this._closeRequested&&0===this._queue.length?(kt(this),ro(r)):jt(this),e._chunkSteps(t)}else J(r,e),jt(this)},ReadableStreamDefaultController.prototype[E]=function(){return this._queue.length>0},ReadableStreamDefaultController.prototype[W]=function(){},ReadableStreamDefaultController}();function Ot(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof Wt)}function jt(e){Bt(e)&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,jt(e)),null},function(r){return Dt(e,r),null})))}function Bt(e){var r=e._controlledReadableStream;return!!Lt(e)&&(!!e._started&&(!!($t(r)&&Z(r)>0)||Ft(e)>0))}function kt(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function At(e){if(Lt(e)){var r=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(kt(e),ro(r))}}function zt(e,r){if(Lt(e)){var t=e._controlledReadableStream;if($t(t)&&Z(t)>0)K(t,r,!1);else{var o=void 0;try{o=e._strategySizeAlgorithm(r)}catch(r){throw Dt(e,r),r}try{Oe(e,r,o)}catch(r){throw Dt(e,r),r}}jt(e)}}function Dt(e,r){var t=e._controlledReadableStream;"readable"===t._state&&(je(e),kt(e),to(t,r))}function Ft(e){var r=e._controlledReadableStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function Lt(e){var r=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===r}function It(e,r,t,o,n,i,a){r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=a,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,jt(r),null},function(e){return Dt(r,e),null})}function Mt(e){return new TypeError("ReadableStreamDefaultController.prototype.".concat(e," can only be used on a ReadableStreamDefaultController"))}function xt(e,r){return De(e._readableStreamController)?function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=!1,b=f(function(e){i=e});function h(e){m(e._closedPromise,function(r){return e!==a||(tr(o._readableStreamController,r),tr(n._readableStreamController,r),c&&p||i(void 0)),null})}function _(){yr(a)&&(B(a),h(a=X(e))),ue(a,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var t=r,a=r;if(!c&&!p)try{a=Ee(r)}catch(r){return tr(o._readableStreamController,r),tr(n._readableStreamController,r),void i(eo(e,r))}c||rr(o._readableStreamController,t),p||rr(n._readableStreamController,a),u=!1,l?y():s&&S()})},_closeSteps:function(){u=!1,c||er(o._readableStreamController),p||er(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&ar(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&ar(n._readableStreamController,0),c&&p||i(void 0)},_errorSteps:function(){u=!1}})}function v(r,t){ae(a)&&(B(a),h(a=dr(e)));var f=t?n:o,d=t?o:n;gr(a,r,1,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var o=t?p:c;if(t?c:p)o||ur(f._readableStreamController,r);else{var n=void 0;try{n=Ee(r)}catch(r){return tr(f._readableStreamController,r),tr(d._readableStreamController,r),void i(eo(e,r))}o||ur(f._readableStreamController,r),rr(d._readableStreamController,n)}u=!1,l?y():s&&S()})},_closeSteps:function(e){u=!1;var r=t?p:c,o=t?c:p;r||er(f._readableStreamController),o||er(d._readableStreamController),void 0!==e&&(r||ur(f._readableStreamController,e),!o&&d._readableStreamController._pendingPullIntos.length>0&&ar(d._readableStreamController,0)),r&&o||i(void 0)},_errorSteps:function(){u=!1}})}function y(){if(u)return l=!0,d(void 0);u=!0;var e=nr(o._readableStreamController);return null===e?_():v(e._view,!1),d(void 0)}function S(){if(u)return s=!0,d(void 0);u=!0;var e=nr(n._readableStreamController);return null===e?_():v(e._view,!0),d(void 0)}function w(o){if(c=!0,r=o,p){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function R(o){if(p=!0,t=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function T(){}return o=Jt(T,y,w),n=Jt(T,S,R),h(a),[o,n]}(e):function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=f(function(e){i=e});function b(){return u?(l=!0,d(void 0)):(u=!0,ue(a,{_chunkSteps:function(e){g(function(){l=!1;var r=e,t=e;s||zt(o._readableStreamController,r),c||zt(n._readableStreamController,t),u=!1,l&&b()})},_closeSteps:function(){u=!1,s||At(o._readableStreamController),c||At(n._readableStreamController),s&&c||i(void 0)},_errorSteps:function(){u=!1}}),d(void 0))}function h(o){if(s=!0,r=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function _(o){if(c=!0,t=o,s){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function v(){}return o=Xt(v,b,h),n=Xt(v,b,_),m(a._closedPromise,function(e){return Dt(o._readableStreamController,e),Dt(n._readableStreamController,e),s&&c||i(void 0),null}),[o,n]}(e)}function Yt(e){return o(r=e)&&void 0!==r.getReader?function(e){var r;function n(){var t;try{t=e.read()}catch(e){return p(e)}return v(t,function(e){if(!o(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function i(r){try{return d(e.cancel(r))}catch(e){return p(e)}}return r=Xt(t,n,i,0),r}(e.getReader()):function(e){var r,n=ge(e,"async");function i(){var e;try{e=Se(n)}catch(e){return p(e)}return v(d(e),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function a(e){var r,t=n.iterator;try{r=_e(t,"return")}catch(e){return p(e)}return void 0===r?d(void 0):v(w(r,t,[e]),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return r=Xt(t,i,a,0),r}(e);var r}function Qt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Nt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Ht(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Vt(e,r){if("bytes"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamType"));return e}function Ut(e,r){M(e,r);var t=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,i=null==e?void 0:e.signal;return void 0!==i&&function(e,r){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError("".concat(r," is not an AbortSignal."))}(i,"".concat(r," has member 'signal' that")),{preventAbort:Boolean(t),preventCancel:Boolean(o),preventClose:Boolean(n),signal:i}}Object.defineProperties(Wt.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),i(Wt.prototype.close,"close"),i(Wt.prototype.enqueue,"enqueue"),i(Wt.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Wt.prototype,r.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});var Gt=function(){function ReadableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=e,o=null==t?void 0:t.autoAllocateChunkSize,n=null==t?void 0:t.cancel,i=null==t?void 0:t.pull,a=null==t?void 0:t.start,u=null==t?void 0:t.type;return{autoAllocateChunkSize:void 0===o?void 0:U(o,"".concat(r," has member 'autoAllocateChunkSize' that")),cancel:void 0===n?void 0:Qt(n,t,"".concat(r," has member 'cancel' that")),pull:void 0===i?void 0:Nt(i,t,"".concat(r," has member 'pull' that")),start:void 0===a?void 0:Ht(a,t,"".concat(r," has member 'start' that")),type:void 0===u?void 0:Vt(u,"".concat(r," has member 'type' that"))}}(e,"First parameter");if(Kt(this),"bytes"===o.type){if(void 0!==t.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,r,t){var o,n,i,a=Object.create(ze.prototype);o=void 0!==r.start?function(){return r.start(a)}:function(){},n=void 0!==r.pull?function(){return r.pull(a)}:function(){return d(void 0)},i=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};var u=r.autoAllocateChunkSize;if(0===u)throw new TypeError("autoAllocateChunkSize must be greater than 0");lr(e,a,o,n,i,t,u)}(this,o,Rr(t,0))}else{var n=Tr(t);!function(e,r,t,o){var n,i,a,u=Object.create(Wt.prototype);n=void 0!==r.start?function(){return r.start(u)}:function(){},i=void 0!==r.pull?function(){return r.pull(u)}:function(){return d(void 0)},a=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)},It(e,u,n,i,a,t,o)}(this,o,Rr(t,1),n)}}return Object.defineProperty(ReadableStream.prototype,"locked",{get:function(){if(!Zt(this))throw oo("locked");return $t(this)},enumerable:!1,configurable:!0}),ReadableStream.prototype.cancel=function(e){return void 0===e&&(e=void 0),Zt(this)?$t(this)?p(new TypeError("Cannot cancel a stream that already has a reader")):eo(this,e):p(oo("cancel"))},ReadableStream.prototype.getReader=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("getReader");return void 0===function(e,r){M(e,r);var t=null==e?void 0:e.mode;return{mode:void 0===t?void 0:fr(t,"".concat(r," has member 'mode' that"))}}(e,"First parameter").mode?X(this):dr(this)},ReadableStream.prototype.pipeThrough=function(e,r){if(void 0===r&&(r={}),!Zt(this))throw oo("pipeThrough");Q(e,1,"pipeThrough");var t=function(e,r){M(e,r);var t=null==e?void 0:e.readable;N(t,"readable","ReadableWritablePair"),G(t,"".concat(r," has member 'readable' that"));var o=null==e?void 0:e.writable;return N(o,"writable","ReadableWritablePair"),jr(o,"".concat(r," has member 'writable' that")),{readable:t,writable:o}}(e,"First parameter"),o=Ut(r,"Second parameter");if($t(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Dr(t.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return y(Tt(this,t.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),t.readable},ReadableStream.prototype.pipeTo=function(e,r){if(void 0===r&&(r={}),!Zt(this))return p(oo("pipeTo"));if(void 0===e)return p("Parameter 1 is required in 'pipeTo'.");if(!zr(e))return p(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));var t;try{t=Ut(r,"Second parameter")}catch(e){return p(e)}return $t(this)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Dr(e)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Tt(this,e,t.preventClose,t.preventAbort,t.preventCancel,t.signal)},ReadableStream.prototype.tee=function(){if(!Zt(this))throw oo("tee");return fe(xt(this))},ReadableStream.prototype.values=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("values");var r,t,o,n,i,a=function(e,r){M(e,r);var t=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(t)}}(e,"First parameter");return r=this,t=a.preventCancel,o=X(r),n=new we(o,t),(i=Object.create(Te))._asyncIteratorImpl=n,i},ReadableStream.prototype[ye]=function(e){return this.values(e)},ReadableStream.from=function(e){return Yt(e)},ReadableStream}();function Xt(e,r,t,o,n){void 0===o&&(o=1),void 0===n&&(n=function(){return 1});var i=Object.create(Gt.prototype);return Kt(i),It(i,Object.create(Wt.prototype),e,r,t,o,n),i}function Jt(e,r,t){var o=Object.create(Gt.prototype);return Kt(o),lr(o,Object.create(ze.prototype),e,r,t,0,void 0),o}function Kt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Zt(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof Gt)}function $t(e){return void 0!==e._reader}function eo(e,r){if(e._disturbed=!0,"closed"===e._state)return d(void 0);if("errored"===e._state)return p(e._storedError);ro(e);var o=e._reader;if(void 0!==o&&yr(o)){var n=o._readIntoRequests;o._readIntoRequests=new R,n.forEach(function(e){e._closeSteps(void 0)})}return v(e._readableStreamController[C](r),t)}function ro(e){e._state="closed";var r=e._reader;if(void 0!==r&&(F(r),ae(r))){var t=r._readRequests;r._readRequests=new R,t.forEach(function(e){e._closeSteps()})}}function to(e,r){e._state="errored",e._storedError=r;var t=e._reader;void 0!==t&&(D(t,r),ae(t)?se(t,r):Sr(t,r))}function oo(e){return new TypeError("ReadableStream.prototype.".concat(e," can only be used on a ReadableStream"))}function no(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark;return N(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:H(t)}}Object.defineProperties(Gt,{from:{enumerable:!0}}),Object.defineProperties(Gt.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),i(Gt.from,"from"),i(Gt.prototype.cancel,"cancel"),i(Gt.prototype.getReader,"getReader"),i(Gt.prototype.pipeThrough,"pipeThrough"),i(Gt.prototype.pipeTo,"pipeTo"),i(Gt.prototype.tee,"tee"),i(Gt.prototype.values,"values"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Gt.prototype,r.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(Gt.prototype,ye,{value:Gt.prototype.values,writable:!0,configurable:!0});var io=function(e){return e.byteLength};i(io,"size");var ao=function(){function ByteLengthQueuingStrategy(e){Q(e,1,"ByteLengthQueuingStrategy"),e=no(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(ByteLengthQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!lo(this))throw uo("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(ByteLengthQueuingStrategy.prototype,"size",{get:function(){if(!lo(this))throw uo("size");return io},enumerable:!1,configurable:!0}),ByteLengthQueuingStrategy}();function uo(e){return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(e," can only be used on a ByteLengthQueuingStrategy"))}function lo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ao)}Object.defineProperties(ao.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(ao.prototype,r.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});var so=function(){return 1};i(so,"size");var co=function(){function CountQueuingStrategy(e){Q(e,1,"CountQueuingStrategy"),e=no(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(CountQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!po(this))throw fo("highWaterMark");return this._countQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(CountQueuingStrategy.prototype,"size",{get:function(){if(!po(this))throw fo("size");return so},enumerable:!1,configurable:!0}),CountQueuingStrategy}();function fo(e){return new TypeError("CountQueuingStrategy.prototype.".concat(e," can only be used on a CountQueuingStrategy"))}function po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof co)}function bo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function ho(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function _o(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function mo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}Object.defineProperties(co.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(co.prototype,r.toStringTag,{value:"CountQueuingStrategy",configurable:!0});var vo=function(){function TransformStream(e,r,t){void 0===e&&(e={}),void 0===r&&(r={}),void 0===t&&(t={}),void 0===e&&(e=null);var o=Pr(r,"Second parameter"),n=Pr(t,"Third parameter"),i=function(e,r){M(e,r);var t=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,i=null==e?void 0:e.start,a=null==e?void 0:e.transform,u=null==e?void 0:e.writableType;return{cancel:void 0===t?void 0:mo(t,e,"".concat(r," has member 'cancel' that")),flush:void 0===o?void 0:bo(o,e,"".concat(r," has member 'flush' that")),readableType:n,start:void 0===i?void 0:ho(i,e,"".concat(r," has member 'start' that")),transform:void 0===a?void 0:_o(a,e,"".concat(r," has member 'transform' that")),writableType:u}}(e,"First parameter");if(void 0!==i.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==i.writableType)throw new RangeError("Invalid writableType specified");var a,u=Rr(n,0),l=Tr(n),s=Rr(o,1),c=Tr(o);!function(e,r,t,o,n,i){function a(){return r}function u(r){return function(e,r){var t=e._transformStreamController;if(e._backpressure){return v(e._backpressureChangePromise,function(){var o=e._writable;if("erroring"===o._state)throw o._storedError;return Eo(t,r)})}return Eo(t,r)}(e,r)}function l(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._readable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(Dt(o._readableStreamController,r),Oo(t)),null},function(e){return Dt(o._readableStreamController,e),jo(t,e),null}),t._finishPromise}(e,r)}function s(){return function(e){var r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;var t=e._readable;r._finishPromise=f(function(e,t){r._finishPromise_resolve=e,r._finishPromise_reject=t});var o=r._flushAlgorithm();return Co(r),h(o,function(){return"errored"===t._state?jo(r,t._storedError):(At(t._readableStreamController),Oo(r)),null},function(e){return Dt(t._readableStreamController,e),jo(r,e),null}),r._finishPromise}(e)}function c(){return function(e){return Ro(e,!1),e._backpressureChangePromise}(e)}function d(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._writable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(it(o._writableStreamController,r),wo(e),Oo(t)),null},function(r){return it(o._writableStreamController,r),wo(e),jo(t,r),null}),t._finishPromise}(e,r)}e._writable=function(e,r,t,o,n,i){void 0===n&&(n=1),void 0===i&&(i=function(){return 1});var a=Object.create(Br.prototype);return Ar(a),rt(a,Object.create($r.prototype),e,r,t,o,n,i),a}(a,u,s,l,t,o),e._readable=Xt(a,c,d,n,i),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,Ro(e,!0),e._transformStreamController=void 0}(this,f(function(e){a=e}),s,c,u,l),function(e,r){var t,o,n,i=Object.create(To.prototype);t=void 0!==r.transform?function(e){return r.transform(e,i)}:function(e){try{return qo(i,e),d(void 0)}catch(e){return p(e)}};o=void 0!==r.flush?function(){return r.flush(i)}:function(){return d(void 0)};n=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};!function(e,r,t,o,n){r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=o,r._cancelAlgorithm=n,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}(e,i,t,o,n)}(this,i),void 0!==i.start?a(i.start(this._transformStreamController)):a(void 0)}return Object.defineProperty(TransformStream.prototype,"readable",{get:function(){if(!yo(this))throw Bo("readable");return this._readable},enumerable:!1,configurable:!0}),Object.defineProperty(TransformStream.prototype,"writable",{get:function(){if(!yo(this))throw Bo("writable");return this._writable},enumerable:!1,configurable:!0}),TransformStream}();function yo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof vo)}function go(e,r){Dt(e._readable._readableStreamController,r),So(e,r)}function So(e,r){Co(e._transformStreamController),it(e._writable._writableStreamController,r),wo(e)}function wo(e){e._backpressure&&Ro(e,!1)}function Ro(e,r){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=f(function(r){e._backpressureChangePromise_resolve=r}),e._backpressure=r}Object.defineProperties(vo.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(vo.prototype,r.toStringTag,{value:"TransformStream",configurable:!0});var To=function(){function TransformStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(TransformStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Po(this))throw Wo("desiredSize");return Ft(this._controlledTransformStream._readable._readableStreamController)},enumerable:!1,configurable:!0}),TransformStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("enqueue");qo(this,e)},TransformStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("error");var r;r=e,go(this._controlledTransformStream,r)},TransformStreamDefaultController.prototype.terminate=function(){if(!Po(this))throw Wo("terminate");!function(e){var r=e._controlledTransformStream;At(r._readable._readableStreamController);var t=new TypeError("TransformStream terminated");So(r,t)}(this)},TransformStreamDefaultController}();function Po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof To)}function Co(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function qo(e,r){var t=e._controlledTransformStream,o=t._readable._readableStreamController;if(!Lt(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{zt(o,r)}catch(e){throw So(t,e),t._readable._storedError}var n=function(e){return!Bt(e)}(o);n!==t._backpressure&&Ro(t,!0)}function Eo(e,r){return v(e._transformAlgorithm(r),void 0,function(r){throw go(e._controlledTransformStream,r),r})}function Wo(e){return new TypeError("TransformStreamDefaultController.prototype.".concat(e," can only be used on a TransformStreamDefaultController"))}function Oo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function jo(e,r){void 0!==e._finishPromise_reject&&(y(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function Bo(e){return new TypeError("TransformStream.prototype.".concat(e," can only be used on a TransformStream"))}Object.defineProperties(To.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),i(To.prototype.enqueue,"enqueue"),i(To.prototype.error,"error"),i(To.prototype.terminate,"terminate"),"symbol"==typeof r.toStringTag&&Object.defineProperty(To.prototype,r.toStringTag,{value:"TransformStreamDefaultController",configurable:!0}),e.ByteLengthQueuingStrategy=ao,e.CountQueuingStrategy=co,e.ReadableByteStreamController=ze,e.ReadableStream=Gt,e.ReadableStreamBYOBReader=_r,e.ReadableStreamBYOBRequest=Ae,e.ReadableStreamDefaultController=Wt,e.ReadableStreamDefaultReader=ee,e.TransformStream=vo,e.TransformStreamDefaultController=To,e.WritableStream=Br,e.WritableStreamDefaultController=$r,e.WritableStreamDefaultWriter=Hr}); diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..254b10dc 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -78,6 +78,7 @@ target_link_libraries(UnitTests PRIVATE Performance PRIVATE TextDecoder PRIVATE TextEncoder + PRIVATE Streams ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..6b153c59 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1541,6 +1541,162 @@ describe("Console", function () { }); }); +describe("Web Streams", function () { + // Focused ports from the WHATWG Streams WPT suites at c05b4473: + // readable-streams/general.any.js and tee.any.js, + // writable-streams/write.any.js, and transform-streams/general.any.js. + it("installs the standard stream constructors", function () { + expect(ReadableStream).to.be.a("function"); + expect(WritableStream).to.be.a("function"); + expect(TransformStream).to.be.a("function"); + expect(ByteLengthQueuingStrategy).to.be.a("function"); + expect(CountQueuingStrategy).to.be.a("function"); + }); + + it("delivers queued chunks in order and closes the reader", async function () { + const stream = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }); + const reader = stream.getReader(); + + expect(await reader.read()).to.deep.equal({ value: "a", done: false }); + expect(await reader.read()).to.deep.equal({ value: "b", done: false }); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + await reader.closed; + }); + + it("propagates a rejected pull to read and closed", async function () { + const failure = new Error("pull failed"); + const reader = new ReadableStream({ + pull() { + return Promise.reject(failure); + } + }).getReader(); + + let readFailure: unknown; + let closedFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + try { await reader.closed; } catch (error) { closedFailure = error; } + expect(readFailure).to.equal(failure); + expect(closedFailure).to.equal(failure); + }); + + it("tees without one branch consuming the other", async function () { + const [first, second] = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }).tee(); + const firstReader = first.getReader(); + const secondReader = second.getReader(); + + expect(await firstReader.read()).to.deep.equal({ value: "a", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: "b", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: undefined, done: true }); + expect(await secondReader.read()).to.deep.equal({ value: "a", done: false }); + }); + + it("waits for asynchronous writes before closing", async function () { + const stored: number[] = []; + const writable = new WritableStream({ + write(chunk) { + return Promise.resolve().then(() => stored.push(chunk)); + } + }); + const writer = writable.getWriter(); + + writer.write(1); + writer.write(2); + await writer.close(); + expect(stored).to.deep.equal([1, 2]); + }); + + it("applies transform output and backpressure", async function () { + const transform = new TransformStream({ + transform(chunk, controller) { + controller.enqueue(chunk.toUpperCase()); + } + }); + const writer = transform.writable.getWriter(); + const reader = transform.readable.getReader(); + const write = writer.write("native"); + + expect(await reader.read()).to.deep.equal({ value: "NATIVE", done: false }); + await write; + await writer.close(); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + }); + + it("supports BYOB reads from byte streams", async function () { + let sent = false; + const stream = new ReadableStream({ + type: "bytes", + pull(controller) { + if (!sent) { + sent = true; + controller.enqueue(new Uint8Array([8, 241, 48, 123, 151])); + controller.close(); + } + } + } as any); + const reader = stream.getReader({ mode: "byob" }); + const result = await reader.read(new Uint8Array(8)); + + expect(result.done).to.equal(false); + expect(Array.from(result.value!)).to.deep.equal([8, 241, 48, 123, 151]); + expect((await reader.read(new Uint8Array(8))).done).to.equal(true); + }); + + // Ported from Firefox's dom/streams/test/xpcshell/subclassing.js. + it("supports subclassed streams, readers, and queuing strategies", async function () { + class SubclassedStream extends ReadableStream {} + class SubclassedStrategy extends CountQueuingStrategy {} + const stream = new SubclassedStream({ + start(controller) { + controller.enqueue("first"); + controller.close(); + } + }); + const Reader = stream.getReader().constructor as typeof ReadableStreamDefaultReader; + class SubclassedReader extends Reader {} + + expect(stream).to.be.instanceOf(ReadableStream); + expect(new SubclassedStrategy({ highWaterMark: 4 }).highWaterMark).to.equal(4); + + const secondStream = new ReadableStream({ + start(controller) { + controller.enqueue("second"); + controller.close(); + } + }); + const reader = new SubclassedReader(secondStream); + expect(await reader.read()).to.deep.equal({ value: "second", done: false }); + }); + + // Ported from Chromium's http/tests/streams/chromium/transform-stream-enqueue.html. + it("rejects enqueues after a transform is terminated or errored", function () { + expect(() => new TransformStream({ + start(controller) { + controller.terminate(); + controller.enqueue("late"); + } + })).to.throw(TypeError); + + expect(() => new TransformStream({ + start(controller) { + controller.error(new Error("failed")); + controller.enqueue("late"); + } + })).to.throw(TypeError); + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..b71218bd 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -90,6 +91,7 @@ TEST(JavaScript, All) Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -166,6 +168,30 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } +TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); + global.Set("ReadableStream", hostReadableStream); + + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").IsFunction()); + + const auto installedTransformStream = global.Get("TransformStream"); + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 9dc464aac071b157292a34b6081b1cc59d42d45e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:26:50 -0700 Subject: [PATCH 065/174] Keep Streams implementations internally consistent Replace a partial or null host Streams surface as a complete constructor suite so stream products retain compatible instanceof relationships. Preserve a complete suite on repeated initialization.\n\nHarden the native initialization test so N-API failures complete the test promise instead of hanging, and cover partial host replacement plus null handling and cross-constructor compatibility. --- Polyfills/Streams/Source/Streams.cpp | 8 ++---- Tests/UnitTests/Shared/Shared.cpp | 42 +++++++++++++++++++++------- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp index 4552ed07..e742344f 100644 --- a/Polyfills/Streams/Source/Streams.cpp +++ b/Polyfills/Streams/Source/Streams.cpp @@ -31,7 +31,8 @@ namespace Babylon::Polyfills::Streams bool needsPonyfill{}; for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) + const auto constructor = global.Get(name.data()); + if (constructor.IsUndefined() || constructor.IsNull()) { needsPonyfill = true; break; @@ -46,10 +47,7 @@ namespace Babylon::Polyfills::Streams const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) - { - global.Set(name.data(), exports.Get(name.data())); - } + global.Set(name.data(), exports.Get(name.data())); } } } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index b71218bd..f27cad71 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -168,28 +168,50 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } -TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; + + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; - runtime.Dispatch([&done](Napi::Env env) { + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); global.Set("ReadableStream", hostReadableStream); + global.Set("TransformStream", env.Null()); Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); - EXPECT_TRUE(global.Get("TransformStream").IsFunction()); - + const auto installedReadableStream = global.Get("ReadableStream"); const auto installedTransformStream = global.Get("TransformStream"); + EXPECT_FALSE(installedReadableStream.StrictEquals(hostReadableStream)); + if (!installedReadableStream.IsFunction() || !installedTransformStream.IsFunction()) + { + complete("Streams::Initialize did not install a complete constructor suite."); + return; + } + + const auto transform = installedTransformStream.As().New({}); + EXPECT_TRUE(transform.Get("readable").As().InstanceOf(installedReadableStream.As())); + Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(installedReadableStream)); EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Console, Log) From 54c2d6e20fd10961279977ee2c81e920f3bed4a0 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 02:14:45 -0700 Subject: [PATCH 066/174] Preserve Streams bundle bytes across source splits --- Polyfills/Streams/Source/StreamsScripts.h.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 9bf7f5bf..126a23f7 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -9,9 +9,10 @@ namespace Babylon::Polyfills::Internal::StreamsScripts (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@ -)JSRHSTREAM"; +@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; + // Keep the split transparent: inserting whitespace here can divide an + // identifier or string literal when the vendored bundle is regenerated. inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ return module.exports; })() From c53aca482ab95c336d8600636ca7e956ef52f98f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 21:55:02 -0700 Subject: [PATCH 067/174] Add optional WHATWG Streams polyfill Vendor the ES5 web-streams-polyfill 4.3.0 ponyfill and expose an idempotent Streams initializer that preserves constructors supplied by the selected JavaScript engine. Cover readable, writable, transform, BYOB, error, tee, subclassing, and host-constructor behavior with focused ports from WPT plus Firefox and Chromium regression tests. Validate the implementation on JavaScriptCore under ASan/UBSan and QuickJS Release. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 6 +- Polyfills/Streams/CMakeLists.txt | 30 ++++ .../Include/Babylon/Polyfills/Streams.h | 11 ++ Polyfills/Streams/README.md | 14 ++ Polyfills/Streams/Source/Streams.cpp | 55 ++++++ Polyfills/Streams/Source/StreamsScripts.h.in | 36 ++++ .../ThirdParty/web-streams-polyfill/LICENSE | 22 +++ .../web-streams-polyfill/ponyfill.es5.js | 8 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 156 ++++++++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 26 +++ 12 files changed, 365 insertions(+), 1 deletion(-) create mode 100644 Polyfills/Streams/CMakeLists.txt create mode 100644 Polyfills/Streams/Include/Babylon/Polyfills/Streams.h create mode 100644 Polyfills/Streams/README.md create mode 100644 Polyfills/Streams/Source/Streams.cpp create mode 100644 Polyfills/Streams/Source/StreamsScripts.h.in create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..6535a653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,6 +102,7 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) +option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index a44765fb..c952cf27 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -44,4 +44,8 @@ endif() if(JSRUNTIMEHOST_POLYFILL_TEXTENCODER) add_subdirectory(TextEncoder) -endif() \ No newline at end of file +endif() + +if(JSRUNTIMEHOST_POLYFILL_STREAMS) + add_subdirectory(Streams) +endif() diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt new file mode 100644 index 00000000..6c00ed81 --- /dev/null +++ b/Polyfills/Streams/CMakeLists.txt @@ -0,0 +1,30 @@ +set(WEB_STREAMS_POLYFILL_FILE + "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/web-streams-polyfill/ponyfill.es5.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${WEB_STREAMS_POLYFILL_FILE}") +file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +configure_file( + "Source/StreamsScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Streams.h" + "Source/Streams.cpp" + "Source/StreamsScripts.h.in" + "ThirdParty/web-streams-polyfill/LICENSE" + "ThirdParty/web-streams-polyfill/ponyfill.es5.js") + +add_library(Streams ${SOURCES}) +warnings_as_errors(Streams) + +target_include_directories(Streams + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Streams PUBLIC JsRuntime) + +set_property(TARGET Streams PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h new file mode 100644 index 00000000..01e5a15c --- /dev/null +++ b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + // Installs the WHATWG Streams constructors that are not already supplied + // by the JavaScript engine. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Streams/README.md b/Polyfills/Streams/README.md new file mode 100644 index 00000000..c84a38e3 --- /dev/null +++ b/Polyfills/Streams/README.md @@ -0,0 +1,14 @@ +# Web Streams + +Installs the standard `ReadableStream`, `WritableStream`, `TransformStream`, +reader, writer, controller, and queuing-strategy globals when the selected +JavaScript engine does not provide them. + +The implementation is the ES5 ponyfill bundle from +[`web-streams-polyfill` 4.3.0](https://github.com/MattiasBuelens/web-streams-polyfill/tree/add69059ed08eae6a18559aba49575a280d1529e), +which is based on the WHATWG reference implementation. The vendored project +tests this release against the Streams portion of WPT at revision +[`c05b4473`](https://github.com/web-platform-tests/wpt/tree/c05b447326585237713013c66341eab2cdf967b6/streams). + +`Initialize` preserves any Streams constructors already supplied by the host +engine and fills only missing globals. diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp new file mode 100644 index 00000000..4552ed07 --- /dev/null +++ b/Polyfills/Streams/Source/Streams.cpp @@ -0,0 +1,55 @@ +#include + +#include "StreamsScripts.h" + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + void BABYLON_API Initialize(Napi::Env env) + { + Napi::HandleScope scope{env}; + auto global = env.Global(); + + static constexpr std::array constructorNames{ + "ReadableStream", + "ReadableStreamDefaultController", + "ReadableByteStreamController", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultReader", + "ReadableStreamBYOBReader", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", + "ByteLengthQueuingStrategy", + "CountQueuingStrategy", + "TransformStream", + "TransformStreamDefaultController", + }; + + bool needsPonyfill{}; + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + needsPonyfill = true; + break; + } + } + + if (!needsPonyfill) + { + return; + } + + const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + global.Set(name.data(), exports.Get(name.data())); + } + } + } +} diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in new file mode 100644 index 00000000..9bf7f5bf --- /dev/null +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Internal::StreamsScripts +{ + inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( +(function() { + var exports = {}; + var module = { exports: exports }; +@WEB_STREAMS_POLYFILL_SOURCE_1@ +)JSRHSTREAM"; + + inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ + return module.exports; +})() +)JSRHSTREAM"; + + template + consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + { + std::array result{}; + for (std::size_t index{}; index < Part1Size - 1; ++index) + { + result[index] = part1[index]; + } + for (std::size_t index{}; index < Part2Size; ++index) + { + result[Part1Size - 1 + index] = part2[index]; + } + return result; + } + + inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); +} diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js new file mode 100644 index 00000000..18d63683 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js @@ -0,0 +1,8 @@ +/** + * @license + * web-streams-polyfill v4.3.0 + * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors. + * This code is released under the MIT license. + * SPDX-License-Identifier: MIT + */ +!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).WebStreamsPolyfill={})}(this,function(e){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?Symbol:function(e){return"Symbol(".concat(e,")")};function t(){}function o(e){return"object"==typeof e&&null!==e||"function"==typeof e}"function"==typeof SuppressedError&&SuppressedError;var n=t;function i(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch(e){}}var a=Promise,u=Promise.resolve.bind(a),l=Promise.prototype.then,s=Promise.reject.bind(a),c=u;function f(e){return new a(e)}function d(e){return f(function(r){return r(e)})}function p(e){return s(e)}function b(e,r,t){return l.call(e,r,t)}function h(e,r,t){b(b(e,r,t),void 0,n)}function _(e,r){h(e,r)}function m(e,r){h(e,void 0,r)}function v(e,r,t){return b(e,r,t)}function y(e){b(e,void 0,n)}var g=function(e){if("function"==typeof queueMicrotask)g=queueMicrotask;else{var r=d(void 0);g=function(e){return b(r,e)}}return g(e)};function S(e,r,t){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}function w(e,r,t){try{return d(S(e,r,t))}catch(e){return p(e)}}var R=function(){function e(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}return Object.defineProperty(e.prototype,"length",{get:function(){return this._size},enumerable:!1,configurable:!0}),e.prototype.push=function(e){var r=this._back,t=r;16383===r._elements.length&&(t={_elements:[],_next:void 0}),r._elements.push(e),t!==r&&(this._back=t,r._next=t),++this._size},e.prototype.shift=function(){var e=this._front,r=e,t=this._cursor,o=t+1,n=e._elements,i=n[t];return 16384===o&&(r=e._next,o=0),--this._size,this._cursor=o,e!==r&&(this._front=r),n[t]=void 0,i},e.prototype.forEach=function(e){for(var r=this._cursor,t=this._front,o=t._elements;!(r===o.length&&void 0===t._next||r===o.length&&(r=0,0===(o=(t=t._next)._elements).length));)e(o[r]),++r},e.prototype.peek=function(){var e=this._front,r=this._cursor;return e._elements[r]},e}(),T=r("[[AbortSteps]]"),P=r("[[ErrorSteps]]"),C=r("[[CancelSteps]]"),q=r("[[PullSteps]]"),E=r("[[CanPullSyncSteps]]"),W=r("[[ReleaseSteps]]");function O(e,r){e._ownerReadableStream=r,r._reader=e,"readable"===r._state?A(e):"closed"===r._state?function(e){A(e),F(e)}(e):z(e,r._storedError)}function j(e,r){return eo(e._ownerReadableStream,r)}function B(e){var r=e._ownerReadableStream;"readable"===r._state?D(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,r){z(e,r)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[W](),r._reader=void 0,e._ownerReadableStream=void 0}function k(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function A(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t})}function z(e,r){A(e),D(e,r)}function D(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function F(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var L=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},I=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function M(e,r){if(void 0!==e&&("object"!=typeof(t=e)&&"function"!=typeof t))throw new TypeError("".concat(r," is not an object."));var t}function x(e,r){if("function"!=typeof e)throw new TypeError("".concat(r," is not a function."))}function Y(e,r){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError("".concat(r," is not an object."))}function Q(e,r,t){if(void 0===e)throw new TypeError("Parameter ".concat(r," is required in '").concat(t,"'."))}function N(e,r,t){if(void 0===e)throw new TypeError("".concat(r," is required in '").concat(t,"'."))}function H(e){return Number(e)}function V(e){return 0===e?0:e}function U(e,r){var t=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=V(o),!L(o))throw new TypeError("".concat(r," is not a finite number"));if((o=function(e){return V(I(e))}(o))<0||o>t)throw new TypeError("".concat(r," is outside the accepted range of ").concat(0," to ").concat(t,", inclusive"));return L(o)&&0!==o?o:0}function G(e,r){if(!Zt(e))throw new TypeError("".concat(r," is not a ReadableStream."))}function X(e){return new ee(e)}function J(e,r){e._reader._readRequests.push(r)}function K(e,r,t){var o=e._reader._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}function Z(e){return e._reader._readRequests.length}function $(e){var r=e._reader;return void 0!==r&&!!ae(r)}var ee=function(){function ReadableStreamDefaultReader(e){if(Q(e,1,"ReadableStreamDefaultReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");O(this,e),this._readRequests=new R}return Object.defineProperty(ReadableStreamDefaultReader.prototype,"closed",{get:function(){return ae(this)?this._closedPromise:p(ce("closed"))},enumerable:!1,configurable:!0}),ReadableStreamDefaultReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),ae(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(ce("cancel"))},ReadableStreamDefaultReader.prototype.read=function(){if(!ae(this))return p(ce("read"));if(void 0===this._ownerReadableStream)return p(k("read from"));var e=le(this)?new ie:new ne;return ue(this,e),e._promise},ReadableStreamDefaultReader.prototype.releaseLock=function(){if(!ae(this))throw ce("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");se(e,r)}(this)},ReadableStreamDefaultReader}();Object.defineProperties(ee.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(ee.prototype.cancel,"cancel"),i(ee.prototype.read,"read"),i(ee.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ee.prototype,r.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var re,te,oe,ne=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(){this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),ie=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(){this._promise=c({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function ae(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ee)}function ue(e,r){var t=e._ownerReadableStream;t._disturbed=!0,"closed"===t._state?r._closeSteps():"errored"===t._state?r._errorSteps(t._storedError):t._readableStreamController[q](r)}function le(e){var r=e._ownerReadableStream;return"closed"===r._state||("errored"===r._state||r._readableStreamController[E]())}function se(e,r){var t=e._readRequests;e._readRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function ce(e){return new TypeError("ReadableStreamDefaultReader.prototype.".concat(e," can only be used on a ReadableStreamDefaultReader"))}function fe(e){return e.slice()}function de(e,r,t,o,n){new Uint8Array(e).set(new Uint8Array(t,o,n),r)}var pe=function(e){return(pe="function"==typeof e.transfer?function(e){return e.transfer()}:"function"==typeof structuredClone?function(e){return structuredClone(e,{transfer:[e]})}:function(e){return e})(e)},be=function(e){return(be="boolean"==typeof e.detached?function(e){return e.detached}:function(e){return 0===e.byteLength})(e)};function he(e,r,t){if(e.slice)return e.slice(r,t);var o=t-r,n=new ArrayBuffer(o);return de(n,0,e,r,o),n}function _e(e,r){var t=e[r];if(null!=t){if("function"!=typeof t)throw new TypeError("".concat(String(r)," is not a function"));return t}}function me(e){try{var r=e.done,t=e.value;return b(c(t),function(e){return{done:r,value:e}})}catch(e){return p(e)}}var ve,ye=null!==(oe=null!==(re=r.asyncIterator)&&void 0!==re?re:null===(te=r.for)||void 0===te?void 0:te.call(r,"Symbol.asyncIterator"))&&void 0!==oe?oe:"@@asyncIterator";function ge(e,t,n){if(void 0===t&&(t="sync"),void 0===n)if("async"===t){if(void 0===(n=_e(e,ye)))return function(e){var r={next:function(){var r;try{r=Se(e)}catch(e){return p(e)}return me(r)},return:function(r){var t;try{var n=_e(e.iterator,"return");if(void 0===n)return d({done:!0,value:r});t=S(n,e.iterator,[r])}catch(e){return p(e)}return o(t)?me(t):p(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(ge(e,"sync",_e(e,r.iterator)))}else n=_e(e,r.iterator);if(void 0===n)throw new TypeError("The object is not iterable");var i=S(n,e,[]);if(!o(i))throw new TypeError("The iterator method must return an object");return{iterator:i,nextMethod:i.next,done:!1}}function Se(e){var r=S(e.nextMethod,e.iterator,[]);if(!o(r))throw new TypeError("The iterator.next() method must return an object");return r}var we=function(){function e(e,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=r}return e.prototype.next=function(){var e=this,r=function(){return e._nextSteps()};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,r,r):r(),this._ongoingPromise},e.prototype.return=function(e){var r=this,t=function(){return r._returnSteps(e)};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,t,t):t(),this._ongoingPromise},e.prototype._nextSteps=function(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});var e=this._reader,r=new Re(this);return ue(e,r),r._promise},e.prototype._returnSteps=function(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;var r=this._reader;if(!this._preventCancel){var t=j(r,e);return B(r),v(t,function(){return{value:e,done:!0}})}return B(r),d({value:e,done:!0})},e}(),Re=function(){function e(e){var r=this;this._iterator=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){var r=this;this._iterator._ongoingPromise=void 0,g(function(){return r._resolvePromise({value:e,done:!1})})},e.prototype._closeSteps=function(){var e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){var r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,B(r._reader),this._rejectPromise(e)},e}(),Te=((ve={next:function(){return Pe(this)?this._asyncIteratorImpl.next():p(Ce("next"))},return:function(e){return Pe(this)?this._asyncIteratorImpl.return(e):p(Ce("return"))}})[ye]=function(){return this},ve);function Pe(e){if(!o(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof we}catch(e){return!1}}function Ce(e){return new TypeError("ReadableStreamAsyncIterator.".concat(e," can only be used on a ReadableSteamAsyncIterator"))}Object.defineProperty(Te,ye,{enumerable:!1});var qe=Number.isNaN||function(e){return e!=e};function Ee(e){var r=he(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}function We(e){var r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}function Oe(e,r,t){if("number"!=typeof(o=t)||qe(o)||o<0||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:r,size:t}),e._queueTotalSize+=t}function je(e){e._queue=new R,e._queueTotalSize=0}function Be(e){return e===DataView}function ke(e){return Be(e)?1:e.BYTES_PER_ELEMENT}var Ae=function(){function ReadableStreamBYOBRequest(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamBYOBRequest.prototype,"view",{get:function(){if(!Fe(this))throw sr("view");return this._view},enumerable:!1,configurable:!0}),ReadableStreamBYOBRequest.prototype.respond=function(e){if(!Fe(this))throw sr("respond");if(Q(e,1,"respond"),e=U(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");ar(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest.prototype.respondWithNewView=function(e){if(!Fe(this))throw sr("respondWithNewView");if(Q(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");ur(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest}();Object.defineProperties(Ae.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),i(Ae.prototype.respond,"respond"),i(Ae.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Ae.prototype,r.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var ze=function(){function ReadableByteStreamController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableByteStreamController.prototype,"byobRequest",{get:function(){if(!De(this))throw cr("byobRequest");return nr(this)},enumerable:!1,configurable:!0}),Object.defineProperty(ReadableByteStreamController.prototype,"desiredSize",{get:function(){if(!De(this))throw cr("desiredSize");return ir(this)},enumerable:!1,configurable:!0}),ReadableByteStreamController.prototype.close=function(){if(!De(this))throw cr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");var e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError("The stream (in ".concat(e," state) is not in the readable state and cannot be closed"));er(this)},ReadableByteStreamController.prototype.enqueue=function(e){if(!De(this))throw cr("enqueue");if(Q(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");var r=this._controlledReadableByteStream._state;if("readable"!==r)throw new TypeError("The stream (in ".concat(r," state) is not in the readable state and cannot be enqueued to"));rr(this,e)},ReadableByteStreamController.prototype.error=function(e){if(void 0===e&&(e=void 0),!De(this))throw cr("error");tr(this,e)},ReadableByteStreamController.prototype[C]=function(e){Ie(this),je(this);var r=this._cancelAlgorithm(e);return $e(this),r},ReadableByteStreamController.prototype[q]=function(e){var r=this._controlledReadableByteStream;if(this._queueTotalSize>0)or(this,e);else{var t=this._autoAllocateChunkSize;if(void 0!==t){var o=void 0;try{o=new ArrayBuffer(t)}catch(r){return void e._errorSteps(r)}var n={buffer:o,bufferByteLength:t,byteOffset:0,byteLength:t,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(n)}J(r,e),Le(this)}},ReadableByteStreamController.prototype[E]=function(){return this._queueTotalSize>0},ReadableByteStreamController.prototype[W]=function(){if(this._pendingPullIntos.length>0){var e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new R,this._pendingPullIntos.push(e)}},ReadableByteStreamController}();function De(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ze)}function Fe(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof Ae)}function Le(e){var r=function(e){var r=e._controlledReadableByteStream;if("readable"!==r._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if($(r)&&Z(r)>0)return!0;if(hr(r)&&br(r)>0)return!0;var t=ir(e);if(t>0)return!0;return!1}(e);r&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Le(e)),null},function(r){return tr(e,r),null})))}function Ie(e){Xe(e),e._pendingPullIntos=new R}function Me(e,r){var t=!1;"closed"===e._state&&(t=!0);var o=Ye(r);"default"===r.readerType?K(e,o,t):function(e,r,t){var o=e._reader,n=o._readIntoRequests.shift();t?n._closeSteps(r):n._chunkSteps(r)}(e,o,t)}function xe(e,r){for(var t=0;t0&&Ne(e,r.buffer,r.byteOffset,r.bytesFilled),Ze(e)}function Ve(e,r){var t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),o=r.bytesFilled+t,n=t,i=!1,a=o-o%r.elementSize;a>=r.minimumFill&&(n=a-r.bytesFilled,i=!0);for(var u=e._queue;n>0;){var l=u.peek(),s=Math.min(n,l.byteLength),c=r.byteOffset+r.bytesFilled;de(r.buffer,c,l.buffer,l.byteOffset,s),l.byteLength===s?u.shift():(l.byteOffset+=s,l.byteLength-=s),e._queueTotalSize-=s,Ue(e,s,r),n-=s}return i}function Ue(e,r,t){t.bytesFilled+=r}function Ge(e){0===e._queueTotalSize&&e._closeRequested?($e(e),ro(e._controlledReadableByteStream)):Le(e)}function Xe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Je(e){for(var r=[];e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){var t=e._pendingPullIntos.peek();Ve(e,t)&&(Ze(e),r.push(t))}return r}function Ke(e,r){var t=e._pendingPullIntos.peek();Xe(e),"closed"===e._controlledReadableByteStream._state?function(e,r){"none"===r.readerType&&Ze(e);var t=e._controlledReadableByteStream;if(hr(t)){for(var o=[];o.length0){var n=t.byteOffset+t.bytesFilled;Ne(e,t.buffer,n-o,o)}t.bytesFilled-=o;var i=Je(e);Me(e._controlledReadableByteStream,t),xe(e._controlledReadableByteStream,i)}}else{He(e,t);var a=Je(e);xe(e._controlledReadableByteStream,a)}}(e,r,t),Le(e)}function Ze(e){return e._pendingPullIntos.shift()}function $e(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function er(e){var r=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===r._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){var t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){var o=new TypeError("Insufficient bytes to fill elements in the given buffer");throw tr(e,o),o}}$e(e),ro(r)}}function rr(e,r){var t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state){var o=r.buffer,n=r.byteOffset,i=r.byteLength;if(be(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");var a=pe(o);if(e._pendingPullIntos.length>0){var u=e._pendingPullIntos.peek();if(be(u.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Xe(e),u.buffer=pe(u.buffer),"none"===u.readerType&&He(e,u)}if($(t))if(function(e){for(var r=e._controlledReadableByteStream._reader;r._readRequests.length>0;){if(0===e._queueTotalSize)return;or(e,r._readRequests.shift())}}(e),0===Z(t))Qe(e,a,n,i);else e._pendingPullIntos.length>0&&Ze(e),K(t,new Uint8Array(a,n,i),!1);else if(hr(t)){Qe(e,a,n,i),xe(t,Je(e))}else Qe(e,a,n,i);Le(e)}}function tr(e,r){var t=e._controlledReadableByteStream;"readable"===t._state&&(Ie(e),je(e),$e(e),to(t,r))}function or(e,r){var t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ge(e);var o=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(o)}function nr(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){var r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),o=Object.create(Ae.prototype);!function(e,r,t){e._associatedReadableByteStreamController=r,e._view=t}(o,e,t),e._byobRequest=o}return e._byobRequest}function ir(e){var r=e._controlledReadableByteStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function ar(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===r)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=pe(t.buffer),Ke(e,r)}function ur(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===r.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");var o=r.byteLength;t.buffer=pe(r.buffer),Ke(e,o)}function lr(e,r,t,o,n,i,a){r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,je(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,r._autoAllocateChunkSize=a,r._pendingPullIntos=new R,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,Le(r),null},function(e){return tr(r,e),null})}function sr(e){return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(e," can only be used on a ReadableStreamBYOBRequest"))}function cr(e){return new TypeError("ReadableByteStreamController.prototype.".concat(e," can only be used on a ReadableByteStreamController"))}function fr(e,r){if("byob"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamReaderMode"));return e}function dr(e){return new _r(e)}function pr(e,r){e._reader._readIntoRequests.push(r)}function br(e){return e._reader._readIntoRequests.length}function hr(e){var r=e._reader;return void 0!==r&&!!yr(r)}Object.defineProperties(ze.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),i(ze.prototype.close,"close"),i(ze.prototype.enqueue,"enqueue"),i(ze.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ze.prototype,r.toStringTag,{value:"ReadableByteStreamController",configurable:!0});var _r=function(){function ReadableStreamBYOBReader(e){if(Q(e,1,"ReadableStreamBYOBReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!De(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");O(this,e),this._readIntoRequests=new R}return Object.defineProperty(ReadableStreamBYOBReader.prototype,"closed",{get:function(){return yr(this)?this._closedPromise:p(wr("closed"))},enumerable:!1,configurable:!0}),ReadableStreamBYOBReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),yr(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(wr("cancel"))},ReadableStreamBYOBReader.prototype.read=function(e,r){if(void 0===r&&(r={}),!yr(this))return p(wr("read"));if(!ArrayBuffer.isView(e))return p(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return p(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return p(new TypeError("view's buffer must have non-zero byteLength"));if(be(e.buffer))return p(new TypeError("view's buffer has been detached"));var t;try{t=function(e,r){var t;return M(e,r),{min:U(null!==(t=null==e?void 0:e.min)&&void 0!==t?t:1,"".concat(r," has member 'min' that"))}}(r,"options")}catch(e){return p(e)}var o=t.min;if(0===o)return p(new TypeError("options.min must be greater than 0"));if(function(e){return Be(e.constructor)}(e)){if(o>e.byteLength)return p(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return p(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return p(k("read from"));var n=function(e,r,t){var o=e._ownerReadableStream;return"errored"===o._state||function(e,r,t){var o=e._controlledReadableByteStream,n=ke(r.constructor);r.byteLength;var i=t*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,r,t)}(this,e,o)?new vr:new mr;return gr(this,e,o,n),n._promise},ReadableStreamBYOBReader.prototype.releaseLock=function(){if(!yr(this))throw wr("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");Sr(e,r)}(this)},ReadableStreamBYOBReader}();Object.defineProperties(_r.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(_r.prototype.cancel,"cancel"),i(_r.prototype.read,"read"),i(_r.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(_r.prototype,r.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var mr=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(e){this._resolvePromise({value:e,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),vr=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(e){this._promise=c({value:e,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function yr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof _r)}function gr(e,r,t,o){var n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,r,t,o){var n,i=e._controlledReadableByteStream,a=r.constructor,u=ke(a),l=r.byteOffset,s=r.byteLength,c=t*u;try{n=pe(r.buffer)}catch(p){return void o._errorSteps(p)}var f={buffer:n,bufferByteLength:n.byteLength,byteOffset:l,byteLength:s,bytesFilled:0,minimumFill:c,elementSize:u,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(f),void pr(i,o);if("closed"!==i._state){if(e._queueTotalSize>0){if(Ve(e,f)){var d=Ye(f);return Ge(e),void o._chunkSteps(d)}if(e._closeRequested){var p=new TypeError("Insufficient bytes to fill elements in the given buffer");return tr(e,p),void o._errorSteps(p)}}e._pendingPullIntos.push(f),pr(i,o),Le(e)}else{var b=new a(f.buffer,f.byteOffset,0);o._closeSteps(b)}}(n._readableStreamController,r,t,o)}function Sr(e,r){var t=e._readIntoRequests;e._readIntoRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function wr(e){return new TypeError("ReadableStreamBYOBReader.prototype.".concat(e," can only be used on a ReadableStreamBYOBReader"))}function Rr(e,r){var t=e.highWaterMark;if(void 0===t)return r;if(qe(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}function Tr(e){var r=e.size;return r||function(){return 1}}function Pr(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===t?void 0:H(t),size:void 0===o?void 0:Cr(o,"".concat(r," has member 'size' that"))}}function Cr(e,r){return x(e,r),function(r){return H(e(r))}}function qr(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Er(e,r,t){return x(e,t),function(){return w(e,r,[])}}function Wr(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Or(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function jr(e,r){if(!zr(e))throw new TypeError("".concat(r," is not a WritableStream."))}var Br=function(){function WritableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,i=null==e?void 0:e.type,a=null==e?void 0:e.write;return{abort:void 0===t?void 0:qr(t,e,"".concat(r," has member 'abort' that")),close:void 0===o?void 0:Er(o,e,"".concat(r," has member 'close' that")),start:void 0===n?void 0:Wr(n,e,"".concat(r," has member 'start' that")),write:void 0===a?void 0:Or(a,e,"".concat(r," has member 'write' that")),type:i}}(e,"First parameter");if(Ar(this),void 0!==o.type)throw new RangeError("Invalid type is specified");var n=Tr(t);!function(e,r,t,o){var n,i,a,u,l=Object.create($r.prototype);n=void 0!==r.start?function(){return r.start(l)}:function(){};i=void 0!==r.write?function(e){return r.write(e,l)}:function(){return d(void 0)};a=void 0!==r.close?function(){return r.close()}:function(){return d(void 0)};u=void 0!==r.abort?function(e){return r.abort(e)}:function(){return d(void 0)};rt(e,l,n,i,a,u,t,o)}(this,o,Rr(t,1),n)}return Object.defineProperty(WritableStream.prototype,"locked",{get:function(){if(!zr(this))throw lt("locked");return Dr(this)},enumerable:!1,configurable:!0}),WritableStream.prototype.abort=function(e){return void 0===e&&(e=void 0),zr(this)?Dr(this)?p(new TypeError("Cannot abort a stream that already has a writer")):Fr(this,e):p(lt("abort"))},WritableStream.prototype.close=function(){return zr(this)?Dr(this)?p(new TypeError("Cannot close a stream that already has a writer")):Yr(this)?p(new TypeError("Cannot close an already-closing stream")):Lr(this):p(lt("close"))},WritableStream.prototype.getWriter=function(){if(!zr(this))throw lt("getWriter");return kr(this)},WritableStream}();function kr(e){return new Hr(e)}function Ar(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new R,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function zr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof Br)}function Dr(e){return void 0!==e._writer}function Fr(e,r){var t;if("closed"===e._state||"errored"===e._state)return d(void 0);e._writableStreamController._abortReason=r,null===(t=e._writableStreamController._abortController)||void 0===t||t.abort(r);var o=e._state;if("closed"===o||"errored"===o)return d(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;var n=!1;"erroring"===o&&(n=!0,r=void 0);var i=f(function(t,o){e._pendingAbortRequest={_promise:void 0,_resolve:t,_reject:o,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=i,n||Mr(e,r),i}function Lr(e){var r=e._state;if("closed"===r||"errored"===r)return p(new TypeError("The stream (in ".concat(r," state) is not in the writable state and cannot be closed")));var t,o=f(function(r,t){var o={_resolve:r,_reject:t};e._closeRequest=o}),n=e._writer;return void 0!==n&&e._backpressure&&"writable"===r&>(n),Oe(t=e._writableStreamController,Zr,0),nt(t),o}function Ir(e,r){"writable"!==e._state?xr(e):Mr(e,r)}function Mr(e,r){var t=e._writableStreamController;e._state="erroring",e._storedError=r;var o=e._writer;void 0!==o&&Xr(o,r),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&t._started&&xr(e)}function xr(e){e._state="errored",e._writableStreamController[P]();var r=e._storedError;if(e._writeRequests.forEach(function(e){e._reject(r)}),e._writeRequests=new R,void 0!==e._pendingAbortRequest){var t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring)return t._reject(r),void Qr(e);h(e._writableStreamController[T](t._reason),function(){return t._resolve(),Qr(e),null},function(r){return t._reject(r),Qr(e),null})}else Qr(e)}function Yr(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function Qr(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);var r=e._writer;void 0!==r&&bt(r,e._storedError)}function Nr(e,r){var t=e._writer;void 0!==t&&r!==e._backpressure&&(r?function(e){_t(e)}(t):gt(t)),e._backpressure=r}Object.defineProperties(Br.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),i(Br.prototype.abort,"abort"),i(Br.prototype.close,"close"),i(Br.prototype.getWriter,"getWriter"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Br.prototype,r.toStringTag,{value:"WritableStream",configurable:!0});var Hr=function(){function WritableStreamDefaultWriter(e){if(Q(e,1,"WritableStreamDefaultWriter"),jr(e,"First parameter"),Dr(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;var r,t=e._state;if("writable"===t)!Yr(e)&&e._backpressure?_t(this):vt(this),dt(this);else if("erroring"===t)mt(this,e._storedError),dt(this);else if("closed"===t)vt(this),dt(r=this),ht(r);else{var o=e._storedError;mt(this,o),pt(this,o)}}return Object.defineProperty(WritableStreamDefaultWriter.prototype,"closed",{get:function(){return Vr(this)?this._closedPromise:p(ct("closed"))},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"desiredSize",{get:function(){if(!Vr(this))throw ct("desiredSize");if(void 0===this._ownerWritableStream)throw ft("desiredSize");return function(e){var r=e._ownerWritableStream,t=r._state;if("errored"===t||"erroring"===t)return null;if("closed"===t)return 0;return ot(r._writableStreamController)}(this)},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"ready",{get:function(){return Vr(this)?this._readyPromise:p(ct("ready"))},enumerable:!1,configurable:!0}),WritableStreamDefaultWriter.prototype.abort=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("abort")):function(e,r){return Fr(e._ownerWritableStream,r)}(this,e):p(ct("abort"))},WritableStreamDefaultWriter.prototype.close=function(){if(!Vr(this))return p(ct("close"));var e=this._ownerWritableStream;return void 0===e?p(ft("close")):Yr(e)?p(new TypeError("Cannot close an already-closing stream")):Ur(this)},WritableStreamDefaultWriter.prototype.releaseLock=function(){if(!Vr(this))throw ct("releaseLock");void 0!==this._ownerWritableStream&&Jr(this)},WritableStreamDefaultWriter.prototype.write=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("write to")):Kr(this,e):p(ct("write"))},WritableStreamDefaultWriter}();function Vr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof Hr)}function Ur(e){return Lr(e._ownerWritableStream)}function Gr(e,r){"pending"===e._closedPromiseState?bt(e,r):function(e,r){pt(e,r)}(e,r)}function Xr(e,r){"pending"===e._readyPromiseState?yt(e,r):function(e,r){mt(e,r)}(e,r)}function Jr(e){var r=e._ownerWritableStream,t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Xr(e,t),Gr(e,t),r._writer=void 0,e._ownerWritableStream=void 0}function Kr(e,r){var t=e._ownerWritableStream,o=t._writableStreamController,n=function(e,r){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(r)}catch(r){return it(e,r),1}}(o,r);if(t!==e._ownerWritableStream)return p(ft("write to"));var i=t._state;if("errored"===i)return p(t._storedError);if(Yr(t)||"closed"===i)return p(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===i)return p(t._storedError);var a=function(e){return f(function(r,t){var o={_resolve:r,_reject:t};e._writeRequests.push(o)})}(t);return function(e,r,t){try{Oe(e,r,t)}catch(r){return void it(e,r)}var o=e._controlledWritableStream;if(!Yr(o)&&"writable"===o._state){Nr(o,at(e))}nt(e)}(o,r,n),a}Object.defineProperties(Hr.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),i(Hr.prototype.abort,"abort"),i(Hr.prototype.close,"close"),i(Hr.prototype.releaseLock,"releaseLock"),i(Hr.prototype.write,"write"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Hr.prototype,r.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});var Zr={},$r=function(){function WritableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(WritableStreamDefaultController.prototype,"abortReason",{get:function(){if(!et(this))throw st("abortReason");return this._abortReason},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultController.prototype,"signal",{get:function(){if(!et(this))throw st("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal},enumerable:!1,configurable:!0}),WritableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!et(this))throw st("error");"writable"===this._controlledWritableStream._state&&ut(this,e)},WritableStreamDefaultController.prototype[T]=function(e){var r=this._abortAlgorithm(e);return tt(this),r},WritableStreamDefaultController.prototype[P]=function(){je(this)},WritableStreamDefaultController}();function et(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof $r)}function rt(e,r,t,o,n,i,a,u){r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._abortReason=void 0,r._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),r._started=!1,r._strategySizeAlgorithm=u,r._strategyHWM=a,r._writeAlgorithm=o,r._closeAlgorithm=n,r._abortAlgorithm=i;var l=at(r);Nr(e,l),h(d(t()),function(){return r._started=!0,nt(r),null},function(t){return r._started=!0,Ir(e,t),null})}function tt(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ot(e){return e._strategyHWM-e._queueTotalSize}function nt(e){var r=e._controlledWritableStream;if(e._started&&void 0===r._inFlightWriteRequest)if("erroring"!==r._state){if(0!==e._queue.length){var t=e._queue.peek().value;t===Zr?function(e){var r=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(r),We(e);var t=e._closeAlgorithm();tt(e),h(t,function(){return function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";var r=e._writer;void 0!==r&&ht(r)}(r),null},function(e){return function(e,r){e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Ir(e,r)}(r,e),null})}(e):function(e,r){var t=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(t);var o=e._writeAlgorithm(r);h(o,function(){!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(t);var r=t._state;if(We(e),!Yr(t)&&"writable"===r){var o=at(e);Nr(t,o)}return nt(e),null},function(r){return"writable"===t._state&&tt(e),function(e,r){e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,Ir(e,r)}(t,r),null})}(e,t)}}else xr(r)}function it(e,r){"writable"===e._controlledWritableStream._state&&ut(e,r)}function at(e){return ot(e)<=0}function ut(e,r){var t=e._controlledWritableStream;tt(e),Mr(t,r)}function lt(e){return new TypeError("WritableStream.prototype.".concat(e," can only be used on a WritableStream"))}function st(e){return new TypeError("WritableStreamDefaultController.prototype.".concat(e," can only be used on a WritableStreamDefaultController"))}function ct(e){return new TypeError("WritableStreamDefaultWriter.prototype.".concat(e," can only be used on a WritableStreamDefaultWriter"))}function ft(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function dt(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}function pt(e,r){dt(e),bt(e,r)}function bt(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ht(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function _t(e){e._readyPromise=f(function(r,t){e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}function mt(e,r){_t(e),yt(e,r)}function vt(e){_t(e),gt(e)}function yt(e,r){void 0!==e._readyPromise_reject&&(y(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function gt(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties($r.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty($r.prototype,r.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});var St="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;var wt,Rt=(function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(wt=null==St?void 0:St.DOMException)?wt:void 0)||function(){var e=function(e,r){this.message=e||"",this.name=r||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return i(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function Tt(e,r,t,o,n,i){var a=X(e),u=kr(r);e._disturbed=!0;var l=new Pt(u),s=new qt(l);return f(function(c,m){var v,g,S,w;if(void 0!==i){if(v=function(){var t=void 0!==i.reason?i.reason:new Rt("Aborted","AbortError"),a=[];o||a.push(function(){return"writable"===r._state?Fr(r,t):d(void 0)}),n||a.push(function(){return"readable"===e._state?eo(e,t):d(void 0)}),P(function(){return Promise.all(a.map(function(e){return e()}))},!0,t)},i.aborted)return void v();i.addEventListener("abort",v)}function R(){for(;!l._shuttingDown&&!r._backpressure&&"writable"===r._state&&!Yr(r)&&"readable"===e._state&&le(a);)ue(a,s);if(l._shuttingDown)return d(!0);if(r._backpressure)return b(u._readyPromise,R);var t=new Ct(l);return ue(a,t),t._promise}if(Et(e,a._closedPromise,function(e){return o?C(!0,e):P(function(){return Fr(r,e)},!0,e),null}),Et(r,u._closedPromise,function(r){return n?C(!0,r):P(function(){return eo(e,r)},!0,r),null}),g=e,S=a._closedPromise,w=function(){return t?C():P(function(){return function(e){var r=e._ownerWritableStream,t=r._state;return Yr(r)||"closed"===t?d(void 0):"errored"===t?p(r._storedError):Ur(e)}(u)}),null},"closed"===g._state?w():_(S,w),Yr(r)||"closed"===r._state){var T=new TypeError("the destination writable stream closed before all data could be piped to it");n?C(!0,T):P(function(){return eo(e,T)},!0,T)}function P(e,t,o){function n(){return h(e(),function(){return q(t,o)},function(e){return q(!0,e)}),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?n():_(l._waitForWritesToFinish(),n))}function C(e,t){l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?q(e,t):_(l._waitForWritesToFinish(),function(){return q(e,t)}))}function q(e,r){return Jr(u),B(a),void 0!==i&&i.removeEventListener("abort",v),e?m(r):c(void 0),null}y(f(function(e,r){!function t(o){o?e():b(R(),t,r)}(!1)}))})}var Pt=function(){function e(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=d(void 0)}return e.prototype._waitForWritesToFinish=function(){var e=this,r=this._currentWrite;return b(this._currentWrite,function(){return r!==e._currentWrite?e._waitForWritesToFinish():void 0})},e}(),Ct=function(){function e(e){var r=this;this._state=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t),this._resolvePromise(!1)},e.prototype._closeSteps=function(){this._resolvePromise(!0)},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),qt=function(){function e(e){this._state=e}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t)},e.prototype._closeSteps=function(){},e.prototype._errorSteps=function(e){},e}();function Et(e,r,t){"errored"===e._state?t(e._storedError):m(r,t)}var Wt=function(){function ReadableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Ot(this))throw Mt("desiredSize");return Ft(this)},enumerable:!1,configurable:!0}),ReadableStreamDefaultController.prototype.close=function(){if(!Ot(this))throw Mt("close");if(!Lt(this))throw new TypeError("The stream is not in a state that permits close");At(this)},ReadableStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("enqueue");if(!Lt(this))throw new TypeError("The stream is not in a state that permits enqueue");return zt(this,e)},ReadableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("error");Dt(this,e)},ReadableStreamDefaultController.prototype[C]=function(e){je(this);var r=this._cancelAlgorithm(e);return kt(this),r},ReadableStreamDefaultController.prototype[q]=function(e){var r=this._controlledReadableStream;if(this._queue.length>0){var t=We(this);this._closeRequested&&0===this._queue.length?(kt(this),ro(r)):jt(this),e._chunkSteps(t)}else J(r,e),jt(this)},ReadableStreamDefaultController.prototype[E]=function(){return this._queue.length>0},ReadableStreamDefaultController.prototype[W]=function(){},ReadableStreamDefaultController}();function Ot(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof Wt)}function jt(e){Bt(e)&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,jt(e)),null},function(r){return Dt(e,r),null})))}function Bt(e){var r=e._controlledReadableStream;return!!Lt(e)&&(!!e._started&&(!!($t(r)&&Z(r)>0)||Ft(e)>0))}function kt(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function At(e){if(Lt(e)){var r=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(kt(e),ro(r))}}function zt(e,r){if(Lt(e)){var t=e._controlledReadableStream;if($t(t)&&Z(t)>0)K(t,r,!1);else{var o=void 0;try{o=e._strategySizeAlgorithm(r)}catch(r){throw Dt(e,r),r}try{Oe(e,r,o)}catch(r){throw Dt(e,r),r}}jt(e)}}function Dt(e,r){var t=e._controlledReadableStream;"readable"===t._state&&(je(e),kt(e),to(t,r))}function Ft(e){var r=e._controlledReadableStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function Lt(e){var r=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===r}function It(e,r,t,o,n,i,a){r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=a,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,jt(r),null},function(e){return Dt(r,e),null})}function Mt(e){return new TypeError("ReadableStreamDefaultController.prototype.".concat(e," can only be used on a ReadableStreamDefaultController"))}function xt(e,r){return De(e._readableStreamController)?function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=!1,b=f(function(e){i=e});function h(e){m(e._closedPromise,function(r){return e!==a||(tr(o._readableStreamController,r),tr(n._readableStreamController,r),c&&p||i(void 0)),null})}function _(){yr(a)&&(B(a),h(a=X(e))),ue(a,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var t=r,a=r;if(!c&&!p)try{a=Ee(r)}catch(r){return tr(o._readableStreamController,r),tr(n._readableStreamController,r),void i(eo(e,r))}c||rr(o._readableStreamController,t),p||rr(n._readableStreamController,a),u=!1,l?y():s&&S()})},_closeSteps:function(){u=!1,c||er(o._readableStreamController),p||er(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&ar(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&ar(n._readableStreamController,0),c&&p||i(void 0)},_errorSteps:function(){u=!1}})}function v(r,t){ae(a)&&(B(a),h(a=dr(e)));var f=t?n:o,d=t?o:n;gr(a,r,1,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var o=t?p:c;if(t?c:p)o||ur(f._readableStreamController,r);else{var n=void 0;try{n=Ee(r)}catch(r){return tr(f._readableStreamController,r),tr(d._readableStreamController,r),void i(eo(e,r))}o||ur(f._readableStreamController,r),rr(d._readableStreamController,n)}u=!1,l?y():s&&S()})},_closeSteps:function(e){u=!1;var r=t?p:c,o=t?c:p;r||er(f._readableStreamController),o||er(d._readableStreamController),void 0!==e&&(r||ur(f._readableStreamController,e),!o&&d._readableStreamController._pendingPullIntos.length>0&&ar(d._readableStreamController,0)),r&&o||i(void 0)},_errorSteps:function(){u=!1}})}function y(){if(u)return l=!0,d(void 0);u=!0;var e=nr(o._readableStreamController);return null===e?_():v(e._view,!1),d(void 0)}function S(){if(u)return s=!0,d(void 0);u=!0;var e=nr(n._readableStreamController);return null===e?_():v(e._view,!0),d(void 0)}function w(o){if(c=!0,r=o,p){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function R(o){if(p=!0,t=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function T(){}return o=Jt(T,y,w),n=Jt(T,S,R),h(a),[o,n]}(e):function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=f(function(e){i=e});function b(){return u?(l=!0,d(void 0)):(u=!0,ue(a,{_chunkSteps:function(e){g(function(){l=!1;var r=e,t=e;s||zt(o._readableStreamController,r),c||zt(n._readableStreamController,t),u=!1,l&&b()})},_closeSteps:function(){u=!1,s||At(o._readableStreamController),c||At(n._readableStreamController),s&&c||i(void 0)},_errorSteps:function(){u=!1}}),d(void 0))}function h(o){if(s=!0,r=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function _(o){if(c=!0,t=o,s){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function v(){}return o=Xt(v,b,h),n=Xt(v,b,_),m(a._closedPromise,function(e){return Dt(o._readableStreamController,e),Dt(n._readableStreamController,e),s&&c||i(void 0),null}),[o,n]}(e)}function Yt(e){return o(r=e)&&void 0!==r.getReader?function(e){var r;function n(){var t;try{t=e.read()}catch(e){return p(e)}return v(t,function(e){if(!o(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function i(r){try{return d(e.cancel(r))}catch(e){return p(e)}}return r=Xt(t,n,i,0),r}(e.getReader()):function(e){var r,n=ge(e,"async");function i(){var e;try{e=Se(n)}catch(e){return p(e)}return v(d(e),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function a(e){var r,t=n.iterator;try{r=_e(t,"return")}catch(e){return p(e)}return void 0===r?d(void 0):v(w(r,t,[e]),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return r=Xt(t,i,a,0),r}(e);var r}function Qt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Nt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Ht(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Vt(e,r){if("bytes"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamType"));return e}function Ut(e,r){M(e,r);var t=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,i=null==e?void 0:e.signal;return void 0!==i&&function(e,r){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError("".concat(r," is not an AbortSignal."))}(i,"".concat(r," has member 'signal' that")),{preventAbort:Boolean(t),preventCancel:Boolean(o),preventClose:Boolean(n),signal:i}}Object.defineProperties(Wt.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),i(Wt.prototype.close,"close"),i(Wt.prototype.enqueue,"enqueue"),i(Wt.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Wt.prototype,r.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});var Gt=function(){function ReadableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=e,o=null==t?void 0:t.autoAllocateChunkSize,n=null==t?void 0:t.cancel,i=null==t?void 0:t.pull,a=null==t?void 0:t.start,u=null==t?void 0:t.type;return{autoAllocateChunkSize:void 0===o?void 0:U(o,"".concat(r," has member 'autoAllocateChunkSize' that")),cancel:void 0===n?void 0:Qt(n,t,"".concat(r," has member 'cancel' that")),pull:void 0===i?void 0:Nt(i,t,"".concat(r," has member 'pull' that")),start:void 0===a?void 0:Ht(a,t,"".concat(r," has member 'start' that")),type:void 0===u?void 0:Vt(u,"".concat(r," has member 'type' that"))}}(e,"First parameter");if(Kt(this),"bytes"===o.type){if(void 0!==t.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,r,t){var o,n,i,a=Object.create(ze.prototype);o=void 0!==r.start?function(){return r.start(a)}:function(){},n=void 0!==r.pull?function(){return r.pull(a)}:function(){return d(void 0)},i=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};var u=r.autoAllocateChunkSize;if(0===u)throw new TypeError("autoAllocateChunkSize must be greater than 0");lr(e,a,o,n,i,t,u)}(this,o,Rr(t,0))}else{var n=Tr(t);!function(e,r,t,o){var n,i,a,u=Object.create(Wt.prototype);n=void 0!==r.start?function(){return r.start(u)}:function(){},i=void 0!==r.pull?function(){return r.pull(u)}:function(){return d(void 0)},a=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)},It(e,u,n,i,a,t,o)}(this,o,Rr(t,1),n)}}return Object.defineProperty(ReadableStream.prototype,"locked",{get:function(){if(!Zt(this))throw oo("locked");return $t(this)},enumerable:!1,configurable:!0}),ReadableStream.prototype.cancel=function(e){return void 0===e&&(e=void 0),Zt(this)?$t(this)?p(new TypeError("Cannot cancel a stream that already has a reader")):eo(this,e):p(oo("cancel"))},ReadableStream.prototype.getReader=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("getReader");return void 0===function(e,r){M(e,r);var t=null==e?void 0:e.mode;return{mode:void 0===t?void 0:fr(t,"".concat(r," has member 'mode' that"))}}(e,"First parameter").mode?X(this):dr(this)},ReadableStream.prototype.pipeThrough=function(e,r){if(void 0===r&&(r={}),!Zt(this))throw oo("pipeThrough");Q(e,1,"pipeThrough");var t=function(e,r){M(e,r);var t=null==e?void 0:e.readable;N(t,"readable","ReadableWritablePair"),G(t,"".concat(r," has member 'readable' that"));var o=null==e?void 0:e.writable;return N(o,"writable","ReadableWritablePair"),jr(o,"".concat(r," has member 'writable' that")),{readable:t,writable:o}}(e,"First parameter"),o=Ut(r,"Second parameter");if($t(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Dr(t.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return y(Tt(this,t.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),t.readable},ReadableStream.prototype.pipeTo=function(e,r){if(void 0===r&&(r={}),!Zt(this))return p(oo("pipeTo"));if(void 0===e)return p("Parameter 1 is required in 'pipeTo'.");if(!zr(e))return p(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));var t;try{t=Ut(r,"Second parameter")}catch(e){return p(e)}return $t(this)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Dr(e)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Tt(this,e,t.preventClose,t.preventAbort,t.preventCancel,t.signal)},ReadableStream.prototype.tee=function(){if(!Zt(this))throw oo("tee");return fe(xt(this))},ReadableStream.prototype.values=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("values");var r,t,o,n,i,a=function(e,r){M(e,r);var t=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(t)}}(e,"First parameter");return r=this,t=a.preventCancel,o=X(r),n=new we(o,t),(i=Object.create(Te))._asyncIteratorImpl=n,i},ReadableStream.prototype[ye]=function(e){return this.values(e)},ReadableStream.from=function(e){return Yt(e)},ReadableStream}();function Xt(e,r,t,o,n){void 0===o&&(o=1),void 0===n&&(n=function(){return 1});var i=Object.create(Gt.prototype);return Kt(i),It(i,Object.create(Wt.prototype),e,r,t,o,n),i}function Jt(e,r,t){var o=Object.create(Gt.prototype);return Kt(o),lr(o,Object.create(ze.prototype),e,r,t,0,void 0),o}function Kt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Zt(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof Gt)}function $t(e){return void 0!==e._reader}function eo(e,r){if(e._disturbed=!0,"closed"===e._state)return d(void 0);if("errored"===e._state)return p(e._storedError);ro(e);var o=e._reader;if(void 0!==o&&yr(o)){var n=o._readIntoRequests;o._readIntoRequests=new R,n.forEach(function(e){e._closeSteps(void 0)})}return v(e._readableStreamController[C](r),t)}function ro(e){e._state="closed";var r=e._reader;if(void 0!==r&&(F(r),ae(r))){var t=r._readRequests;r._readRequests=new R,t.forEach(function(e){e._closeSteps()})}}function to(e,r){e._state="errored",e._storedError=r;var t=e._reader;void 0!==t&&(D(t,r),ae(t)?se(t,r):Sr(t,r))}function oo(e){return new TypeError("ReadableStream.prototype.".concat(e," can only be used on a ReadableStream"))}function no(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark;return N(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:H(t)}}Object.defineProperties(Gt,{from:{enumerable:!0}}),Object.defineProperties(Gt.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),i(Gt.from,"from"),i(Gt.prototype.cancel,"cancel"),i(Gt.prototype.getReader,"getReader"),i(Gt.prototype.pipeThrough,"pipeThrough"),i(Gt.prototype.pipeTo,"pipeTo"),i(Gt.prototype.tee,"tee"),i(Gt.prototype.values,"values"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Gt.prototype,r.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(Gt.prototype,ye,{value:Gt.prototype.values,writable:!0,configurable:!0});var io=function(e){return e.byteLength};i(io,"size");var ao=function(){function ByteLengthQueuingStrategy(e){Q(e,1,"ByteLengthQueuingStrategy"),e=no(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(ByteLengthQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!lo(this))throw uo("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(ByteLengthQueuingStrategy.prototype,"size",{get:function(){if(!lo(this))throw uo("size");return io},enumerable:!1,configurable:!0}),ByteLengthQueuingStrategy}();function uo(e){return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(e," can only be used on a ByteLengthQueuingStrategy"))}function lo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ao)}Object.defineProperties(ao.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(ao.prototype,r.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});var so=function(){return 1};i(so,"size");var co=function(){function CountQueuingStrategy(e){Q(e,1,"CountQueuingStrategy"),e=no(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(CountQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!po(this))throw fo("highWaterMark");return this._countQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(CountQueuingStrategy.prototype,"size",{get:function(){if(!po(this))throw fo("size");return so},enumerable:!1,configurable:!0}),CountQueuingStrategy}();function fo(e){return new TypeError("CountQueuingStrategy.prototype.".concat(e," can only be used on a CountQueuingStrategy"))}function po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof co)}function bo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function ho(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function _o(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function mo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}Object.defineProperties(co.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(co.prototype,r.toStringTag,{value:"CountQueuingStrategy",configurable:!0});var vo=function(){function TransformStream(e,r,t){void 0===e&&(e={}),void 0===r&&(r={}),void 0===t&&(t={}),void 0===e&&(e=null);var o=Pr(r,"Second parameter"),n=Pr(t,"Third parameter"),i=function(e,r){M(e,r);var t=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,i=null==e?void 0:e.start,a=null==e?void 0:e.transform,u=null==e?void 0:e.writableType;return{cancel:void 0===t?void 0:mo(t,e,"".concat(r," has member 'cancel' that")),flush:void 0===o?void 0:bo(o,e,"".concat(r," has member 'flush' that")),readableType:n,start:void 0===i?void 0:ho(i,e,"".concat(r," has member 'start' that")),transform:void 0===a?void 0:_o(a,e,"".concat(r," has member 'transform' that")),writableType:u}}(e,"First parameter");if(void 0!==i.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==i.writableType)throw new RangeError("Invalid writableType specified");var a,u=Rr(n,0),l=Tr(n),s=Rr(o,1),c=Tr(o);!function(e,r,t,o,n,i){function a(){return r}function u(r){return function(e,r){var t=e._transformStreamController;if(e._backpressure){return v(e._backpressureChangePromise,function(){var o=e._writable;if("erroring"===o._state)throw o._storedError;return Eo(t,r)})}return Eo(t,r)}(e,r)}function l(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._readable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(Dt(o._readableStreamController,r),Oo(t)),null},function(e){return Dt(o._readableStreamController,e),jo(t,e),null}),t._finishPromise}(e,r)}function s(){return function(e){var r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;var t=e._readable;r._finishPromise=f(function(e,t){r._finishPromise_resolve=e,r._finishPromise_reject=t});var o=r._flushAlgorithm();return Co(r),h(o,function(){return"errored"===t._state?jo(r,t._storedError):(At(t._readableStreamController),Oo(r)),null},function(e){return Dt(t._readableStreamController,e),jo(r,e),null}),r._finishPromise}(e)}function c(){return function(e){return Ro(e,!1),e._backpressureChangePromise}(e)}function d(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._writable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(it(o._writableStreamController,r),wo(e),Oo(t)),null},function(r){return it(o._writableStreamController,r),wo(e),jo(t,r),null}),t._finishPromise}(e,r)}e._writable=function(e,r,t,o,n,i){void 0===n&&(n=1),void 0===i&&(i=function(){return 1});var a=Object.create(Br.prototype);return Ar(a),rt(a,Object.create($r.prototype),e,r,t,o,n,i),a}(a,u,s,l,t,o),e._readable=Xt(a,c,d,n,i),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,Ro(e,!0),e._transformStreamController=void 0}(this,f(function(e){a=e}),s,c,u,l),function(e,r){var t,o,n,i=Object.create(To.prototype);t=void 0!==r.transform?function(e){return r.transform(e,i)}:function(e){try{return qo(i,e),d(void 0)}catch(e){return p(e)}};o=void 0!==r.flush?function(){return r.flush(i)}:function(){return d(void 0)};n=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};!function(e,r,t,o,n){r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=o,r._cancelAlgorithm=n,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}(e,i,t,o,n)}(this,i),void 0!==i.start?a(i.start(this._transformStreamController)):a(void 0)}return Object.defineProperty(TransformStream.prototype,"readable",{get:function(){if(!yo(this))throw Bo("readable");return this._readable},enumerable:!1,configurable:!0}),Object.defineProperty(TransformStream.prototype,"writable",{get:function(){if(!yo(this))throw Bo("writable");return this._writable},enumerable:!1,configurable:!0}),TransformStream}();function yo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof vo)}function go(e,r){Dt(e._readable._readableStreamController,r),So(e,r)}function So(e,r){Co(e._transformStreamController),it(e._writable._writableStreamController,r),wo(e)}function wo(e){e._backpressure&&Ro(e,!1)}function Ro(e,r){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=f(function(r){e._backpressureChangePromise_resolve=r}),e._backpressure=r}Object.defineProperties(vo.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(vo.prototype,r.toStringTag,{value:"TransformStream",configurable:!0});var To=function(){function TransformStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(TransformStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Po(this))throw Wo("desiredSize");return Ft(this._controlledTransformStream._readable._readableStreamController)},enumerable:!1,configurable:!0}),TransformStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("enqueue");qo(this,e)},TransformStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("error");var r;r=e,go(this._controlledTransformStream,r)},TransformStreamDefaultController.prototype.terminate=function(){if(!Po(this))throw Wo("terminate");!function(e){var r=e._controlledTransformStream;At(r._readable._readableStreamController);var t=new TypeError("TransformStream terminated");So(r,t)}(this)},TransformStreamDefaultController}();function Po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof To)}function Co(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function qo(e,r){var t=e._controlledTransformStream,o=t._readable._readableStreamController;if(!Lt(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{zt(o,r)}catch(e){throw So(t,e),t._readable._storedError}var n=function(e){return!Bt(e)}(o);n!==t._backpressure&&Ro(t,!0)}function Eo(e,r){return v(e._transformAlgorithm(r),void 0,function(r){throw go(e._controlledTransformStream,r),r})}function Wo(e){return new TypeError("TransformStreamDefaultController.prototype.".concat(e," can only be used on a TransformStreamDefaultController"))}function Oo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function jo(e,r){void 0!==e._finishPromise_reject&&(y(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function Bo(e){return new TypeError("TransformStream.prototype.".concat(e," can only be used on a TransformStream"))}Object.defineProperties(To.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),i(To.prototype.enqueue,"enqueue"),i(To.prototype.error,"error"),i(To.prototype.terminate,"terminate"),"symbol"==typeof r.toStringTag&&Object.defineProperty(To.prototype,r.toStringTag,{value:"TransformStreamDefaultController",configurable:!0}),e.ByteLengthQueuingStrategy=ao,e.CountQueuingStrategy=co,e.ReadableByteStreamController=ze,e.ReadableStream=Gt,e.ReadableStreamBYOBReader=_r,e.ReadableStreamBYOBRequest=Ae,e.ReadableStreamDefaultController=Wt,e.ReadableStreamDefaultReader=ee,e.TransformStream=vo,e.TransformStreamDefaultController=To,e.WritableStream=Br,e.WritableStreamDefaultController=$r,e.WritableStreamDefaultWriter=Hr}); diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..254b10dc 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -78,6 +78,7 @@ target_link_libraries(UnitTests PRIVATE Performance PRIVATE TextDecoder PRIVATE TextEncoder + PRIVATE Streams ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..6b153c59 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1541,6 +1541,162 @@ describe("Console", function () { }); }); +describe("Web Streams", function () { + // Focused ports from the WHATWG Streams WPT suites at c05b4473: + // readable-streams/general.any.js and tee.any.js, + // writable-streams/write.any.js, and transform-streams/general.any.js. + it("installs the standard stream constructors", function () { + expect(ReadableStream).to.be.a("function"); + expect(WritableStream).to.be.a("function"); + expect(TransformStream).to.be.a("function"); + expect(ByteLengthQueuingStrategy).to.be.a("function"); + expect(CountQueuingStrategy).to.be.a("function"); + }); + + it("delivers queued chunks in order and closes the reader", async function () { + const stream = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }); + const reader = stream.getReader(); + + expect(await reader.read()).to.deep.equal({ value: "a", done: false }); + expect(await reader.read()).to.deep.equal({ value: "b", done: false }); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + await reader.closed; + }); + + it("propagates a rejected pull to read and closed", async function () { + const failure = new Error("pull failed"); + const reader = new ReadableStream({ + pull() { + return Promise.reject(failure); + } + }).getReader(); + + let readFailure: unknown; + let closedFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + try { await reader.closed; } catch (error) { closedFailure = error; } + expect(readFailure).to.equal(failure); + expect(closedFailure).to.equal(failure); + }); + + it("tees without one branch consuming the other", async function () { + const [first, second] = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }).tee(); + const firstReader = first.getReader(); + const secondReader = second.getReader(); + + expect(await firstReader.read()).to.deep.equal({ value: "a", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: "b", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: undefined, done: true }); + expect(await secondReader.read()).to.deep.equal({ value: "a", done: false }); + }); + + it("waits for asynchronous writes before closing", async function () { + const stored: number[] = []; + const writable = new WritableStream({ + write(chunk) { + return Promise.resolve().then(() => stored.push(chunk)); + } + }); + const writer = writable.getWriter(); + + writer.write(1); + writer.write(2); + await writer.close(); + expect(stored).to.deep.equal([1, 2]); + }); + + it("applies transform output and backpressure", async function () { + const transform = new TransformStream({ + transform(chunk, controller) { + controller.enqueue(chunk.toUpperCase()); + } + }); + const writer = transform.writable.getWriter(); + const reader = transform.readable.getReader(); + const write = writer.write("native"); + + expect(await reader.read()).to.deep.equal({ value: "NATIVE", done: false }); + await write; + await writer.close(); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + }); + + it("supports BYOB reads from byte streams", async function () { + let sent = false; + const stream = new ReadableStream({ + type: "bytes", + pull(controller) { + if (!sent) { + sent = true; + controller.enqueue(new Uint8Array([8, 241, 48, 123, 151])); + controller.close(); + } + } + } as any); + const reader = stream.getReader({ mode: "byob" }); + const result = await reader.read(new Uint8Array(8)); + + expect(result.done).to.equal(false); + expect(Array.from(result.value!)).to.deep.equal([8, 241, 48, 123, 151]); + expect((await reader.read(new Uint8Array(8))).done).to.equal(true); + }); + + // Ported from Firefox's dom/streams/test/xpcshell/subclassing.js. + it("supports subclassed streams, readers, and queuing strategies", async function () { + class SubclassedStream extends ReadableStream {} + class SubclassedStrategy extends CountQueuingStrategy {} + const stream = new SubclassedStream({ + start(controller) { + controller.enqueue("first"); + controller.close(); + } + }); + const Reader = stream.getReader().constructor as typeof ReadableStreamDefaultReader; + class SubclassedReader extends Reader {} + + expect(stream).to.be.instanceOf(ReadableStream); + expect(new SubclassedStrategy({ highWaterMark: 4 }).highWaterMark).to.equal(4); + + const secondStream = new ReadableStream({ + start(controller) { + controller.enqueue("second"); + controller.close(); + } + }); + const reader = new SubclassedReader(secondStream); + expect(await reader.read()).to.deep.equal({ value: "second", done: false }); + }); + + // Ported from Chromium's http/tests/streams/chromium/transform-stream-enqueue.html. + it("rejects enqueues after a transform is terminated or errored", function () { + expect(() => new TransformStream({ + start(controller) { + controller.terminate(); + controller.enqueue("late"); + } + })).to.throw(TypeError); + + expect(() => new TransformStream({ + start(controller) { + controller.error(new Error("failed")); + controller.enqueue("late"); + } + })).to.throw(TypeError); + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..b71218bd 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -90,6 +91,7 @@ TEST(JavaScript, All) Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -166,6 +168,30 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } +TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); + global.Set("ReadableStream", hostReadableStream); + + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").IsFunction()); + + const auto installedTransformStream = global.Get("TransformStream"); + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From bfcf0fb75158f294e53eea6c101396818f549cd8 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 23:10:42 -0700 Subject: [PATCH 068/174] Add browser-compatible compression streams Add optional CompressionStream and DecompressionStream polyfills for gzip, deflate, and raw deflate on top of WHATWG Streams. Reuse one native output buffer per active codec, borrow input views only synchronously, and defer JavaScript enqueue callbacks until zlib has finished consuming each input. Cover constructor and BufferSource behavior, split and empty chunks, large flushes, corrupt/truncated/trailing input, reentrant input mutation, and repeated stream teardown with focused WPT and browser-engine regression tests. Preserve host constructors and use platform zlib where available with a pinned fallback. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 7 + Polyfills/Compression/CMakeLists.txt | 59 +++ .../Include/Babylon/Polyfills/Compression.h | 11 + Polyfills/Compression/README.md | 16 + Polyfills/Compression/Source/Compression.cpp | 407 ++++++++++++++++++ .../Compression/Source/CompressionPolyfill.js | 137 ++++++ .../Source/CompressionScripts.h.in | 8 + Polyfills/Compression/ThirdParty/zlib/LICENSE | 22 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 272 ++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 25 ++ 12 files changed, 966 insertions(+) create mode 100644 Polyfills/Compression/CMakeLists.txt create mode 100644 Polyfills/Compression/Include/Babylon/Polyfills/Compression.h create mode 100644 Polyfills/Compression/README.md create mode 100644 Polyfills/Compression/Source/Compression.cpp create mode 100644 Polyfills/Compression/Source/CompressionPolyfill.js create mode 100644 Polyfills/Compression/Source/CompressionScripts.h.in create mode 100644 Polyfills/Compression/ThirdParty/zlib/LICENSE diff --git a/CMakeLists.txt b/CMakeLists.txt index 6535a653..731593b5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -103,6 +103,7 @@ option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Perfor option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) +option(JSRUNTIMEHOST_POLYFILL_COMPRESSION "Include JsRuntimeHost Polyfills CompressionStream and DecompressionStream." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index c952cf27..3368375f 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -49,3 +49,10 @@ endif() if(JSRUNTIMEHOST_POLYFILL_STREAMS) add_subdirectory(Streams) endif() + +if(JSRUNTIMEHOST_POLYFILL_COMPRESSION) + if(NOT JSRUNTIMEHOST_POLYFILL_STREAMS) + message(FATAL_ERROR "The Compression polyfill requires the Streams polyfill.") + endif() + add_subdirectory(Compression) +endif() diff --git a/Polyfills/Compression/CMakeLists.txt b/Polyfills/Compression/CMakeLists.txt new file mode 100644 index 00000000..d049f155 --- /dev/null +++ b/Polyfills/Compression/CMakeLists.txt @@ -0,0 +1,59 @@ +if(APPLE) + # FindZLIB exposes the SDK's usr/include as an explicit system include on + # recent Xcode versions. That breaks libc++'s include_next ordering. The + # header and library are both SDK-provided, so only add the link library. + find_library(JSRUNTIMEHOST_COMPRESSION_ZLIB_LIBRARY NAMES z REQUIRED) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET "${JSRUNTIMEHOST_COMPRESSION_ZLIB_LIBRARY}") +elseif(TARGET ZLIB::ZLIB) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET ZLIB::ZLIB) +elseif(TARGET zlibstatic) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET zlibstatic) +elseif(TARGET zlib) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET zlib) +else() + find_package(ZLIB QUIET) + if(ZLIB_FOUND) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET ZLIB::ZLIB) + else() + set(ZLIB_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) + set(SKIP_INSTALL_ALL ON CACHE BOOL "" FORCE) + FetchContent_Declare(jsruntimehost_zlib + GIT_REPOSITORY https://github.com/madler/zlib.git + GIT_TAG 51b7f2abdade71cd9bb0e7a373ef2610ec6f9daf + EXCLUDE_FROM_ALL) + FetchContent_MakeAvailable_With_Message(jsruntimehost_zlib) + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET zlibstatic) + set_property(TARGET zlibstatic PROPERTY FOLDER Dependencies) + endif() +endif() + +set(COMPRESSION_POLYFILL_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Source/CompressionPolyfill.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${COMPRESSION_POLYFILL_FILE}") +file(READ "${COMPRESSION_POLYFILL_FILE}" COMPRESSION_POLYFILL_SOURCE) +configure_file( + "Source/CompressionScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/CompressionScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Compression.h" + "README.md" + "Source/Compression.cpp" + "Source/CompressionPolyfill.js" + "Source/CompressionScripts.h.in" + "ThirdParty/zlib/LICENSE") + +add_library(Compression ${SOURCES}) +warnings_as_errors(Compression) + +target_include_directories(Compression + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Compression + PUBLIC JsRuntime + PUBLIC Streams + PRIVATE ${JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET}) + +set_property(TARGET Compression PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Compression/Include/Babylon/Polyfills/Compression.h b/Polyfills/Compression/Include/Babylon/Polyfills/Compression.h new file mode 100644 index 00000000..44cb9693 --- /dev/null +++ b/Polyfills/Compression/Include/Babylon/Polyfills/Compression.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Compression +{ + // Installs CompressionStream and DecompressionStream when the host does + // not already provide them. The Streams polyfill is initialized first. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Compression/README.md b/Polyfills/Compression/README.md new file mode 100644 index 00000000..78a0d424 --- /dev/null +++ b/Polyfills/Compression/README.md @@ -0,0 +1,16 @@ +# Compression streams + +This optional polyfill installs the browser `CompressionStream` and +`DecompressionStream` interfaces when the JavaScript host does not already +provide them. It supports the interoperable `deflate`, `deflate-raw`, and +`gzip` formats using zlib and the WHATWG Streams API. + +Input `BufferSource` memory is borrowed only for the duration of a synchronous +codec call. Output is accumulated before invoking JavaScript so an enqueue +callback cannot invalidate an input buffer still in use. A native 64 KiB +scratch buffer is reused for the lifetime of each active stream; each emitted +`Uint8Array` receives one exact-size copy into JavaScript-owned memory. + +The module uses an existing CMake zlib target or the platform zlib package when +available. It fetches pinned zlib 1.3.1 only when no zlib package is present. +The zlib license is included under `ThirdParty/zlib`. diff --git a/Polyfills/Compression/Source/Compression.cpp b/Polyfills/Compression/Source/Compression.cpp new file mode 100644 index 00000000..aab2ab10 --- /dev/null +++ b/Polyfills/Compression/Source/Compression.cpp @@ -0,0 +1,407 @@ +#include "CompressionScripts.h" + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Babylon::Polyfills::Internal +{ + namespace + { + constexpr size_t OUTPUT_BUFFER_SIZE = 64 * 1024; + + int WindowBits(const std::string& format) + { + if (format == "deflate") + { + return 15; + } + if (format == "deflate-raw") + { + return -15; + } + if (format == "gzip") + { + return 15 + 16; + } + return 0; + } + + class CompressionCodec final : public Napi::ObjectWrap + { + public: + static Napi::Function CreateConstructor(Napi::Env env) + { + return DefineClass( + env, + "NativeCompressionCodec", + { + InstanceMethod("transform", &CompressionCodec::Transform), + InstanceMethod("finish", &CompressionCodec::Finish), + InstanceMethod("close", &CompressionCodec::Close), + }); + } + + explicit CompressionCodec(const Napi::CallbackInfo& info) + : Napi::ObjectWrap{info} + { + auto env = info.Env(); + if (info.Length() < 2 || !info[0].IsString()) + { + throw Napi::TypeError::New(env, "Invalid compression codec arguments"); + } + + const auto format = info[0].As().Utf8Value(); + const auto windowBits = WindowBits(format); + if (windowBits == 0) + { + throw Napi::TypeError::New(env, "Unsupported compression format"); + } + + m_compressing = info[1].ToBoolean().Value(); + const auto result = m_compressing + ? deflateInit2(&m_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY) + : inflateInit2(&m_stream, windowBits); + if (result != Z_OK) + { + throw Napi::Error::New(env, "Unable to initialize the compression codec"); + } + m_initialized = true; + } + + ~CompressionCodec() override + { + EndStream(); + } + + private: + Napi::Value Transform(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + if (m_closed || m_finished) + { + throw Napi::TypeError::New(env, "The compression stream is no longer writable"); + } + if (info.Length() < 2 || !info[0].IsTypedArray() || !info[1].IsFunction()) + { + throw Napi::TypeError::New(env, "Invalid compression transform arguments"); + } + + const auto input = info[0].As(); + if (input.TypedArrayType() != napi_uint8_array) + { + throw Napi::TypeError::New(env, "Compression input must be a Uint8Array"); + } + + const auto bytes = info[0].As(); + if (bytes.ByteLength() > 0) + { + if (!Process(bytes.Data(), bytes.ByteLength(), false, info[1].As())) + { + return {}; + } + } + return env.Undefined(); + } + + Napi::Value Finish(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + if (!m_closed && !m_finished) + { + if (info.Length() < 1 || !info[0].IsFunction()) + { + throw Napi::TypeError::New(env, "Invalid compression finish arguments"); + } + if (!Process(nullptr, 0, true, info[0].As())) + { + return {}; + } + } + return env.Undefined(); + } + + Napi::Value Close(const Napi::CallbackInfo& info) + { + m_closed = true; + EndStream(); + ReleasePendingStorage(); + return info.Env().Undefined(); + } + + void EnsureOutputBuffer() + { + if (!m_outputBuffer) + { + m_outputBuffer = std::make_unique(OUTPUT_BUFFER_SIZE); + } + } + + void CaptureOutput(Napi::Env env, size_t byteLength) + { + if (byteLength == 0) + { + return; + } + + auto output = Napi::Uint8Array::New(env, byteLength); + std::memcpy(output.Data(), m_outputBuffer.get(), byteLength); + m_pendingOutput.emplace_back(std::move(output)); + } + + void EnqueuePending(const Napi::Function& enqueue) + { + for (const auto& output : m_pendingOutput) + { + enqueue.Call({output}); + } + m_pendingOutput.clear(); + } + + bool Process(const uint8_t* input, size_t inputLength, bool finishing, const Napi::Function& enqueue) + { + auto env = enqueue.Env(); + if (!m_initialized) + { + throw Napi::TypeError::New(env, "The compression stream is no longer writable"); + } + + EnsureOutputBuffer(); + m_pendingOutput.clear(); + + const uint8_t* inputCursor = input; + size_t inputRemaining = inputLength; + bool reachedEnd{}; + bool closeAfterEnqueue{}; + std::string failure; + + try + { + while (true) + { + if (m_stream.avail_in == 0 && inputRemaining > 0) + { + const auto nextLength = std::min( + inputRemaining, + static_cast(std::numeric_limits::max())); + m_stream.next_in = const_cast(reinterpret_cast(inputCursor)); + m_stream.avail_in = static_cast(nextLength); + inputCursor += nextLength; + inputRemaining -= nextLength; + } + + m_stream.next_out = reinterpret_cast(m_outputBuffer.get()); + m_stream.avail_out = static_cast(OUTPUT_BUFFER_SIZE); + + const auto inputBefore = m_stream.avail_in; + const auto result = m_compressing + ? deflate(&m_stream, finishing ? Z_FINISH : Z_NO_FLUSH) + : inflate(&m_stream, finishing ? Z_FINISH : Z_NO_FLUSH); + const auto produced = OUTPUT_BUFFER_SIZE - m_stream.avail_out; + CaptureOutput(env, produced); + + if (result == Z_STREAM_END) + { + reachedEnd = true; + closeAfterEnqueue = true; + if (!m_compressing && (m_stream.avail_in > 0 || inputRemaining > 0)) + { + failure = "Unexpected input after the end of the compressed stream"; + } + break; + } + + if (result == Z_DATA_ERROR || result == Z_NEED_DICT) + { + failure = m_stream.msg != nullptr + ? std::string{"The compressed data is invalid: "} + m_stream.msg + : "The compressed data is invalid"; + closeAfterEnqueue = true; + break; + } + if (result == Z_MEM_ERROR) + { + failure = "The compression codec ran out of memory"; + closeAfterEnqueue = true; + break; + } + if (result != Z_OK && result != Z_BUF_ERROR) + { + failure = "The compression codec entered an invalid state"; + closeAfterEnqueue = true; + break; + } + + const bool madeProgress = produced > 0 || m_stream.avail_in < inputBefore; + const bool hasInput = m_stream.avail_in > 0 || inputRemaining > 0; + if (!finishing && !hasInput && m_stream.avail_out > 0) + { + break; + } + if (!madeProgress && result == Z_BUF_ERROR) + { + if (finishing && !m_compressing) + { + failure = "The compressed input ended before the end of the stream"; + } + else + { + failure = "The compression codec could not make progress"; + } + closeAfterEnqueue = true; + break; + } + if (!madeProgress && finishing) + { + failure = m_compressing + ? "The compression codec could not finish" + : "The compressed input ended before the end of the stream"; + closeAfterEnqueue = true; + break; + } + } + } + catch (...) + { + ResetZlibPointers(); + m_pendingOutput.clear(); + m_closed = true; + EndStream(); + ReleasePendingStorage(); + throw; + } + + ResetZlibPointers(); + if (closeAfterEnqueue) + { + EndStream(); + } + + try + { + // Complete zlib's access to the borrowed input before this + // callback can run JavaScript and mutate or detach it. + EnqueuePending(enqueue); + } + catch (...) + { + m_closed = true; + EndStream(); + ReleasePendingStorage(); + throw; + } + + if (!failure.empty()) + { + m_closed = true; + ReleasePendingStorage(); + // This error is reported after EnqueuePending has called + // back into JavaScript. Setting the pending exception + // directly avoids a second C++ exception conversion in + // Node-API backends with reentrant callback contexts. + static_cast(napi_throw_type_error(env, nullptr, failure.c_str())); + return false; + } + + if (reachedEnd || finishing) + { + m_finished = true; + EndStream(); + ReleasePendingStorage(); + } + return true; + } + + void ResetZlibPointers() noexcept + { + m_stream.next_in = Z_NULL; + m_stream.avail_in = 0; + m_stream.next_out = Z_NULL; + m_stream.avail_out = 0; + } + + void EndStream() noexcept + { + if (m_initialized) + { + if (m_compressing) + { + deflateEnd(&m_stream); + } + else + { + inflateEnd(&m_stream); + } + m_initialized = false; + } + m_outputBuffer.reset(); + } + + void ReleasePendingStorage() + { + m_pendingOutput.clear(); + std::vector{}.swap(m_pendingOutput); + } + + z_stream m_stream{}; + std::unique_ptr m_outputBuffer; + std::vector m_pendingOutput; + bool m_compressing{}; + bool m_initialized{}; + bool m_finished{}; + bool m_closed{}; + }; + } +} + +namespace Babylon::Polyfills::Compression +{ + void BABYLON_API Initialize(Napi::Env env) + { + Streams::Initialize(env); + + Napi::HandleScope scope{env}; + auto global = env.Global(); + const auto compressionStream = global.Get("CompressionStream"); + const auto decompressionStream = global.Get("DecompressionStream"); + if (!compressionStream.IsUndefined() && !decompressionStream.IsUndefined()) + { + return; + } + + if (!global.Get("TransformStream").IsFunction()) + { + throw Napi::Error::New(env, "Compression streams require TransformStream"); + } + + const auto nativeConstructor = Internal::CompressionCodec::CreateConstructor(env); + const auto factory = Napi::Eval( + env, + Internal::CompressionScripts::Polyfill, + "jsruntimehost://compression-polyfill.js") + .As(); + const auto exports = factory.Call({nativeConstructor}).As(); + + if (compressionStream.IsUndefined()) + { + global.Set("CompressionStream", exports.Get("CompressionStream")); + } + if (decompressionStream.IsUndefined()) + { + global.Set("DecompressionStream", exports.Get("DecompressionStream")); + } + } +} diff --git a/Polyfills/Compression/Source/CompressionPolyfill.js b/Polyfills/Compression/Source/CompressionPolyfill.js new file mode 100644 index 00000000..92c7c468 --- /dev/null +++ b/Polyfills/Compression/Source/CompressionPolyfill.js @@ -0,0 +1,137 @@ +(function() { + "use strict"; + + return function createCompressionPolyfill(NativeCompressionCodec) { + var compressionStates = new WeakMap(); + var decompressionStates = new WeakMap(); + + function normalizeFormat(value) { + // String concatenation follows Web IDL's DOMString conversion, + // including throwing for Symbol values and propagating user + // conversion exceptions. + var format = value + ""; + if (format !== "deflate" && format !== "deflate-raw" && format !== "gzip") { + throw new TypeError("Unsupported compression format: '" + format + "'"); + } + return format; + } + + function toUint8Array(chunk) { + if (chunk instanceof ArrayBuffer) { + return new Uint8Array(chunk); + } + if (ArrayBuffer.isView(chunk) && chunk.buffer instanceof ArrayBuffer) { + return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength); + } + throw new TypeError("Compression stream chunks must be BufferSource values"); + } + + function initialize(instance, states, format, compressing) { + var codec = new NativeCompressionCodec(format, compressing); + var enqueue; + var transform = new TransformStream({ + start: function(controller) { + enqueue = controller.enqueue.bind(controller); + }, + transform: function(chunk) { + var bytes = toUint8Array(chunk); + if (bytes.byteLength === 0) { + return; + } + + try { + codec.transform(bytes, enqueue); + } catch (error) { + codec.close(); + codec = null; + enqueue = null; + throw error; + } + }, + flush: function() { + try { + codec.finish(enqueue); + } finally { + codec.close(); + codec = null; + enqueue = null; + } + } + }); + + states.set(instance, { + readable: transform.readable, + writable: transform.writable + }); + } + + function getState(states, value) { + var state = states.get(value); + if (!state) { + throw new TypeError("Illegal invocation"); + } + return state; + } + + function CompressionStream(format) { + if (!(this instanceof CompressionStream)) { + throw new TypeError("CompressionStream must be constructed with new"); + } + if (arguments.length === 0) { + throw new TypeError("CompressionStream requires a format"); + } + initialize(this, compressionStates, normalizeFormat(format), true); + } + + function DecompressionStream(format) { + if (!(this instanceof DecompressionStream)) { + throw new TypeError("DecompressionStream must be constructed with new"); + } + if (arguments.length === 0) { + throw new TypeError("DecompressionStream requires a format"); + } + initialize(this, decompressionStates, normalizeFormat(format), false); + } + + Object.defineProperties(CompressionStream.prototype, { + readable: { + configurable: true, + enumerable: true, + get: function() { return getState(compressionStates, this).readable; } + }, + writable: { + configurable: true, + enumerable: true, + get: function() { return getState(compressionStates, this).writable; } + } + }); + Object.defineProperties(DecompressionStream.prototype, { + readable: { + configurable: true, + enumerable: true, + get: function() { return getState(decompressionStates, this).readable; } + }, + writable: { + configurable: true, + enumerable: true, + get: function() { return getState(decompressionStates, this).writable; } + } + }); + + if (typeof Symbol === "function" && Symbol.toStringTag) { + Object.defineProperty(CompressionStream.prototype, Symbol.toStringTag, { + configurable: true, + value: "CompressionStream" + }); + Object.defineProperty(DecompressionStream.prototype, Symbol.toStringTag, { + configurable: true, + value: "DecompressionStream" + }); + } + + return { + CompressionStream: CompressionStream, + DecompressionStream: DecompressionStream + }; + }; +})() diff --git a/Polyfills/Compression/Source/CompressionScripts.h.in b/Polyfills/Compression/Source/CompressionScripts.h.in new file mode 100644 index 00000000..abee928f --- /dev/null +++ b/Polyfills/Compression/Source/CompressionScripts.h.in @@ -0,0 +1,8 @@ +#pragma once + +namespace Babylon::Polyfills::Internal::CompressionScripts +{ + inline constexpr char Polyfill[] = R"JSRHCOMPRESSION( +@COMPRESSION_POLYFILL_SOURCE@ +)JSRHCOMPRESSION"; +} diff --git a/Polyfills/Compression/ThirdParty/zlib/LICENSE b/Polyfills/Compression/ThirdParty/zlib/LICENSE new file mode 100644 index 00000000..ab8ee6f7 --- /dev/null +++ b/Polyfills/Compression/ThirdParty/zlib/LICENSE @@ -0,0 +1,22 @@ +Copyright notice: + + (C) 1995-2022 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index 254b10dc..1a1a92f1 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -79,6 +79,7 @@ target_link_libraries(UnitTests PRIVATE TextDecoder PRIVATE TextEncoder PRIVATE Streams + PRIVATE Compression ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 6b153c59..9ab83c71 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1697,6 +1697,278 @@ describe("Web Streams", function () { }); }); +describe("Compression streams", function () { + this.timeout(20000); + + type SupportedCompressionFormat = "deflate" | "deflate-raw" | "gzip"; + type CompressionTransform = { + readable: ReadableStream; + writable: WritableStream; + }; + + const formats: SupportedCompressionFormat[] = ["deflate", "deflate-raw", "gzip"]; + const expectedOutput = new TextEncoder().encode("expected output"); + const compressedFixtures: Array<[SupportedCompressionFormat, Uint8Array]> = [ + ["deflate", new Uint8Array([120, 156, 75, 173, 40, 72, 77, 46, 73, 77, 81, 200, 47, 45, 41, 40, 45, 1, 0, 48, 173, 6, 36])], + ["gzip", new Uint8Array([31, 139, 8, 0, 0, 0, 0, 0, 0, 3, 75, 173, 40, 72, 77, 46, 73, 77, 81, 200, 47, 45, 41, 40, 45, 1, 0, 176, 1, 57, 179, 15, 0, 0, 0])], + ["deflate-raw", new Uint8Array([75, 173, 40, 72, 77, 46, 73, 77, 81, 200, 47, 45, 41, 40, 45, 1, 0])], + ]; + + async function concatenateStream(readable: ReadableStream): Promise { + const reader = readable.getReader(); + const chunks: Uint8Array[] = []; + let byteLength = 0; + while (true) { + const result = await reader.read(); + if (result.done) { + break; + } + expect(result.value).to.be.instanceOf(Uint8Array); + chunks.push(result.value); + byteLength += result.value.byteLength; + } + + const output = new Uint8Array(byteLength); + let offset = 0; + for (const chunk of chunks) { + output.set(chunk, offset); + offset += chunk.byteLength; + } + return output; + } + + async function transformChunks(transform: CompressionTransform, chunks: BufferSource[]): Promise { + const output = concatenateStream(transform.readable); + const writer = transform.writable.getWriter(); + for (const chunk of chunks) { + await writer.write(chunk); + } + await writer.close(); + return output; + } + + async function roundTrip(input: Uint8Array, format: SupportedCompressionFormat): Promise { + const compressed = await transformChunks(new CompressionStream(format), [input]); + return transformChunks(new DecompressionStream(format), [compressed]); + } + + it("exposes browser-shaped constructors, properties, and brand checks", function () { + const compression = new CompressionStream("gzip"); + const decompression = new DecompressionStream("gzip"); + expect(compression.readable).to.be.instanceOf(ReadableStream); + expect(compression.writable).to.be.instanceOf(WritableStream); + expect(decompression.readable).to.be.instanceOf(ReadableStream); + expect(decompression.writable).to.be.instanceOf(WritableStream); + expect(String(compression)).to.equal("[object CompressionStream]"); + expect(String(decompression)).to.equal("[object DecompressionStream]"); + + const compressionReadable = Object.getOwnPropertyDescriptor(CompressionStream.prototype, "readable")!.get!; + const decompressionWritable = Object.getOwnPropertyDescriptor(DecompressionStream.prototype, "writable")!.get!; + expect(() => compressionReadable.call({})).to.throw(TypeError); + expect(() => decompressionWritable.call({})).to.throw(TypeError); + }); + + // Focused ports from WPT compression/*-constructor-error.any.js. + it("validates and converts constructor formats", function () { + expect(() => new CompressionStream()).to.throw(TypeError); + expect(() => new DecompressionStream()).to.throw(TypeError); + expect(() => new CompressionStream("invalid" as any)).to.throw(TypeError); + expect(() => new DecompressionStream("GZIP" as any)).to.throw(TypeError); + expect(() => new CompressionStream(Symbol("gzip") as any)).to.throw(TypeError); + + const failure = new Error("format conversion failed"); + let thrown: unknown; + try { + new DecompressionStream({ toString() { throw failure; } } as any); + } catch (error) { + thrown = error; + } + expect(thrown).to.equal(failure); + }); + + // Focused ports from WPT compression-stream.any.js, + // compression-multiple-chunks.any.js, and including-empty-chunk.any.js. + it("round-trips all supported formats across multiple and empty chunks", async function () { + const middleBacking = new Uint8Array(new TextEncoder().encode("!from browser-shaped streams!")); + const inputChunks = [ + new TextEncoder().encode("Hello "), + new Uint8Array(), + middleBacking.subarray(1, middleBacking.byteLength - 1), + ]; + const expected = new TextEncoder().encode("Hello from browser-shaped streams"); + + for (const format of formats) { + const compressed = await transformChunks(new CompressionStream(format), inputChunks); + const output = await transformChunks(new DecompressionStream(format), [compressed]); + expect(Array.from(output)).to.deep.equal(Array.from(expected)); + } + }); + + // Ported from WPT decompression-buffersource.any.js. + it("accepts ArrayBuffer, typed-array, and DataView input", async function () { + const fixtures: Array<[SupportedCompressionFormat, number[], string]> = [ + ["deflate", [120, 156, 75, 52, 48, 52, 50, 54, 49, 53, 3, 0, 8, 136, 1, 199], "a0123456"], + ["gzip", [31, 139, 8, 0, 0, 0, 0, 0, 0, 3, 75, 52, 48, 52, 2, 0, 216, 252, 63, 136, 4, 0, 0, 0], "a012"], + ["deflate-raw", [0, 6, 0, 249, 255, 65, 66, 67, 68, 69, 70, 1, 0, 0, 255, 255], "ABCDEF"], + ]; + + for (const [format, values, expected] of fixtures) { + const expectedBytes = Array.from(new TextEncoder().encode(expected)); + const makeBuffer = () => new Uint8Array(values).buffer as ArrayBuffer; + const padded = new Uint8Array(values.length + 2); + padded.set(values, 1); + const inputs: BufferSource[] = [ + makeBuffer(), + new Int8Array(makeBuffer()), + new Uint16Array(makeBuffer()), + new DataView(makeBuffer()), + new DataView(padded.buffer, 1, values.length), + ]; + for (const input of inputs) { + const output = await transformChunks(new DecompressionStream(format), [input]); + expect(Array.from(output)).to.deep.equal(expectedBytes); + } + } + }); + + // Focused ports from WPT decompression-split-chunk.any.js and + // decompression-uint8array-output.any.js. + it("decompresses input split at every small chunk boundary", async function () { + for (const [format, fixture] of compressedFixtures) { + for (let chunkSize = 1; chunkSize < 16; ++chunkSize) { + const chunks: Uint8Array[] = []; + for (let offset = 0; offset < fixture.byteLength; offset += chunkSize) { + chunks.push(fixture.slice(offset, offset + chunkSize)); + } + const output = await transformChunks(new DecompressionStream(format), chunks); + expect(Array.from(output)).to.deep.equal(Array.from(expectedOutput)); + } + } + }); + + // Ported from WPT compression-large-flush-output.any.js. + it("does not truncate output produced while closing", async function () { + const encoded = new TextEncoder().encode(JSON.stringify(Array.from({ length: 10000 }, (_, index) => index))); + const input = encoded.subarray(0, 35579); + for (const format of formats) { + expect(Array.from(await roundTrip(input, format))).to.deep.equal(Array.from(input)); + } + }); + + // WPT decompression-extra-input.any.js requires already-produced output + // to be observable before the stream reports the trailing-data error. + it("emits valid output before rejecting extra compressed input", async function () { + for (const [format, fixture] of compressedFixtures) { + const stream = new DecompressionStream(format); + const reader = stream.readable.getReader(); + const writer = stream.writable.getWriter(); + const firstRead = reader.read(); + const write = writer.write(new Uint8Array([...fixture, 0])).catch(error => error); + const first = await firstRead; + expect(first.done).to.equal(false); + expect(Array.from(first.value!)).to.deep.equal(Array.from(expectedOutput)); + + let readFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + expect(readFailure).to.be.instanceOf(TypeError); + expect(await write).to.be.instanceOf(TypeError); + } + }); + + // Focused ports from WPT compression-bad-chunks.any.js and + // decompression-bad-chunks.any.js. + it("errors both sides of the transform for non-BufferSource chunks", async function () { + for (const create of [ + () => new CompressionStream("gzip"), + () => new DecompressionStream("gzip"), + ]) { + const stream = create(); + const reader = stream.readable.getReader(); + const writer = stream.writable.getWriter(); + const read = reader.read().catch(error => error); + const write = writer.write({} as any).catch(error => error); + expect(await write).to.be.instanceOf(TypeError); + expect(await read).to.be.instanceOf(TypeError); + } + }); + + // Focused ports from WPT decompression-corrupt-input.any.js and the + // truncated-input check in Chromium's InflateTransformer. + it("rejects corrupt and truncated compressed input", async function () { + for (const [format, fixture] of compressedFixtures) { + const inputs = [ + fixture.subarray(0, fixture.byteLength - 1), + new Uint8Array(fixture.map((value, index) => index === 0 ? value ^ 0xff : value)), + ]; + for (const input of inputs) { + const stream = new DecompressionStream(format); + const output = concatenateStream(stream.readable).catch(error => error); + const writer = stream.writable.getWriter(); + await writer.write(input).catch(() => undefined); + const close = writer.close().catch(error => error); + expect(await close).to.be.instanceOf(TypeError); + expect(await output).to.be.instanceOf(TypeError); + } + } + }); + + // Chromium buffers output before enqueue because enqueue may execute + // JavaScript that mutates or detaches the input still being consumed. + // This regression test forces that reentrancy without needing postMessage. + it("finishes consuming input before an enqueue callback can mutate it", async function () { + const input = new Uint8Array(256 * 1024); + let state = 0x12345678; + for (let index = 0; index < input.length; ++index) { + state ^= state << 13; + state ^= state >>> 17; + state ^= state << 5; + input[index] = state & 0xff; + } + const expected = input.slice(); + + const prototype = TransformStreamDefaultController.prototype as any; + const originalEnqueue = prototype.enqueue; + let mutated = false; + prototype.enqueue = function(chunk: unknown) { + if (!mutated) { + mutated = true; + input.fill(0); + } + return originalEnqueue.call(this, chunk); + }; + + let compressed: Uint8Array; + try { + compressed = await transformChunks(new CompressionStream("deflate"), [input]); + } finally { + prototype.enqueue = originalEnqueue; + } + + expect(mutated).to.equal(true); + const output = await transformChunks(new DecompressionStream("deflate"), [compressed!]); + expect(Array.from(output)).to.deep.equal(Array.from(expected)); + }); + + // Empty chunks are common in WebKit and WPT stream regressions. They must + // not allocate codec output or accumulate retained per-write state. + it("handles a long sequence of empty writes without retained output", async function () { + const chunks = Array.from({ length: 1024 }, () => new Uint8Array()); + const compressed = await transformChunks(new CompressionStream("gzip"), chunks); + const output = await transformChunks(new DecompressionStream("gzip"), [compressed]); + expect(output.byteLength).to.equal(0); + }); + + // Repeated short-lived streams model asset-heavy native applications. A + // completed stream must release zlib and scratch storage before JS GC. + it("releases completed codec state across repeated streams", async function () { + const fixture = compressedFixtures.find(([format]) => format === "gzip")![1]; + for (let iteration = 0; iteration < 128; ++iteration) { + const output = await transformChunks(new DecompressionStream("gzip"), [fixture]); + expect(Array.from(output)).to.deep.equal(Array.from(expectedOutput)); + } + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index b71218bd..6ff1df44 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -92,6 +93,7 @@ TEST(JavaScript, All) Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); Babylon::Polyfills::Streams::Initialize(env); + Babylon::Polyfills::Compression::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -192,6 +194,29 @@ TEST(Streams, PreservesHostConstructorsAndIsIdempotent) done.get_future().get(); } +TEST(Compression, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostCompressionStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostCompressionStream"); + global.Set("CompressionStream", hostCompressionStream); + + Babylon::Polyfills::Compression::Initialize(env); + EXPECT_TRUE(global.Get("CompressionStream").StrictEquals(hostCompressionStream)); + EXPECT_TRUE(global.Get("DecompressionStream").IsFunction()); + + const auto installedDecompressionStream = global.Get("DecompressionStream"); + Babylon::Polyfills::Compression::Initialize(env); + EXPECT_TRUE(global.Get("CompressionStream").StrictEquals(hostCompressionStream)); + EXPECT_TRUE(global.Get("DecompressionStream").StrictEquals(installedDecompressionStream)); + done.set_value(); + }); + + done.get_future().get(); +} TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 9fe3bb4826b18bf73c31b7d944fc5a346fd3b574 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:26:50 -0700 Subject: [PATCH 069/174] Keep Streams implementations internally consistent Replace a partial or null host Streams surface as a complete constructor suite so stream products retain compatible instanceof relationships. Preserve a complete suite on repeated initialization.\n\nHarden the native initialization test so N-API failures complete the test promise instead of hanging, and cover partial host replacement plus null handling and cross-constructor compatibility. --- Polyfills/Streams/Source/Streams.cpp | 8 ++---- Tests/UnitTests/Shared/Shared.cpp | 42 +++++++++++++++++++++------- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp index 4552ed07..e742344f 100644 --- a/Polyfills/Streams/Source/Streams.cpp +++ b/Polyfills/Streams/Source/Streams.cpp @@ -31,7 +31,8 @@ namespace Babylon::Polyfills::Streams bool needsPonyfill{}; for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) + const auto constructor = global.Get(name.data()); + if (constructor.IsUndefined() || constructor.IsNull()) { needsPonyfill = true; break; @@ -46,10 +47,7 @@ namespace Babylon::Polyfills::Streams const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) - { - global.Set(name.data(), exports.Get(name.data())); - } + global.Set(name.data(), exports.Get(name.data())); } } } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 6ff1df44..098aa0c5 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -170,28 +170,50 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } -TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; - runtime.Dispatch([&done](Napi::Env env) { + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); global.Set("ReadableStream", hostReadableStream); + global.Set("TransformStream", env.Null()); Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); - EXPECT_TRUE(global.Get("TransformStream").IsFunction()); - + const auto installedReadableStream = global.Get("ReadableStream"); const auto installedTransformStream = global.Get("TransformStream"); + EXPECT_FALSE(installedReadableStream.StrictEquals(hostReadableStream)); + if (!installedReadableStream.IsFunction() || !installedTransformStream.IsFunction()) + { + complete("Streams::Initialize did not install a complete constructor suite."); + return; + } + + const auto transform = installedTransformStream.As().New({}); + EXPECT_TRUE(transform.Get("readable").As().InstanceOf(installedReadableStream.As())); + Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(installedReadableStream)); EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Compression, PreservesHostConstructorsAndIsIdempotent) From b6089cd50163793eb0f2080f9dcbecea81676e90 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 02:14:59 -0700 Subject: [PATCH 070/174] Preserve Streams bundle bytes across source splits --- Polyfills/Streams/Source/StreamsScripts.h.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 9bf7f5bf..126a23f7 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -9,9 +9,10 @@ namespace Babylon::Polyfills::Internal::StreamsScripts (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@ -)JSRHSTREAM"; +@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; + // Keep the split transparent: inserting whitespace here can divide an + // identifier or string literal when the vendored bundle is regenerated. inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ return module.exports; })() From 5cc0117d34759308316d09675d88c98e06ded6c3 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 21:55:02 -0700 Subject: [PATCH 071/174] Add optional WHATWG Streams polyfill Vendor the ES5 web-streams-polyfill 4.3.0 ponyfill and expose an idempotent Streams initializer that preserves constructors supplied by the selected JavaScript engine. Cover readable, writable, transform, BYOB, error, tee, subclassing, and host-constructor behavior with focused ports from WPT plus Firefox and Chromium regression tests. Validate the implementation on JavaScriptCore under ASan/UBSan and QuickJS Release. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 6 +- Polyfills/Streams/CMakeLists.txt | 30 ++++ .../Include/Babylon/Polyfills/Streams.h | 11 ++ Polyfills/Streams/README.md | 14 ++ Polyfills/Streams/Source/Streams.cpp | 55 ++++++ Polyfills/Streams/Source/StreamsScripts.h.in | 36 ++++ .../ThirdParty/web-streams-polyfill/LICENSE | 22 +++ .../web-streams-polyfill/ponyfill.es5.js | 8 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 156 ++++++++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 26 +++ 12 files changed, 365 insertions(+), 1 deletion(-) create mode 100644 Polyfills/Streams/CMakeLists.txt create mode 100644 Polyfills/Streams/Include/Babylon/Polyfills/Streams.h create mode 100644 Polyfills/Streams/README.md create mode 100644 Polyfills/Streams/Source/Streams.cpp create mode 100644 Polyfills/Streams/Source/StreamsScripts.h.in create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..6535a653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,6 +102,7 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) +option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index a44765fb..c952cf27 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -44,4 +44,8 @@ endif() if(JSRUNTIMEHOST_POLYFILL_TEXTENCODER) add_subdirectory(TextEncoder) -endif() \ No newline at end of file +endif() + +if(JSRUNTIMEHOST_POLYFILL_STREAMS) + add_subdirectory(Streams) +endif() diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt new file mode 100644 index 00000000..6c00ed81 --- /dev/null +++ b/Polyfills/Streams/CMakeLists.txt @@ -0,0 +1,30 @@ +set(WEB_STREAMS_POLYFILL_FILE + "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/web-streams-polyfill/ponyfill.es5.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${WEB_STREAMS_POLYFILL_FILE}") +file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +configure_file( + "Source/StreamsScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Streams.h" + "Source/Streams.cpp" + "Source/StreamsScripts.h.in" + "ThirdParty/web-streams-polyfill/LICENSE" + "ThirdParty/web-streams-polyfill/ponyfill.es5.js") + +add_library(Streams ${SOURCES}) +warnings_as_errors(Streams) + +target_include_directories(Streams + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Streams PUBLIC JsRuntime) + +set_property(TARGET Streams PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h new file mode 100644 index 00000000..01e5a15c --- /dev/null +++ b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + // Installs the WHATWG Streams constructors that are not already supplied + // by the JavaScript engine. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Streams/README.md b/Polyfills/Streams/README.md new file mode 100644 index 00000000..c84a38e3 --- /dev/null +++ b/Polyfills/Streams/README.md @@ -0,0 +1,14 @@ +# Web Streams + +Installs the standard `ReadableStream`, `WritableStream`, `TransformStream`, +reader, writer, controller, and queuing-strategy globals when the selected +JavaScript engine does not provide them. + +The implementation is the ES5 ponyfill bundle from +[`web-streams-polyfill` 4.3.0](https://github.com/MattiasBuelens/web-streams-polyfill/tree/add69059ed08eae6a18559aba49575a280d1529e), +which is based on the WHATWG reference implementation. The vendored project +tests this release against the Streams portion of WPT at revision +[`c05b4473`](https://github.com/web-platform-tests/wpt/tree/c05b447326585237713013c66341eab2cdf967b6/streams). + +`Initialize` preserves any Streams constructors already supplied by the host +engine and fills only missing globals. diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp new file mode 100644 index 00000000..4552ed07 --- /dev/null +++ b/Polyfills/Streams/Source/Streams.cpp @@ -0,0 +1,55 @@ +#include + +#include "StreamsScripts.h" + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + void BABYLON_API Initialize(Napi::Env env) + { + Napi::HandleScope scope{env}; + auto global = env.Global(); + + static constexpr std::array constructorNames{ + "ReadableStream", + "ReadableStreamDefaultController", + "ReadableByteStreamController", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultReader", + "ReadableStreamBYOBReader", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", + "ByteLengthQueuingStrategy", + "CountQueuingStrategy", + "TransformStream", + "TransformStreamDefaultController", + }; + + bool needsPonyfill{}; + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + needsPonyfill = true; + break; + } + } + + if (!needsPonyfill) + { + return; + } + + const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + global.Set(name.data(), exports.Get(name.data())); + } + } + } +} diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in new file mode 100644 index 00000000..9bf7f5bf --- /dev/null +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Internal::StreamsScripts +{ + inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( +(function() { + var exports = {}; + var module = { exports: exports }; +@WEB_STREAMS_POLYFILL_SOURCE_1@ +)JSRHSTREAM"; + + inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ + return module.exports; +})() +)JSRHSTREAM"; + + template + consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + { + std::array result{}; + for (std::size_t index{}; index < Part1Size - 1; ++index) + { + result[index] = part1[index]; + } + for (std::size_t index{}; index < Part2Size; ++index) + { + result[Part1Size - 1 + index] = part2[index]; + } + return result; + } + + inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); +} diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js new file mode 100644 index 00000000..18d63683 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js @@ -0,0 +1,8 @@ +/** + * @license + * web-streams-polyfill v4.3.0 + * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors. + * This code is released under the MIT license. + * SPDX-License-Identifier: MIT + */ +!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).WebStreamsPolyfill={})}(this,function(e){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?Symbol:function(e){return"Symbol(".concat(e,")")};function t(){}function o(e){return"object"==typeof e&&null!==e||"function"==typeof e}"function"==typeof SuppressedError&&SuppressedError;var n=t;function i(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch(e){}}var a=Promise,u=Promise.resolve.bind(a),l=Promise.prototype.then,s=Promise.reject.bind(a),c=u;function f(e){return new a(e)}function d(e){return f(function(r){return r(e)})}function p(e){return s(e)}function b(e,r,t){return l.call(e,r,t)}function h(e,r,t){b(b(e,r,t),void 0,n)}function _(e,r){h(e,r)}function m(e,r){h(e,void 0,r)}function v(e,r,t){return b(e,r,t)}function y(e){b(e,void 0,n)}var g=function(e){if("function"==typeof queueMicrotask)g=queueMicrotask;else{var r=d(void 0);g=function(e){return b(r,e)}}return g(e)};function S(e,r,t){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}function w(e,r,t){try{return d(S(e,r,t))}catch(e){return p(e)}}var R=function(){function e(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}return Object.defineProperty(e.prototype,"length",{get:function(){return this._size},enumerable:!1,configurable:!0}),e.prototype.push=function(e){var r=this._back,t=r;16383===r._elements.length&&(t={_elements:[],_next:void 0}),r._elements.push(e),t!==r&&(this._back=t,r._next=t),++this._size},e.prototype.shift=function(){var e=this._front,r=e,t=this._cursor,o=t+1,n=e._elements,i=n[t];return 16384===o&&(r=e._next,o=0),--this._size,this._cursor=o,e!==r&&(this._front=r),n[t]=void 0,i},e.prototype.forEach=function(e){for(var r=this._cursor,t=this._front,o=t._elements;!(r===o.length&&void 0===t._next||r===o.length&&(r=0,0===(o=(t=t._next)._elements).length));)e(o[r]),++r},e.prototype.peek=function(){var e=this._front,r=this._cursor;return e._elements[r]},e}(),T=r("[[AbortSteps]]"),P=r("[[ErrorSteps]]"),C=r("[[CancelSteps]]"),q=r("[[PullSteps]]"),E=r("[[CanPullSyncSteps]]"),W=r("[[ReleaseSteps]]");function O(e,r){e._ownerReadableStream=r,r._reader=e,"readable"===r._state?A(e):"closed"===r._state?function(e){A(e),F(e)}(e):z(e,r._storedError)}function j(e,r){return eo(e._ownerReadableStream,r)}function B(e){var r=e._ownerReadableStream;"readable"===r._state?D(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,r){z(e,r)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[W](),r._reader=void 0,e._ownerReadableStream=void 0}function k(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function A(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t})}function z(e,r){A(e),D(e,r)}function D(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function F(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var L=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},I=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function M(e,r){if(void 0!==e&&("object"!=typeof(t=e)&&"function"!=typeof t))throw new TypeError("".concat(r," is not an object."));var t}function x(e,r){if("function"!=typeof e)throw new TypeError("".concat(r," is not a function."))}function Y(e,r){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError("".concat(r," is not an object."))}function Q(e,r,t){if(void 0===e)throw new TypeError("Parameter ".concat(r," is required in '").concat(t,"'."))}function N(e,r,t){if(void 0===e)throw new TypeError("".concat(r," is required in '").concat(t,"'."))}function H(e){return Number(e)}function V(e){return 0===e?0:e}function U(e,r){var t=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=V(o),!L(o))throw new TypeError("".concat(r," is not a finite number"));if((o=function(e){return V(I(e))}(o))<0||o>t)throw new TypeError("".concat(r," is outside the accepted range of ").concat(0," to ").concat(t,", inclusive"));return L(o)&&0!==o?o:0}function G(e,r){if(!Zt(e))throw new TypeError("".concat(r," is not a ReadableStream."))}function X(e){return new ee(e)}function J(e,r){e._reader._readRequests.push(r)}function K(e,r,t){var o=e._reader._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}function Z(e){return e._reader._readRequests.length}function $(e){var r=e._reader;return void 0!==r&&!!ae(r)}var ee=function(){function ReadableStreamDefaultReader(e){if(Q(e,1,"ReadableStreamDefaultReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");O(this,e),this._readRequests=new R}return Object.defineProperty(ReadableStreamDefaultReader.prototype,"closed",{get:function(){return ae(this)?this._closedPromise:p(ce("closed"))},enumerable:!1,configurable:!0}),ReadableStreamDefaultReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),ae(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(ce("cancel"))},ReadableStreamDefaultReader.prototype.read=function(){if(!ae(this))return p(ce("read"));if(void 0===this._ownerReadableStream)return p(k("read from"));var e=le(this)?new ie:new ne;return ue(this,e),e._promise},ReadableStreamDefaultReader.prototype.releaseLock=function(){if(!ae(this))throw ce("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");se(e,r)}(this)},ReadableStreamDefaultReader}();Object.defineProperties(ee.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(ee.prototype.cancel,"cancel"),i(ee.prototype.read,"read"),i(ee.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ee.prototype,r.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var re,te,oe,ne=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(){this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),ie=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(){this._promise=c({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function ae(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ee)}function ue(e,r){var t=e._ownerReadableStream;t._disturbed=!0,"closed"===t._state?r._closeSteps():"errored"===t._state?r._errorSteps(t._storedError):t._readableStreamController[q](r)}function le(e){var r=e._ownerReadableStream;return"closed"===r._state||("errored"===r._state||r._readableStreamController[E]())}function se(e,r){var t=e._readRequests;e._readRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function ce(e){return new TypeError("ReadableStreamDefaultReader.prototype.".concat(e," can only be used on a ReadableStreamDefaultReader"))}function fe(e){return e.slice()}function de(e,r,t,o,n){new Uint8Array(e).set(new Uint8Array(t,o,n),r)}var pe=function(e){return(pe="function"==typeof e.transfer?function(e){return e.transfer()}:"function"==typeof structuredClone?function(e){return structuredClone(e,{transfer:[e]})}:function(e){return e})(e)},be=function(e){return(be="boolean"==typeof e.detached?function(e){return e.detached}:function(e){return 0===e.byteLength})(e)};function he(e,r,t){if(e.slice)return e.slice(r,t);var o=t-r,n=new ArrayBuffer(o);return de(n,0,e,r,o),n}function _e(e,r){var t=e[r];if(null!=t){if("function"!=typeof t)throw new TypeError("".concat(String(r)," is not a function"));return t}}function me(e){try{var r=e.done,t=e.value;return b(c(t),function(e){return{done:r,value:e}})}catch(e){return p(e)}}var ve,ye=null!==(oe=null!==(re=r.asyncIterator)&&void 0!==re?re:null===(te=r.for)||void 0===te?void 0:te.call(r,"Symbol.asyncIterator"))&&void 0!==oe?oe:"@@asyncIterator";function ge(e,t,n){if(void 0===t&&(t="sync"),void 0===n)if("async"===t){if(void 0===(n=_e(e,ye)))return function(e){var r={next:function(){var r;try{r=Se(e)}catch(e){return p(e)}return me(r)},return:function(r){var t;try{var n=_e(e.iterator,"return");if(void 0===n)return d({done:!0,value:r});t=S(n,e.iterator,[r])}catch(e){return p(e)}return o(t)?me(t):p(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(ge(e,"sync",_e(e,r.iterator)))}else n=_e(e,r.iterator);if(void 0===n)throw new TypeError("The object is not iterable");var i=S(n,e,[]);if(!o(i))throw new TypeError("The iterator method must return an object");return{iterator:i,nextMethod:i.next,done:!1}}function Se(e){var r=S(e.nextMethod,e.iterator,[]);if(!o(r))throw new TypeError("The iterator.next() method must return an object");return r}var we=function(){function e(e,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=r}return e.prototype.next=function(){var e=this,r=function(){return e._nextSteps()};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,r,r):r(),this._ongoingPromise},e.prototype.return=function(e){var r=this,t=function(){return r._returnSteps(e)};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,t,t):t(),this._ongoingPromise},e.prototype._nextSteps=function(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});var e=this._reader,r=new Re(this);return ue(e,r),r._promise},e.prototype._returnSteps=function(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;var r=this._reader;if(!this._preventCancel){var t=j(r,e);return B(r),v(t,function(){return{value:e,done:!0}})}return B(r),d({value:e,done:!0})},e}(),Re=function(){function e(e){var r=this;this._iterator=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){var r=this;this._iterator._ongoingPromise=void 0,g(function(){return r._resolvePromise({value:e,done:!1})})},e.prototype._closeSteps=function(){var e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){var r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,B(r._reader),this._rejectPromise(e)},e}(),Te=((ve={next:function(){return Pe(this)?this._asyncIteratorImpl.next():p(Ce("next"))},return:function(e){return Pe(this)?this._asyncIteratorImpl.return(e):p(Ce("return"))}})[ye]=function(){return this},ve);function Pe(e){if(!o(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof we}catch(e){return!1}}function Ce(e){return new TypeError("ReadableStreamAsyncIterator.".concat(e," can only be used on a ReadableSteamAsyncIterator"))}Object.defineProperty(Te,ye,{enumerable:!1});var qe=Number.isNaN||function(e){return e!=e};function Ee(e){var r=he(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}function We(e){var r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}function Oe(e,r,t){if("number"!=typeof(o=t)||qe(o)||o<0||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:r,size:t}),e._queueTotalSize+=t}function je(e){e._queue=new R,e._queueTotalSize=0}function Be(e){return e===DataView}function ke(e){return Be(e)?1:e.BYTES_PER_ELEMENT}var Ae=function(){function ReadableStreamBYOBRequest(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamBYOBRequest.prototype,"view",{get:function(){if(!Fe(this))throw sr("view");return this._view},enumerable:!1,configurable:!0}),ReadableStreamBYOBRequest.prototype.respond=function(e){if(!Fe(this))throw sr("respond");if(Q(e,1,"respond"),e=U(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");ar(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest.prototype.respondWithNewView=function(e){if(!Fe(this))throw sr("respondWithNewView");if(Q(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");ur(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest}();Object.defineProperties(Ae.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),i(Ae.prototype.respond,"respond"),i(Ae.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Ae.prototype,r.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var ze=function(){function ReadableByteStreamController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableByteStreamController.prototype,"byobRequest",{get:function(){if(!De(this))throw cr("byobRequest");return nr(this)},enumerable:!1,configurable:!0}),Object.defineProperty(ReadableByteStreamController.prototype,"desiredSize",{get:function(){if(!De(this))throw cr("desiredSize");return ir(this)},enumerable:!1,configurable:!0}),ReadableByteStreamController.prototype.close=function(){if(!De(this))throw cr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");var e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError("The stream (in ".concat(e," state) is not in the readable state and cannot be closed"));er(this)},ReadableByteStreamController.prototype.enqueue=function(e){if(!De(this))throw cr("enqueue");if(Q(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");var r=this._controlledReadableByteStream._state;if("readable"!==r)throw new TypeError("The stream (in ".concat(r," state) is not in the readable state and cannot be enqueued to"));rr(this,e)},ReadableByteStreamController.prototype.error=function(e){if(void 0===e&&(e=void 0),!De(this))throw cr("error");tr(this,e)},ReadableByteStreamController.prototype[C]=function(e){Ie(this),je(this);var r=this._cancelAlgorithm(e);return $e(this),r},ReadableByteStreamController.prototype[q]=function(e){var r=this._controlledReadableByteStream;if(this._queueTotalSize>0)or(this,e);else{var t=this._autoAllocateChunkSize;if(void 0!==t){var o=void 0;try{o=new ArrayBuffer(t)}catch(r){return void e._errorSteps(r)}var n={buffer:o,bufferByteLength:t,byteOffset:0,byteLength:t,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(n)}J(r,e),Le(this)}},ReadableByteStreamController.prototype[E]=function(){return this._queueTotalSize>0},ReadableByteStreamController.prototype[W]=function(){if(this._pendingPullIntos.length>0){var e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new R,this._pendingPullIntos.push(e)}},ReadableByteStreamController}();function De(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ze)}function Fe(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof Ae)}function Le(e){var r=function(e){var r=e._controlledReadableByteStream;if("readable"!==r._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if($(r)&&Z(r)>0)return!0;if(hr(r)&&br(r)>0)return!0;var t=ir(e);if(t>0)return!0;return!1}(e);r&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Le(e)),null},function(r){return tr(e,r),null})))}function Ie(e){Xe(e),e._pendingPullIntos=new R}function Me(e,r){var t=!1;"closed"===e._state&&(t=!0);var o=Ye(r);"default"===r.readerType?K(e,o,t):function(e,r,t){var o=e._reader,n=o._readIntoRequests.shift();t?n._closeSteps(r):n._chunkSteps(r)}(e,o,t)}function xe(e,r){for(var t=0;t0&&Ne(e,r.buffer,r.byteOffset,r.bytesFilled),Ze(e)}function Ve(e,r){var t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),o=r.bytesFilled+t,n=t,i=!1,a=o-o%r.elementSize;a>=r.minimumFill&&(n=a-r.bytesFilled,i=!0);for(var u=e._queue;n>0;){var l=u.peek(),s=Math.min(n,l.byteLength),c=r.byteOffset+r.bytesFilled;de(r.buffer,c,l.buffer,l.byteOffset,s),l.byteLength===s?u.shift():(l.byteOffset+=s,l.byteLength-=s),e._queueTotalSize-=s,Ue(e,s,r),n-=s}return i}function Ue(e,r,t){t.bytesFilled+=r}function Ge(e){0===e._queueTotalSize&&e._closeRequested?($e(e),ro(e._controlledReadableByteStream)):Le(e)}function Xe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Je(e){for(var r=[];e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){var t=e._pendingPullIntos.peek();Ve(e,t)&&(Ze(e),r.push(t))}return r}function Ke(e,r){var t=e._pendingPullIntos.peek();Xe(e),"closed"===e._controlledReadableByteStream._state?function(e,r){"none"===r.readerType&&Ze(e);var t=e._controlledReadableByteStream;if(hr(t)){for(var o=[];o.length0){var n=t.byteOffset+t.bytesFilled;Ne(e,t.buffer,n-o,o)}t.bytesFilled-=o;var i=Je(e);Me(e._controlledReadableByteStream,t),xe(e._controlledReadableByteStream,i)}}else{He(e,t);var a=Je(e);xe(e._controlledReadableByteStream,a)}}(e,r,t),Le(e)}function Ze(e){return e._pendingPullIntos.shift()}function $e(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function er(e){var r=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===r._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){var t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){var o=new TypeError("Insufficient bytes to fill elements in the given buffer");throw tr(e,o),o}}$e(e),ro(r)}}function rr(e,r){var t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state){var o=r.buffer,n=r.byteOffset,i=r.byteLength;if(be(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");var a=pe(o);if(e._pendingPullIntos.length>0){var u=e._pendingPullIntos.peek();if(be(u.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Xe(e),u.buffer=pe(u.buffer),"none"===u.readerType&&He(e,u)}if($(t))if(function(e){for(var r=e._controlledReadableByteStream._reader;r._readRequests.length>0;){if(0===e._queueTotalSize)return;or(e,r._readRequests.shift())}}(e),0===Z(t))Qe(e,a,n,i);else e._pendingPullIntos.length>0&&Ze(e),K(t,new Uint8Array(a,n,i),!1);else if(hr(t)){Qe(e,a,n,i),xe(t,Je(e))}else Qe(e,a,n,i);Le(e)}}function tr(e,r){var t=e._controlledReadableByteStream;"readable"===t._state&&(Ie(e),je(e),$e(e),to(t,r))}function or(e,r){var t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ge(e);var o=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(o)}function nr(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){var r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),o=Object.create(Ae.prototype);!function(e,r,t){e._associatedReadableByteStreamController=r,e._view=t}(o,e,t),e._byobRequest=o}return e._byobRequest}function ir(e){var r=e._controlledReadableByteStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function ar(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===r)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=pe(t.buffer),Ke(e,r)}function ur(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===r.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");var o=r.byteLength;t.buffer=pe(r.buffer),Ke(e,o)}function lr(e,r,t,o,n,i,a){r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,je(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,r._autoAllocateChunkSize=a,r._pendingPullIntos=new R,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,Le(r),null},function(e){return tr(r,e),null})}function sr(e){return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(e," can only be used on a ReadableStreamBYOBRequest"))}function cr(e){return new TypeError("ReadableByteStreamController.prototype.".concat(e," can only be used on a ReadableByteStreamController"))}function fr(e,r){if("byob"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamReaderMode"));return e}function dr(e){return new _r(e)}function pr(e,r){e._reader._readIntoRequests.push(r)}function br(e){return e._reader._readIntoRequests.length}function hr(e){var r=e._reader;return void 0!==r&&!!yr(r)}Object.defineProperties(ze.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),i(ze.prototype.close,"close"),i(ze.prototype.enqueue,"enqueue"),i(ze.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ze.prototype,r.toStringTag,{value:"ReadableByteStreamController",configurable:!0});var _r=function(){function ReadableStreamBYOBReader(e){if(Q(e,1,"ReadableStreamBYOBReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!De(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");O(this,e),this._readIntoRequests=new R}return Object.defineProperty(ReadableStreamBYOBReader.prototype,"closed",{get:function(){return yr(this)?this._closedPromise:p(wr("closed"))},enumerable:!1,configurable:!0}),ReadableStreamBYOBReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),yr(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(wr("cancel"))},ReadableStreamBYOBReader.prototype.read=function(e,r){if(void 0===r&&(r={}),!yr(this))return p(wr("read"));if(!ArrayBuffer.isView(e))return p(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return p(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return p(new TypeError("view's buffer must have non-zero byteLength"));if(be(e.buffer))return p(new TypeError("view's buffer has been detached"));var t;try{t=function(e,r){var t;return M(e,r),{min:U(null!==(t=null==e?void 0:e.min)&&void 0!==t?t:1,"".concat(r," has member 'min' that"))}}(r,"options")}catch(e){return p(e)}var o=t.min;if(0===o)return p(new TypeError("options.min must be greater than 0"));if(function(e){return Be(e.constructor)}(e)){if(o>e.byteLength)return p(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return p(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return p(k("read from"));var n=function(e,r,t){var o=e._ownerReadableStream;return"errored"===o._state||function(e,r,t){var o=e._controlledReadableByteStream,n=ke(r.constructor);r.byteLength;var i=t*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,r,t)}(this,e,o)?new vr:new mr;return gr(this,e,o,n),n._promise},ReadableStreamBYOBReader.prototype.releaseLock=function(){if(!yr(this))throw wr("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");Sr(e,r)}(this)},ReadableStreamBYOBReader}();Object.defineProperties(_r.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(_r.prototype.cancel,"cancel"),i(_r.prototype.read,"read"),i(_r.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(_r.prototype,r.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var mr=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(e){this._resolvePromise({value:e,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),vr=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(e){this._promise=c({value:e,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function yr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof _r)}function gr(e,r,t,o){var n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,r,t,o){var n,i=e._controlledReadableByteStream,a=r.constructor,u=ke(a),l=r.byteOffset,s=r.byteLength,c=t*u;try{n=pe(r.buffer)}catch(p){return void o._errorSteps(p)}var f={buffer:n,bufferByteLength:n.byteLength,byteOffset:l,byteLength:s,bytesFilled:0,minimumFill:c,elementSize:u,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(f),void pr(i,o);if("closed"!==i._state){if(e._queueTotalSize>0){if(Ve(e,f)){var d=Ye(f);return Ge(e),void o._chunkSteps(d)}if(e._closeRequested){var p=new TypeError("Insufficient bytes to fill elements in the given buffer");return tr(e,p),void o._errorSteps(p)}}e._pendingPullIntos.push(f),pr(i,o),Le(e)}else{var b=new a(f.buffer,f.byteOffset,0);o._closeSteps(b)}}(n._readableStreamController,r,t,o)}function Sr(e,r){var t=e._readIntoRequests;e._readIntoRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function wr(e){return new TypeError("ReadableStreamBYOBReader.prototype.".concat(e," can only be used on a ReadableStreamBYOBReader"))}function Rr(e,r){var t=e.highWaterMark;if(void 0===t)return r;if(qe(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}function Tr(e){var r=e.size;return r||function(){return 1}}function Pr(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===t?void 0:H(t),size:void 0===o?void 0:Cr(o,"".concat(r," has member 'size' that"))}}function Cr(e,r){return x(e,r),function(r){return H(e(r))}}function qr(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Er(e,r,t){return x(e,t),function(){return w(e,r,[])}}function Wr(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Or(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function jr(e,r){if(!zr(e))throw new TypeError("".concat(r," is not a WritableStream."))}var Br=function(){function WritableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,i=null==e?void 0:e.type,a=null==e?void 0:e.write;return{abort:void 0===t?void 0:qr(t,e,"".concat(r," has member 'abort' that")),close:void 0===o?void 0:Er(o,e,"".concat(r," has member 'close' that")),start:void 0===n?void 0:Wr(n,e,"".concat(r," has member 'start' that")),write:void 0===a?void 0:Or(a,e,"".concat(r," has member 'write' that")),type:i}}(e,"First parameter");if(Ar(this),void 0!==o.type)throw new RangeError("Invalid type is specified");var n=Tr(t);!function(e,r,t,o){var n,i,a,u,l=Object.create($r.prototype);n=void 0!==r.start?function(){return r.start(l)}:function(){};i=void 0!==r.write?function(e){return r.write(e,l)}:function(){return d(void 0)};a=void 0!==r.close?function(){return r.close()}:function(){return d(void 0)};u=void 0!==r.abort?function(e){return r.abort(e)}:function(){return d(void 0)};rt(e,l,n,i,a,u,t,o)}(this,o,Rr(t,1),n)}return Object.defineProperty(WritableStream.prototype,"locked",{get:function(){if(!zr(this))throw lt("locked");return Dr(this)},enumerable:!1,configurable:!0}),WritableStream.prototype.abort=function(e){return void 0===e&&(e=void 0),zr(this)?Dr(this)?p(new TypeError("Cannot abort a stream that already has a writer")):Fr(this,e):p(lt("abort"))},WritableStream.prototype.close=function(){return zr(this)?Dr(this)?p(new TypeError("Cannot close a stream that already has a writer")):Yr(this)?p(new TypeError("Cannot close an already-closing stream")):Lr(this):p(lt("close"))},WritableStream.prototype.getWriter=function(){if(!zr(this))throw lt("getWriter");return kr(this)},WritableStream}();function kr(e){return new Hr(e)}function Ar(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new R,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function zr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof Br)}function Dr(e){return void 0!==e._writer}function Fr(e,r){var t;if("closed"===e._state||"errored"===e._state)return d(void 0);e._writableStreamController._abortReason=r,null===(t=e._writableStreamController._abortController)||void 0===t||t.abort(r);var o=e._state;if("closed"===o||"errored"===o)return d(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;var n=!1;"erroring"===o&&(n=!0,r=void 0);var i=f(function(t,o){e._pendingAbortRequest={_promise:void 0,_resolve:t,_reject:o,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=i,n||Mr(e,r),i}function Lr(e){var r=e._state;if("closed"===r||"errored"===r)return p(new TypeError("The stream (in ".concat(r," state) is not in the writable state and cannot be closed")));var t,o=f(function(r,t){var o={_resolve:r,_reject:t};e._closeRequest=o}),n=e._writer;return void 0!==n&&e._backpressure&&"writable"===r&>(n),Oe(t=e._writableStreamController,Zr,0),nt(t),o}function Ir(e,r){"writable"!==e._state?xr(e):Mr(e,r)}function Mr(e,r){var t=e._writableStreamController;e._state="erroring",e._storedError=r;var o=e._writer;void 0!==o&&Xr(o,r),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&t._started&&xr(e)}function xr(e){e._state="errored",e._writableStreamController[P]();var r=e._storedError;if(e._writeRequests.forEach(function(e){e._reject(r)}),e._writeRequests=new R,void 0!==e._pendingAbortRequest){var t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring)return t._reject(r),void Qr(e);h(e._writableStreamController[T](t._reason),function(){return t._resolve(),Qr(e),null},function(r){return t._reject(r),Qr(e),null})}else Qr(e)}function Yr(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function Qr(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);var r=e._writer;void 0!==r&&bt(r,e._storedError)}function Nr(e,r){var t=e._writer;void 0!==t&&r!==e._backpressure&&(r?function(e){_t(e)}(t):gt(t)),e._backpressure=r}Object.defineProperties(Br.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),i(Br.prototype.abort,"abort"),i(Br.prototype.close,"close"),i(Br.prototype.getWriter,"getWriter"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Br.prototype,r.toStringTag,{value:"WritableStream",configurable:!0});var Hr=function(){function WritableStreamDefaultWriter(e){if(Q(e,1,"WritableStreamDefaultWriter"),jr(e,"First parameter"),Dr(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;var r,t=e._state;if("writable"===t)!Yr(e)&&e._backpressure?_t(this):vt(this),dt(this);else if("erroring"===t)mt(this,e._storedError),dt(this);else if("closed"===t)vt(this),dt(r=this),ht(r);else{var o=e._storedError;mt(this,o),pt(this,o)}}return Object.defineProperty(WritableStreamDefaultWriter.prototype,"closed",{get:function(){return Vr(this)?this._closedPromise:p(ct("closed"))},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"desiredSize",{get:function(){if(!Vr(this))throw ct("desiredSize");if(void 0===this._ownerWritableStream)throw ft("desiredSize");return function(e){var r=e._ownerWritableStream,t=r._state;if("errored"===t||"erroring"===t)return null;if("closed"===t)return 0;return ot(r._writableStreamController)}(this)},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"ready",{get:function(){return Vr(this)?this._readyPromise:p(ct("ready"))},enumerable:!1,configurable:!0}),WritableStreamDefaultWriter.prototype.abort=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("abort")):function(e,r){return Fr(e._ownerWritableStream,r)}(this,e):p(ct("abort"))},WritableStreamDefaultWriter.prototype.close=function(){if(!Vr(this))return p(ct("close"));var e=this._ownerWritableStream;return void 0===e?p(ft("close")):Yr(e)?p(new TypeError("Cannot close an already-closing stream")):Ur(this)},WritableStreamDefaultWriter.prototype.releaseLock=function(){if(!Vr(this))throw ct("releaseLock");void 0!==this._ownerWritableStream&&Jr(this)},WritableStreamDefaultWriter.prototype.write=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("write to")):Kr(this,e):p(ct("write"))},WritableStreamDefaultWriter}();function Vr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof Hr)}function Ur(e){return Lr(e._ownerWritableStream)}function Gr(e,r){"pending"===e._closedPromiseState?bt(e,r):function(e,r){pt(e,r)}(e,r)}function Xr(e,r){"pending"===e._readyPromiseState?yt(e,r):function(e,r){mt(e,r)}(e,r)}function Jr(e){var r=e._ownerWritableStream,t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Xr(e,t),Gr(e,t),r._writer=void 0,e._ownerWritableStream=void 0}function Kr(e,r){var t=e._ownerWritableStream,o=t._writableStreamController,n=function(e,r){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(r)}catch(r){return it(e,r),1}}(o,r);if(t!==e._ownerWritableStream)return p(ft("write to"));var i=t._state;if("errored"===i)return p(t._storedError);if(Yr(t)||"closed"===i)return p(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===i)return p(t._storedError);var a=function(e){return f(function(r,t){var o={_resolve:r,_reject:t};e._writeRequests.push(o)})}(t);return function(e,r,t){try{Oe(e,r,t)}catch(r){return void it(e,r)}var o=e._controlledWritableStream;if(!Yr(o)&&"writable"===o._state){Nr(o,at(e))}nt(e)}(o,r,n),a}Object.defineProperties(Hr.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),i(Hr.prototype.abort,"abort"),i(Hr.prototype.close,"close"),i(Hr.prototype.releaseLock,"releaseLock"),i(Hr.prototype.write,"write"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Hr.prototype,r.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});var Zr={},$r=function(){function WritableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(WritableStreamDefaultController.prototype,"abortReason",{get:function(){if(!et(this))throw st("abortReason");return this._abortReason},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultController.prototype,"signal",{get:function(){if(!et(this))throw st("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal},enumerable:!1,configurable:!0}),WritableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!et(this))throw st("error");"writable"===this._controlledWritableStream._state&&ut(this,e)},WritableStreamDefaultController.prototype[T]=function(e){var r=this._abortAlgorithm(e);return tt(this),r},WritableStreamDefaultController.prototype[P]=function(){je(this)},WritableStreamDefaultController}();function et(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof $r)}function rt(e,r,t,o,n,i,a,u){r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._abortReason=void 0,r._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),r._started=!1,r._strategySizeAlgorithm=u,r._strategyHWM=a,r._writeAlgorithm=o,r._closeAlgorithm=n,r._abortAlgorithm=i;var l=at(r);Nr(e,l),h(d(t()),function(){return r._started=!0,nt(r),null},function(t){return r._started=!0,Ir(e,t),null})}function tt(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ot(e){return e._strategyHWM-e._queueTotalSize}function nt(e){var r=e._controlledWritableStream;if(e._started&&void 0===r._inFlightWriteRequest)if("erroring"!==r._state){if(0!==e._queue.length){var t=e._queue.peek().value;t===Zr?function(e){var r=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(r),We(e);var t=e._closeAlgorithm();tt(e),h(t,function(){return function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";var r=e._writer;void 0!==r&&ht(r)}(r),null},function(e){return function(e,r){e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Ir(e,r)}(r,e),null})}(e):function(e,r){var t=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(t);var o=e._writeAlgorithm(r);h(o,function(){!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(t);var r=t._state;if(We(e),!Yr(t)&&"writable"===r){var o=at(e);Nr(t,o)}return nt(e),null},function(r){return"writable"===t._state&&tt(e),function(e,r){e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,Ir(e,r)}(t,r),null})}(e,t)}}else xr(r)}function it(e,r){"writable"===e._controlledWritableStream._state&&ut(e,r)}function at(e){return ot(e)<=0}function ut(e,r){var t=e._controlledWritableStream;tt(e),Mr(t,r)}function lt(e){return new TypeError("WritableStream.prototype.".concat(e," can only be used on a WritableStream"))}function st(e){return new TypeError("WritableStreamDefaultController.prototype.".concat(e," can only be used on a WritableStreamDefaultController"))}function ct(e){return new TypeError("WritableStreamDefaultWriter.prototype.".concat(e," can only be used on a WritableStreamDefaultWriter"))}function ft(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function dt(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}function pt(e,r){dt(e),bt(e,r)}function bt(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ht(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function _t(e){e._readyPromise=f(function(r,t){e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}function mt(e,r){_t(e),yt(e,r)}function vt(e){_t(e),gt(e)}function yt(e,r){void 0!==e._readyPromise_reject&&(y(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function gt(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties($r.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty($r.prototype,r.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});var St="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;var wt,Rt=(function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(wt=null==St?void 0:St.DOMException)?wt:void 0)||function(){var e=function(e,r){this.message=e||"",this.name=r||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return i(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function Tt(e,r,t,o,n,i){var a=X(e),u=kr(r);e._disturbed=!0;var l=new Pt(u),s=new qt(l);return f(function(c,m){var v,g,S,w;if(void 0!==i){if(v=function(){var t=void 0!==i.reason?i.reason:new Rt("Aborted","AbortError"),a=[];o||a.push(function(){return"writable"===r._state?Fr(r,t):d(void 0)}),n||a.push(function(){return"readable"===e._state?eo(e,t):d(void 0)}),P(function(){return Promise.all(a.map(function(e){return e()}))},!0,t)},i.aborted)return void v();i.addEventListener("abort",v)}function R(){for(;!l._shuttingDown&&!r._backpressure&&"writable"===r._state&&!Yr(r)&&"readable"===e._state&&le(a);)ue(a,s);if(l._shuttingDown)return d(!0);if(r._backpressure)return b(u._readyPromise,R);var t=new Ct(l);return ue(a,t),t._promise}if(Et(e,a._closedPromise,function(e){return o?C(!0,e):P(function(){return Fr(r,e)},!0,e),null}),Et(r,u._closedPromise,function(r){return n?C(!0,r):P(function(){return eo(e,r)},!0,r),null}),g=e,S=a._closedPromise,w=function(){return t?C():P(function(){return function(e){var r=e._ownerWritableStream,t=r._state;return Yr(r)||"closed"===t?d(void 0):"errored"===t?p(r._storedError):Ur(e)}(u)}),null},"closed"===g._state?w():_(S,w),Yr(r)||"closed"===r._state){var T=new TypeError("the destination writable stream closed before all data could be piped to it");n?C(!0,T):P(function(){return eo(e,T)},!0,T)}function P(e,t,o){function n(){return h(e(),function(){return q(t,o)},function(e){return q(!0,e)}),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?n():_(l._waitForWritesToFinish(),n))}function C(e,t){l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?q(e,t):_(l._waitForWritesToFinish(),function(){return q(e,t)}))}function q(e,r){return Jr(u),B(a),void 0!==i&&i.removeEventListener("abort",v),e?m(r):c(void 0),null}y(f(function(e,r){!function t(o){o?e():b(R(),t,r)}(!1)}))})}var Pt=function(){function e(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=d(void 0)}return e.prototype._waitForWritesToFinish=function(){var e=this,r=this._currentWrite;return b(this._currentWrite,function(){return r!==e._currentWrite?e._waitForWritesToFinish():void 0})},e}(),Ct=function(){function e(e){var r=this;this._state=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t),this._resolvePromise(!1)},e.prototype._closeSteps=function(){this._resolvePromise(!0)},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),qt=function(){function e(e){this._state=e}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t)},e.prototype._closeSteps=function(){},e.prototype._errorSteps=function(e){},e}();function Et(e,r,t){"errored"===e._state?t(e._storedError):m(r,t)}var Wt=function(){function ReadableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Ot(this))throw Mt("desiredSize");return Ft(this)},enumerable:!1,configurable:!0}),ReadableStreamDefaultController.prototype.close=function(){if(!Ot(this))throw Mt("close");if(!Lt(this))throw new TypeError("The stream is not in a state that permits close");At(this)},ReadableStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("enqueue");if(!Lt(this))throw new TypeError("The stream is not in a state that permits enqueue");return zt(this,e)},ReadableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("error");Dt(this,e)},ReadableStreamDefaultController.prototype[C]=function(e){je(this);var r=this._cancelAlgorithm(e);return kt(this),r},ReadableStreamDefaultController.prototype[q]=function(e){var r=this._controlledReadableStream;if(this._queue.length>0){var t=We(this);this._closeRequested&&0===this._queue.length?(kt(this),ro(r)):jt(this),e._chunkSteps(t)}else J(r,e),jt(this)},ReadableStreamDefaultController.prototype[E]=function(){return this._queue.length>0},ReadableStreamDefaultController.prototype[W]=function(){},ReadableStreamDefaultController}();function Ot(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof Wt)}function jt(e){Bt(e)&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,jt(e)),null},function(r){return Dt(e,r),null})))}function Bt(e){var r=e._controlledReadableStream;return!!Lt(e)&&(!!e._started&&(!!($t(r)&&Z(r)>0)||Ft(e)>0))}function kt(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function At(e){if(Lt(e)){var r=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(kt(e),ro(r))}}function zt(e,r){if(Lt(e)){var t=e._controlledReadableStream;if($t(t)&&Z(t)>0)K(t,r,!1);else{var o=void 0;try{o=e._strategySizeAlgorithm(r)}catch(r){throw Dt(e,r),r}try{Oe(e,r,o)}catch(r){throw Dt(e,r),r}}jt(e)}}function Dt(e,r){var t=e._controlledReadableStream;"readable"===t._state&&(je(e),kt(e),to(t,r))}function Ft(e){var r=e._controlledReadableStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function Lt(e){var r=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===r}function It(e,r,t,o,n,i,a){r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=a,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,jt(r),null},function(e){return Dt(r,e),null})}function Mt(e){return new TypeError("ReadableStreamDefaultController.prototype.".concat(e," can only be used on a ReadableStreamDefaultController"))}function xt(e,r){return De(e._readableStreamController)?function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=!1,b=f(function(e){i=e});function h(e){m(e._closedPromise,function(r){return e!==a||(tr(o._readableStreamController,r),tr(n._readableStreamController,r),c&&p||i(void 0)),null})}function _(){yr(a)&&(B(a),h(a=X(e))),ue(a,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var t=r,a=r;if(!c&&!p)try{a=Ee(r)}catch(r){return tr(o._readableStreamController,r),tr(n._readableStreamController,r),void i(eo(e,r))}c||rr(o._readableStreamController,t),p||rr(n._readableStreamController,a),u=!1,l?y():s&&S()})},_closeSteps:function(){u=!1,c||er(o._readableStreamController),p||er(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&ar(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&ar(n._readableStreamController,0),c&&p||i(void 0)},_errorSteps:function(){u=!1}})}function v(r,t){ae(a)&&(B(a),h(a=dr(e)));var f=t?n:o,d=t?o:n;gr(a,r,1,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var o=t?p:c;if(t?c:p)o||ur(f._readableStreamController,r);else{var n=void 0;try{n=Ee(r)}catch(r){return tr(f._readableStreamController,r),tr(d._readableStreamController,r),void i(eo(e,r))}o||ur(f._readableStreamController,r),rr(d._readableStreamController,n)}u=!1,l?y():s&&S()})},_closeSteps:function(e){u=!1;var r=t?p:c,o=t?c:p;r||er(f._readableStreamController),o||er(d._readableStreamController),void 0!==e&&(r||ur(f._readableStreamController,e),!o&&d._readableStreamController._pendingPullIntos.length>0&&ar(d._readableStreamController,0)),r&&o||i(void 0)},_errorSteps:function(){u=!1}})}function y(){if(u)return l=!0,d(void 0);u=!0;var e=nr(o._readableStreamController);return null===e?_():v(e._view,!1),d(void 0)}function S(){if(u)return s=!0,d(void 0);u=!0;var e=nr(n._readableStreamController);return null===e?_():v(e._view,!0),d(void 0)}function w(o){if(c=!0,r=o,p){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function R(o){if(p=!0,t=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function T(){}return o=Jt(T,y,w),n=Jt(T,S,R),h(a),[o,n]}(e):function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=f(function(e){i=e});function b(){return u?(l=!0,d(void 0)):(u=!0,ue(a,{_chunkSteps:function(e){g(function(){l=!1;var r=e,t=e;s||zt(o._readableStreamController,r),c||zt(n._readableStreamController,t),u=!1,l&&b()})},_closeSteps:function(){u=!1,s||At(o._readableStreamController),c||At(n._readableStreamController),s&&c||i(void 0)},_errorSteps:function(){u=!1}}),d(void 0))}function h(o){if(s=!0,r=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function _(o){if(c=!0,t=o,s){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function v(){}return o=Xt(v,b,h),n=Xt(v,b,_),m(a._closedPromise,function(e){return Dt(o._readableStreamController,e),Dt(n._readableStreamController,e),s&&c||i(void 0),null}),[o,n]}(e)}function Yt(e){return o(r=e)&&void 0!==r.getReader?function(e){var r;function n(){var t;try{t=e.read()}catch(e){return p(e)}return v(t,function(e){if(!o(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function i(r){try{return d(e.cancel(r))}catch(e){return p(e)}}return r=Xt(t,n,i,0),r}(e.getReader()):function(e){var r,n=ge(e,"async");function i(){var e;try{e=Se(n)}catch(e){return p(e)}return v(d(e),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function a(e){var r,t=n.iterator;try{r=_e(t,"return")}catch(e){return p(e)}return void 0===r?d(void 0):v(w(r,t,[e]),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return r=Xt(t,i,a,0),r}(e);var r}function Qt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Nt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Ht(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Vt(e,r){if("bytes"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamType"));return e}function Ut(e,r){M(e,r);var t=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,i=null==e?void 0:e.signal;return void 0!==i&&function(e,r){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError("".concat(r," is not an AbortSignal."))}(i,"".concat(r," has member 'signal' that")),{preventAbort:Boolean(t),preventCancel:Boolean(o),preventClose:Boolean(n),signal:i}}Object.defineProperties(Wt.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),i(Wt.prototype.close,"close"),i(Wt.prototype.enqueue,"enqueue"),i(Wt.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Wt.prototype,r.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});var Gt=function(){function ReadableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=e,o=null==t?void 0:t.autoAllocateChunkSize,n=null==t?void 0:t.cancel,i=null==t?void 0:t.pull,a=null==t?void 0:t.start,u=null==t?void 0:t.type;return{autoAllocateChunkSize:void 0===o?void 0:U(o,"".concat(r," has member 'autoAllocateChunkSize' that")),cancel:void 0===n?void 0:Qt(n,t,"".concat(r," has member 'cancel' that")),pull:void 0===i?void 0:Nt(i,t,"".concat(r," has member 'pull' that")),start:void 0===a?void 0:Ht(a,t,"".concat(r," has member 'start' that")),type:void 0===u?void 0:Vt(u,"".concat(r," has member 'type' that"))}}(e,"First parameter");if(Kt(this),"bytes"===o.type){if(void 0!==t.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,r,t){var o,n,i,a=Object.create(ze.prototype);o=void 0!==r.start?function(){return r.start(a)}:function(){},n=void 0!==r.pull?function(){return r.pull(a)}:function(){return d(void 0)},i=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};var u=r.autoAllocateChunkSize;if(0===u)throw new TypeError("autoAllocateChunkSize must be greater than 0");lr(e,a,o,n,i,t,u)}(this,o,Rr(t,0))}else{var n=Tr(t);!function(e,r,t,o){var n,i,a,u=Object.create(Wt.prototype);n=void 0!==r.start?function(){return r.start(u)}:function(){},i=void 0!==r.pull?function(){return r.pull(u)}:function(){return d(void 0)},a=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)},It(e,u,n,i,a,t,o)}(this,o,Rr(t,1),n)}}return Object.defineProperty(ReadableStream.prototype,"locked",{get:function(){if(!Zt(this))throw oo("locked");return $t(this)},enumerable:!1,configurable:!0}),ReadableStream.prototype.cancel=function(e){return void 0===e&&(e=void 0),Zt(this)?$t(this)?p(new TypeError("Cannot cancel a stream that already has a reader")):eo(this,e):p(oo("cancel"))},ReadableStream.prototype.getReader=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("getReader");return void 0===function(e,r){M(e,r);var t=null==e?void 0:e.mode;return{mode:void 0===t?void 0:fr(t,"".concat(r," has member 'mode' that"))}}(e,"First parameter").mode?X(this):dr(this)},ReadableStream.prototype.pipeThrough=function(e,r){if(void 0===r&&(r={}),!Zt(this))throw oo("pipeThrough");Q(e,1,"pipeThrough");var t=function(e,r){M(e,r);var t=null==e?void 0:e.readable;N(t,"readable","ReadableWritablePair"),G(t,"".concat(r," has member 'readable' that"));var o=null==e?void 0:e.writable;return N(o,"writable","ReadableWritablePair"),jr(o,"".concat(r," has member 'writable' that")),{readable:t,writable:o}}(e,"First parameter"),o=Ut(r,"Second parameter");if($t(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Dr(t.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return y(Tt(this,t.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),t.readable},ReadableStream.prototype.pipeTo=function(e,r){if(void 0===r&&(r={}),!Zt(this))return p(oo("pipeTo"));if(void 0===e)return p("Parameter 1 is required in 'pipeTo'.");if(!zr(e))return p(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));var t;try{t=Ut(r,"Second parameter")}catch(e){return p(e)}return $t(this)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Dr(e)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Tt(this,e,t.preventClose,t.preventAbort,t.preventCancel,t.signal)},ReadableStream.prototype.tee=function(){if(!Zt(this))throw oo("tee");return fe(xt(this))},ReadableStream.prototype.values=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("values");var r,t,o,n,i,a=function(e,r){M(e,r);var t=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(t)}}(e,"First parameter");return r=this,t=a.preventCancel,o=X(r),n=new we(o,t),(i=Object.create(Te))._asyncIteratorImpl=n,i},ReadableStream.prototype[ye]=function(e){return this.values(e)},ReadableStream.from=function(e){return Yt(e)},ReadableStream}();function Xt(e,r,t,o,n){void 0===o&&(o=1),void 0===n&&(n=function(){return 1});var i=Object.create(Gt.prototype);return Kt(i),It(i,Object.create(Wt.prototype),e,r,t,o,n),i}function Jt(e,r,t){var o=Object.create(Gt.prototype);return Kt(o),lr(o,Object.create(ze.prototype),e,r,t,0,void 0),o}function Kt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Zt(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof Gt)}function $t(e){return void 0!==e._reader}function eo(e,r){if(e._disturbed=!0,"closed"===e._state)return d(void 0);if("errored"===e._state)return p(e._storedError);ro(e);var o=e._reader;if(void 0!==o&&yr(o)){var n=o._readIntoRequests;o._readIntoRequests=new R,n.forEach(function(e){e._closeSteps(void 0)})}return v(e._readableStreamController[C](r),t)}function ro(e){e._state="closed";var r=e._reader;if(void 0!==r&&(F(r),ae(r))){var t=r._readRequests;r._readRequests=new R,t.forEach(function(e){e._closeSteps()})}}function to(e,r){e._state="errored",e._storedError=r;var t=e._reader;void 0!==t&&(D(t,r),ae(t)?se(t,r):Sr(t,r))}function oo(e){return new TypeError("ReadableStream.prototype.".concat(e," can only be used on a ReadableStream"))}function no(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark;return N(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:H(t)}}Object.defineProperties(Gt,{from:{enumerable:!0}}),Object.defineProperties(Gt.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),i(Gt.from,"from"),i(Gt.prototype.cancel,"cancel"),i(Gt.prototype.getReader,"getReader"),i(Gt.prototype.pipeThrough,"pipeThrough"),i(Gt.prototype.pipeTo,"pipeTo"),i(Gt.prototype.tee,"tee"),i(Gt.prototype.values,"values"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Gt.prototype,r.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(Gt.prototype,ye,{value:Gt.prototype.values,writable:!0,configurable:!0});var io=function(e){return e.byteLength};i(io,"size");var ao=function(){function ByteLengthQueuingStrategy(e){Q(e,1,"ByteLengthQueuingStrategy"),e=no(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(ByteLengthQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!lo(this))throw uo("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(ByteLengthQueuingStrategy.prototype,"size",{get:function(){if(!lo(this))throw uo("size");return io},enumerable:!1,configurable:!0}),ByteLengthQueuingStrategy}();function uo(e){return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(e," can only be used on a ByteLengthQueuingStrategy"))}function lo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ao)}Object.defineProperties(ao.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(ao.prototype,r.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});var so=function(){return 1};i(so,"size");var co=function(){function CountQueuingStrategy(e){Q(e,1,"CountQueuingStrategy"),e=no(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(CountQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!po(this))throw fo("highWaterMark");return this._countQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(CountQueuingStrategy.prototype,"size",{get:function(){if(!po(this))throw fo("size");return so},enumerable:!1,configurable:!0}),CountQueuingStrategy}();function fo(e){return new TypeError("CountQueuingStrategy.prototype.".concat(e," can only be used on a CountQueuingStrategy"))}function po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof co)}function bo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function ho(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function _o(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function mo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}Object.defineProperties(co.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(co.prototype,r.toStringTag,{value:"CountQueuingStrategy",configurable:!0});var vo=function(){function TransformStream(e,r,t){void 0===e&&(e={}),void 0===r&&(r={}),void 0===t&&(t={}),void 0===e&&(e=null);var o=Pr(r,"Second parameter"),n=Pr(t,"Third parameter"),i=function(e,r){M(e,r);var t=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,i=null==e?void 0:e.start,a=null==e?void 0:e.transform,u=null==e?void 0:e.writableType;return{cancel:void 0===t?void 0:mo(t,e,"".concat(r," has member 'cancel' that")),flush:void 0===o?void 0:bo(o,e,"".concat(r," has member 'flush' that")),readableType:n,start:void 0===i?void 0:ho(i,e,"".concat(r," has member 'start' that")),transform:void 0===a?void 0:_o(a,e,"".concat(r," has member 'transform' that")),writableType:u}}(e,"First parameter");if(void 0!==i.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==i.writableType)throw new RangeError("Invalid writableType specified");var a,u=Rr(n,0),l=Tr(n),s=Rr(o,1),c=Tr(o);!function(e,r,t,o,n,i){function a(){return r}function u(r){return function(e,r){var t=e._transformStreamController;if(e._backpressure){return v(e._backpressureChangePromise,function(){var o=e._writable;if("erroring"===o._state)throw o._storedError;return Eo(t,r)})}return Eo(t,r)}(e,r)}function l(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._readable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(Dt(o._readableStreamController,r),Oo(t)),null},function(e){return Dt(o._readableStreamController,e),jo(t,e),null}),t._finishPromise}(e,r)}function s(){return function(e){var r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;var t=e._readable;r._finishPromise=f(function(e,t){r._finishPromise_resolve=e,r._finishPromise_reject=t});var o=r._flushAlgorithm();return Co(r),h(o,function(){return"errored"===t._state?jo(r,t._storedError):(At(t._readableStreamController),Oo(r)),null},function(e){return Dt(t._readableStreamController,e),jo(r,e),null}),r._finishPromise}(e)}function c(){return function(e){return Ro(e,!1),e._backpressureChangePromise}(e)}function d(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._writable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(it(o._writableStreamController,r),wo(e),Oo(t)),null},function(r){return it(o._writableStreamController,r),wo(e),jo(t,r),null}),t._finishPromise}(e,r)}e._writable=function(e,r,t,o,n,i){void 0===n&&(n=1),void 0===i&&(i=function(){return 1});var a=Object.create(Br.prototype);return Ar(a),rt(a,Object.create($r.prototype),e,r,t,o,n,i),a}(a,u,s,l,t,o),e._readable=Xt(a,c,d,n,i),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,Ro(e,!0),e._transformStreamController=void 0}(this,f(function(e){a=e}),s,c,u,l),function(e,r){var t,o,n,i=Object.create(To.prototype);t=void 0!==r.transform?function(e){return r.transform(e,i)}:function(e){try{return qo(i,e),d(void 0)}catch(e){return p(e)}};o=void 0!==r.flush?function(){return r.flush(i)}:function(){return d(void 0)};n=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};!function(e,r,t,o,n){r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=o,r._cancelAlgorithm=n,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}(e,i,t,o,n)}(this,i),void 0!==i.start?a(i.start(this._transformStreamController)):a(void 0)}return Object.defineProperty(TransformStream.prototype,"readable",{get:function(){if(!yo(this))throw Bo("readable");return this._readable},enumerable:!1,configurable:!0}),Object.defineProperty(TransformStream.prototype,"writable",{get:function(){if(!yo(this))throw Bo("writable");return this._writable},enumerable:!1,configurable:!0}),TransformStream}();function yo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof vo)}function go(e,r){Dt(e._readable._readableStreamController,r),So(e,r)}function So(e,r){Co(e._transformStreamController),it(e._writable._writableStreamController,r),wo(e)}function wo(e){e._backpressure&&Ro(e,!1)}function Ro(e,r){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=f(function(r){e._backpressureChangePromise_resolve=r}),e._backpressure=r}Object.defineProperties(vo.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(vo.prototype,r.toStringTag,{value:"TransformStream",configurable:!0});var To=function(){function TransformStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(TransformStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Po(this))throw Wo("desiredSize");return Ft(this._controlledTransformStream._readable._readableStreamController)},enumerable:!1,configurable:!0}),TransformStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("enqueue");qo(this,e)},TransformStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("error");var r;r=e,go(this._controlledTransformStream,r)},TransformStreamDefaultController.prototype.terminate=function(){if(!Po(this))throw Wo("terminate");!function(e){var r=e._controlledTransformStream;At(r._readable._readableStreamController);var t=new TypeError("TransformStream terminated");So(r,t)}(this)},TransformStreamDefaultController}();function Po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof To)}function Co(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function qo(e,r){var t=e._controlledTransformStream,o=t._readable._readableStreamController;if(!Lt(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{zt(o,r)}catch(e){throw So(t,e),t._readable._storedError}var n=function(e){return!Bt(e)}(o);n!==t._backpressure&&Ro(t,!0)}function Eo(e,r){return v(e._transformAlgorithm(r),void 0,function(r){throw go(e._controlledTransformStream,r),r})}function Wo(e){return new TypeError("TransformStreamDefaultController.prototype.".concat(e," can only be used on a TransformStreamDefaultController"))}function Oo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function jo(e,r){void 0!==e._finishPromise_reject&&(y(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function Bo(e){return new TypeError("TransformStream.prototype.".concat(e," can only be used on a TransformStream"))}Object.defineProperties(To.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),i(To.prototype.enqueue,"enqueue"),i(To.prototype.error,"error"),i(To.prototype.terminate,"terminate"),"symbol"==typeof r.toStringTag&&Object.defineProperty(To.prototype,r.toStringTag,{value:"TransformStreamDefaultController",configurable:!0}),e.ByteLengthQueuingStrategy=ao,e.CountQueuingStrategy=co,e.ReadableByteStreamController=ze,e.ReadableStream=Gt,e.ReadableStreamBYOBReader=_r,e.ReadableStreamBYOBRequest=Ae,e.ReadableStreamDefaultController=Wt,e.ReadableStreamDefaultReader=ee,e.TransformStream=vo,e.TransformStreamDefaultController=To,e.WritableStream=Br,e.WritableStreamDefaultController=$r,e.WritableStreamDefaultWriter=Hr}); diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..254b10dc 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -78,6 +78,7 @@ target_link_libraries(UnitTests PRIVATE Performance PRIVATE TextDecoder PRIVATE TextEncoder + PRIVATE Streams ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..6b153c59 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1541,6 +1541,162 @@ describe("Console", function () { }); }); +describe("Web Streams", function () { + // Focused ports from the WHATWG Streams WPT suites at c05b4473: + // readable-streams/general.any.js and tee.any.js, + // writable-streams/write.any.js, and transform-streams/general.any.js. + it("installs the standard stream constructors", function () { + expect(ReadableStream).to.be.a("function"); + expect(WritableStream).to.be.a("function"); + expect(TransformStream).to.be.a("function"); + expect(ByteLengthQueuingStrategy).to.be.a("function"); + expect(CountQueuingStrategy).to.be.a("function"); + }); + + it("delivers queued chunks in order and closes the reader", async function () { + const stream = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }); + const reader = stream.getReader(); + + expect(await reader.read()).to.deep.equal({ value: "a", done: false }); + expect(await reader.read()).to.deep.equal({ value: "b", done: false }); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + await reader.closed; + }); + + it("propagates a rejected pull to read and closed", async function () { + const failure = new Error("pull failed"); + const reader = new ReadableStream({ + pull() { + return Promise.reject(failure); + } + }).getReader(); + + let readFailure: unknown; + let closedFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + try { await reader.closed; } catch (error) { closedFailure = error; } + expect(readFailure).to.equal(failure); + expect(closedFailure).to.equal(failure); + }); + + it("tees without one branch consuming the other", async function () { + const [first, second] = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }).tee(); + const firstReader = first.getReader(); + const secondReader = second.getReader(); + + expect(await firstReader.read()).to.deep.equal({ value: "a", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: "b", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: undefined, done: true }); + expect(await secondReader.read()).to.deep.equal({ value: "a", done: false }); + }); + + it("waits for asynchronous writes before closing", async function () { + const stored: number[] = []; + const writable = new WritableStream({ + write(chunk) { + return Promise.resolve().then(() => stored.push(chunk)); + } + }); + const writer = writable.getWriter(); + + writer.write(1); + writer.write(2); + await writer.close(); + expect(stored).to.deep.equal([1, 2]); + }); + + it("applies transform output and backpressure", async function () { + const transform = new TransformStream({ + transform(chunk, controller) { + controller.enqueue(chunk.toUpperCase()); + } + }); + const writer = transform.writable.getWriter(); + const reader = transform.readable.getReader(); + const write = writer.write("native"); + + expect(await reader.read()).to.deep.equal({ value: "NATIVE", done: false }); + await write; + await writer.close(); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + }); + + it("supports BYOB reads from byte streams", async function () { + let sent = false; + const stream = new ReadableStream({ + type: "bytes", + pull(controller) { + if (!sent) { + sent = true; + controller.enqueue(new Uint8Array([8, 241, 48, 123, 151])); + controller.close(); + } + } + } as any); + const reader = stream.getReader({ mode: "byob" }); + const result = await reader.read(new Uint8Array(8)); + + expect(result.done).to.equal(false); + expect(Array.from(result.value!)).to.deep.equal([8, 241, 48, 123, 151]); + expect((await reader.read(new Uint8Array(8))).done).to.equal(true); + }); + + // Ported from Firefox's dom/streams/test/xpcshell/subclassing.js. + it("supports subclassed streams, readers, and queuing strategies", async function () { + class SubclassedStream extends ReadableStream {} + class SubclassedStrategy extends CountQueuingStrategy {} + const stream = new SubclassedStream({ + start(controller) { + controller.enqueue("first"); + controller.close(); + } + }); + const Reader = stream.getReader().constructor as typeof ReadableStreamDefaultReader; + class SubclassedReader extends Reader {} + + expect(stream).to.be.instanceOf(ReadableStream); + expect(new SubclassedStrategy({ highWaterMark: 4 }).highWaterMark).to.equal(4); + + const secondStream = new ReadableStream({ + start(controller) { + controller.enqueue("second"); + controller.close(); + } + }); + const reader = new SubclassedReader(secondStream); + expect(await reader.read()).to.deep.equal({ value: "second", done: false }); + }); + + // Ported from Chromium's http/tests/streams/chromium/transform-stream-enqueue.html. + it("rejects enqueues after a transform is terminated or errored", function () { + expect(() => new TransformStream({ + start(controller) { + controller.terminate(); + controller.enqueue("late"); + } + })).to.throw(TypeError); + + expect(() => new TransformStream({ + start(controller) { + controller.error(new Error("failed")); + controller.enqueue("late"); + } + })).to.throw(TypeError); + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..b71218bd 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -90,6 +91,7 @@ TEST(JavaScript, All) Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -166,6 +168,30 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } +TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); + global.Set("ReadableStream", hostReadableStream); + + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").IsFunction()); + + const auto installedTransformStream = global.Get("TransformStream"); + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 226ed90bcd5f5d6dac95a1490e58110caeda240a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 22:19:21 -0700 Subject: [PATCH 072/174] Complete Blob streaming and slicing support Implement iterable BlobPart conversion, MIME and endings normalization, zero-copy Blob composition and slicing, and lazy 64 KiB byte streams. Delegate File streaming and slicing to its backing Blob while preserving browser class identity.\n\nUse immutable shared segments so nested Blob and slice construction do not duplicate payload bytes. Add focused WPT, WebKit, and Firefox regression coverage for constructor ordering, iterator closure, UTF-8 decoding, BYOB reads, cancellation, lifetime safety, and large nested streams. --- Polyfills/Blob/CMakeLists.txt | 1 + Polyfills/Blob/README.md | 12 + Polyfills/Blob/Source/Blob.cpp | 507 ++++++++++++++++++++++++++++--- Polyfills/Blob/Source/Blob.h | 27 +- Polyfills/File/Source/File.cpp | 47 ++- Polyfills/File/Source/File.h | 2 + Tests/UnitTests/Scripts/tests.ts | 227 ++++++++++++++ 7 files changed, 761 insertions(+), 62 deletions(-) create mode 100644 Polyfills/Blob/README.md diff --git a/Polyfills/Blob/CMakeLists.txt b/Polyfills/Blob/CMakeLists.txt index b8da610e..d2f9d88f 100644 --- a/Polyfills/Blob/CMakeLists.txt +++ b/Polyfills/Blob/CMakeLists.txt @@ -1,6 +1,7 @@ set(SOURCES "Include/Babylon/Polyfills/Blob.h" "InternalInclude/Babylon/Polyfills/BlobInternal.h" + "README.md" "Source/Blob.cpp" "Source/Blob.h") diff --git a/Polyfills/Blob/README.md b/Polyfills/Blob/README.md new file mode 100644 index 00000000..2206f9c4 --- /dev/null +++ b/Polyfills/Blob/README.md @@ -0,0 +1,12 @@ +# Blob + +Provides the browser `Blob` constructor, byte/text readers, zero-copy Blob +composition and slicing, and a lazily pulled byte `ReadableStream`. + +Call `Babylon::Polyfills::Streams::Initialize` before using `Blob.stream()` on +engines that do not provide Web Streams. Stream reads copy only the requested +chunk into JavaScript-owned memory; composing Blobs and slicing share immutable +native byte segments. + +The focused tests are adapted from WPT `FileAPI/blob`, WebKit's Blob stream +chunk/crash regressions, and Firefox's large Blob `pipeTo` regression. diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 242763fe..bed99cb6 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -3,8 +3,63 @@ #include #include +#include +#include +#include + namespace Babylon::Polyfills::Internal { + struct Blob::Segment + { + std::shared_ptr> Bytes; + size_t Offset{}; + size_t Length{}; + }; + + struct Blob::Storage + { + std::vector Segments; + size_t Size{}; + + void Append(const Segment& segment) + { + if (segment.Length == 0) + { + return; + } + + Segments.emplace_back(segment); + Size += segment.Length; + } + + void CopyTo(size_t position, std::byte* destination, size_t length) const + { + size_t segmentStart{}; + for (const auto& segment : Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + if (position < segmentEnd && length > 0) + { + const auto localOffset = position > segmentStart ? position - segmentStart : 0; + const auto copyLength = std::min(segment.Length - localOffset, length); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + localOffset, copyLength); + destination += copyLength; + position += copyLength; + length -= copyLength; + } + segmentStart = segmentEnd; + } + } + }; + + struct Blob::StreamState + { + std::shared_ptr BlobData; + size_t Position{}; + size_t SegmentIndex{}; + size_t SegmentOffset{}; + }; + void Blob::Initialize(Napi::Env env) { static constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; @@ -19,8 +74,14 @@ namespace Babylon::Polyfills::Internal InstanceMethod("text", &Blob::Text), InstanceMethod("arrayBuffer", &Blob::ArrayBuffer), InstanceMethod("bytes", &Blob::Bytes), + InstanceMethod("slice", &Blob::Slice), + InstanceMethod("stream", &Blob::Stream), }); + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_BLOB_CONSTRUCTOR_NAME); + env.Global().Get("Object").As().Get("defineProperty").As().Call(env.Global().Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -28,36 +89,122 @@ namespace Babylon::Polyfills::Internal Blob::Blob(const Napi::CallbackInfo& info) : Napi::ObjectWrap(info) { - if (info.Length() > 0) + auto env = Env(); + auto data = std::make_shared(); + std::vector stringSegmentIndices; + bool convertLineEndings{}; + + if (info.Length() > 0 && !info[0].IsUndefined()) { - const auto blobParts = info[0].As(); + if (!info[0].IsObject() && !info[0].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob parts must be an iterable object."); + } + + const auto blobParts = info[0].As(); + if (blobParts.IsArray()) + { + data->Segments.reserve(blobParts.As().Length()); + } - if (blobParts.Length() > 0) + const auto reflect = env.Global().Get("Reflect").As(); + const auto iteratorMethod = reflect.Get("get").As().Call( + reflect, + {blobParts, Napi::Symbol::WellKnown(env, "iterator")}); + if (!iteratorMethod.IsFunction()) { - const auto firstPart = blobParts.Get(uint32_t{0}); - ProcessBlobPart(firstPart); + throw Napi::TypeError::New(env, "Blob parts must be iterable."); + } - if (blobParts.Length() > 1) + const auto iterator = iteratorMethod.As().Call(blobParts, {}).As(); + const auto next = iterator.Get("next").As(); + try + { + while (true) { - throw Napi::Error::New(Env(), "Using multiple BlobParts in Blob constructor is not implemented."); + const auto result = next.Call(iterator, {}).As(); + if (result.Get("done").ToBoolean().Value()) + { + break; + } + + if (AppendBlobPart(*data, result.Get("value"))) + { + stringSegmentIndices.emplace_back(data->Segments.size() - 1); + } } } + catch (...) + { + try + { + const auto returnMethod = iterator.Get("return"); + if (returnMethod.IsFunction()) + { + returnMethod.As().Call(iterator, {}); + } + } + catch (...) + { + // Preserve the exception that interrupted part conversion. + } + throw; + } } - if (info.Length() > 1) + if (info.Length() > 1 && !info[1].IsUndefined() && !info[1].IsNull()) { + if (!info[1].IsObject() && !info[1].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob options must be an object."); + } + const auto options = info[1].As(); + const auto endings = options.Get("endings"); + if (!endings.IsUndefined()) + { + const auto value = endings.ToString().Utf8Value(); + if (value != "transparent" && value != "native") + { + throw Napi::TypeError::New(env, "Blob endings must be 'transparent' or 'native'."); + } + convertLineEndings = value == "native"; + } + + const auto type = options.Get("type"); + if (!type.IsUndefined()) + { + m_type = NormalizeType(type.ToString().Utf8Value()); + } + } - if (options.Has("type")) + if (convertLineEndings) + { + for (const auto segmentIndex : stringSegmentIndices) { - m_type = options.Get("type").As().Utf8Value(); + auto& segment = data->Segments[segmentIndex]; + auto value = std::string{ + reinterpret_cast(segment.Bytes->data() + segment.Offset), + segment.Length}; + value = NormalizeLineEndings(std::move(value)); + + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data->Size -= segment.Length; + segment = {std::move(bytes), 0, value.size()}; + data->Size += segment.Length; } } + + m_data = std::move(data); } Napi::Value Blob::GetSize(const Napi::CallbackInfo&) { - return Napi::Value::From(Env(), m_data->size()); + return Napi::Value::From(Env(), m_data->Size); } Napi::Value Blob::GetType(const Napi::CallbackInfo&) @@ -68,8 +215,11 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::Text(const Napi::CallbackInfo&) { // NOTE: This will not check for UTF-8 validity - const auto begin = reinterpret_cast(m_data->data()); - std::string text(begin, m_data->size()); + std::string text(m_data->Size, '\0'); + if (!text.empty()) + { + m_data->CopyTo(0, reinterpret_cast(text.data()), text.size()); + } const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(Napi::String::New(Env(), text)); @@ -78,60 +228,333 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::ArrayBuffer(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto deferred = Napi::Promise::Deferred::New(Env()); - deferred.Resolve(arrayBuffer); + deferred.Resolve(CreateArrayBuffer()); return deferred.Promise(); } Napi::Value Blob::Bytes(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->size(), arrayBuffer, 0); + const auto arrayBuffer = CreateArrayBuffer(); + const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->Size, arrayBuffer, 0); const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(uint8Array); return deferred.Promise(); } - void Blob::ProcessBlobPart(const Napi::Value& blobPart) + Napi::Value Blob::Slice(const Napi::CallbackInfo& info) { + const auto start = NormalizeSliceIndex( + info.Length() > 0 && !info[0].IsUndefined() ? info[0].ToNumber().DoubleValue() : 0, + m_data->Size); + const auto end = NormalizeSliceIndex( + info.Length() > 1 && !info[1].IsUndefined() ? info[1].ToNumber().DoubleValue() : static_cast(m_data->Size), + m_data->Size); + const auto sliceEnd = std::max(start, end); + + auto sliceData = std::make_shared(); + size_t segmentStart{}; + for (const auto& segment : m_data->Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + const auto overlapStart = std::max(start, segmentStart); + const auto overlapEnd = std::min(sliceEnd, segmentEnd); + if (overlapStart < overlapEnd) + { + sliceData->Append({segment.Bytes, segment.Offset + overlapStart - segmentStart, overlapEnd - overlapStart}); + } + segmentStart = segmentEnd; + if (segmentStart >= sliceEnd) + { + break; + } + } + + std::string contentType; + if (info.Length() > 2 && !info[2].IsUndefined()) + { + contentType = NormalizeType(info[2].ToString().Utf8Value()); + } + + const auto blobConstructor = Env().Global().Get("Blob").As(); + const auto result = blobConstructor.New({Napi::Array::New(Env())}); + auto resultBlob = Napi::ObjectWrap::Unwrap(result); + resultBlob->m_data = std::move(sliceData); + resultBlob->m_type = std::move(contentType); + return result; + } + + Napi::Value Blob::Stream(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + const auto readableStreamValue = env.Global().Get("ReadableStream"); + if (!readableStreamValue.IsFunction()) + { + throw Napi::TypeError::New(env, "Blob.stream() requires ReadableStream to be installed."); + } + + auto state = std::make_shared(); + state->BlobData = m_data; + + auto source = Napi::Object::New(env); + source.Set("type", "bytes"); + source.Set("pull", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + auto callbackEnv = callbackInfo.Env(); + auto controller = callbackInfo[0].As(); + if (!state->BlobData || state->Position >= state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + return callbackEnv.Undefined(); + } + + constexpr size_t CHUNK_SIZE = 64 * 1024; + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + auto destination = static_cast(outputBuffer.Data()); + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + + if (state->Position == state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + } + + return callbackEnv.Undefined(); + })); + source.Set("cancel", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + state->BlobData.reset(); + return callbackInfo.Env().Undefined(); + })); + + return readableStreamValue.As().New({source}); + } + + bool Blob::AppendBlobPart(Storage& data, const Napi::Value& blobPart) + { + const std::byte* source{}; + size_t length{}; + bool isBufferSource{}; + if (blobPart.IsArrayBuffer()) { const auto buffer = blobPart.As(); - const auto begin = static_cast(buffer.Data()); - m_data = std::make_shared>(begin, begin + buffer.ByteLength()); + source = static_cast(buffer.Data()); + length = buffer.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsTypedArray() || blobPart.IsDataView()) + else if (blobPart.IsTypedArray()) { const auto array = blobPart.As(); const auto buffer = array.ArrayBuffer(); - const auto begin = static_cast(buffer.Data()) + array.ByteOffset(); - m_data = std::make_shared>(begin, begin + array.ByteLength()); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + array.ByteOffset(); + length = array.ByteLength(); + isBufferSource = true; + } + else if (blobPart.IsDataView()) + { + const auto view = blobPart.As(); + const auto buffer = view.ArrayBuffer(); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); + length = view.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsString()) + else if (blobPart.IsObject()) { - const auto str = blobPart.As().Utf8Value(); - const auto begin = reinterpret_cast(str.data()); - m_data = std::make_shared>(begin, begin + str.length()); + const auto object = blobPart.As(); + const auto blobConstructor = Env().Global().Get("Blob").As(); + if (object.InstanceOf(blobConstructor)) + { + auto nativeBlob = object; + if (!object.Get("constructor").StrictEquals(blobConstructor)) + { + nativeBlob = object.Get("slice").As().Call(object, {Napi::Number::New(Env(), 0), object.Get("size")}).As(); + } + + const auto blob = Napi::ObjectWrap::Unwrap(nativeBlob); + data.Segments.reserve(data.Segments.size() + blob->m_data->Segments.size()); + for (const auto& segment : blob->m_data->Segments) + { + data.Append(segment); + } + return false; + } } - else + + if (isBufferSource) { - // Assume it's another Blob object. Blobs are immutable, so the buffer can be shared - // rather than copied. - const auto obj = blobPart.As(); - const auto blobObj = Napi::ObjectWrap::Unwrap(obj); - m_data = blobObj->m_data; + auto bytes = std::make_shared>(length); + if (length > 0) + { + std::memcpy(bytes->data(), source, length); + } + data.Append({std::move(bytes), 0, length}); + return false; } + + auto value = blobPart.ToString().Utf8Value(); + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data.Append({std::move(bytes), 0, value.size()}); + return !value.empty(); + } + + Napi::ArrayBuffer Blob::CreateArrayBuffer() const + { + auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, static_cast(arrayBuffer.Data()), m_data->Size); + } + return arrayBuffer; + } + + const std::shared_ptr>& Blob::Data() const + { + if (!m_contiguous) + { + const auto& segments = m_data->Segments; + if (segments.size() == 1 && segments[0].Offset == 0 && segments[0].Length == segments[0].Bytes->size()) + { + m_contiguous = segments[0].Bytes; + } + else + { + auto bytes = std::make_shared>(m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, bytes->data(), m_data->Size); + } + m_contiguous = std::move(bytes); + } + } + return m_contiguous; + } + + std::string Blob::NormalizeType(std::string type) + { + for (auto& character : type) + { + const auto value = static_cast(character); + if (value < 0x20 || value > 0x7E) + { + return {}; + } + if (character >= 'A' && character <= 'Z') + { + character = static_cast(character - 'A' + 'a'); + } + } + return type; + } + + std::string Blob::NormalizeLineEndings(std::string value) + { +#ifdef _WIN32 + static constexpr auto nativeNewline = "\r\n"; +#else + static constexpr auto nativeNewline = "\n"; +#endif + size_t outputLength{}; + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + outputLength += std::char_traits::length(nativeNewline); + } + else if (value[index] == '\n') + { + outputLength += std::char_traits::length(nativeNewline); + } + else + { + ++outputLength; + } + } + + std::string result; + result.reserve(outputLength); + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + result.append(nativeNewline); + } + else if (value[index] == '\n') + { + result.append(nativeNewline); + } + else + { + result.push_back(value[index]); + } + } + return result; + } + + size_t Blob::NormalizeSliceIndex(double value, size_t size) + { + if (std::isnan(value)) + { + return 0; + } + + const auto magnitude = std::abs(value); + const auto lower = std::floor(magnitude); + const auto fraction = magnitude - lower; + auto rounded = lower; + if (fraction > 0.5 || (fraction == 0.5 && std::fmod(lower, 2.0) != 0.0)) + { + rounded += 1.0; + } + + if (value < 0) + { + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? 0 + : size - static_cast(rounded); + } + + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? size + : static_cast(rounded); } } diff --git a/Polyfills/Blob/Source/Blob.h b/Polyfills/Blob/Source/Blob.h index 5d0147d0..1f061f97 100644 --- a/Polyfills/Blob/Source/Blob.h +++ b/Polyfills/Blob/Source/Blob.h @@ -6,6 +6,7 @@ #include #include #include +#include namespace Babylon::Polyfills::Internal { @@ -17,9 +18,11 @@ namespace Babylon::Polyfills::Internal explicit Blob(const Napi::CallbackInfo& info); // Synchronous accessors for internal cross-polyfill use (e.g. URL.createObjectURL). - // A Blob is immutable once constructed, so the bytes are held in a shared_ptr and can be - // shared with consumers rather than copied. Never null. - const std::shared_ptr>& Data() const { return m_data; } + // A Blob is immutable once constructed, so its bytes can be shared with consumers rather + // than copied. Storage is segmented (slices and multi-part Blobs share their parts' + // buffers), so Data() hands back the one underlying buffer when there is exactly one, and + // otherwise materializes a contiguous copy once and caches it. Never null. + const std::shared_ptr>& Data() const; const std::string& Type() const { return m_type; } private: @@ -28,10 +31,22 @@ namespace Babylon::Polyfills::Internal Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); + + struct Segment; + struct Storage; + struct StreamState; + + bool AppendBlobPart(Storage& data, const Napi::Value& blobPart); + Napi::ArrayBuffer CreateArrayBuffer() const; - void ProcessBlobPart(const Napi::Value& blobPart); + static std::string NormalizeType(std::string type); + static std::string NormalizeLineEndings(std::string value); + static size_t NormalizeSliceIndex(double value, size_t size); - std::shared_ptr> m_data{std::make_shared>()}; + std::shared_ptr m_data; + mutable std::shared_ptr> m_contiguous; std::string m_type; }; -} \ No newline at end of file +} diff --git a/Polyfills/File/Source/File.cpp b/Polyfills/File/Source/File.cpp index 75261e79..47c07169 100644 --- a/Polyfills/File/Source/File.cpp +++ b/Polyfills/File/Source/File.cpp @@ -46,6 +46,8 @@ namespace Babylon::Polyfills::Internal InstanceMethod("arrayBuffer", &File::ArrayBuffer), InstanceMethod("text", &File::Text), InstanceMethod("bytes", &File::Bytes), + InstanceMethod("slice", &File::Slice), + InstanceMethod("stream", &File::Stream), }); global.Set(JS_FILE_CONSTRUCTOR_NAME, func); @@ -55,12 +57,16 @@ namespace Babylon::Polyfills::Internal // a Blob subtype; BJS core (fileTools, Offline/database, // abstractEngine, thinNativeEngine) branches on `instanceof Blob` // and needs File inputs to satisfy that check. - auto setPrototypeOf = env.Global().Get("Object").As() - .Get("setPrototypeOf").As(); + auto setPrototypeOf = env.Global().Get("Object").As().Get("setPrototypeOf").As(); setPrototypeOf.Call({ func.Get("prototype"), blob.As().Get("prototype"), }); + + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_FILE_CONSTRUCTOR_NAME); + global.Get("Object").As().Get("defineProperty").As().Call(global.Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); } File::File(const Napi::CallbackInfo& info) @@ -75,7 +81,7 @@ namespace Babylon::Polyfills::Internal { throw Napi::TypeError::New(env, "Failed to construct 'File': 2 arguments required, but only " + - std::to_string(info.Length()) + " present."); + std::to_string(info.Length()) + " present."); } Napi::Value parts = info[0]; @@ -114,21 +120,11 @@ namespace Babylon::Polyfills::Internal } } - Napi::Value partsArray; - if (parts.IsArray()) - { - partsArray = parts; - } - else - { - partsArray = Napi::Array::New(env, 0); - } - // Delegate byte-buffer construction to the native Blob polyfill so // we benefit from its existing BlobPart handling (ArrayBuffer, // typed array, string, Blob). auto blobCtor = env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).As(); - auto blobInstance = blobCtor.New({partsArray, blobOptions}); + auto blobInstance = blobCtor.New({parts, blobOptions}); m_blob = Napi::Persistent(blobInstance); } @@ -169,6 +165,29 @@ namespace Babylon::Polyfills::Internal auto blob = m_blob.Value(); return blob.Get("bytes").As().Call(blob, {}); } + + Napi::Value File::Slice(const Napi::CallbackInfo& info) + { + auto blob = m_blob.Value(); + const auto slice = blob.Get("slice").As(); + switch (info.Length()) + { + case 0: + return slice.Call(blob, {}); + case 1: + return slice.Call(blob, {info[0]}); + case 2: + return slice.Call(blob, {info[0], info[1]}); + default: + return slice.Call(blob, {info[0], info[1], info[2]}); + } + } + + Napi::Value File::Stream(const Napi::CallbackInfo&) + { + auto blob = m_blob.Value(); + return blob.Get("stream").As().Call(blob, {}); + } } namespace Babylon::Polyfills::File diff --git a/Polyfills/File/Source/File.h b/Polyfills/File/Source/File.h index 9d73edb2..49473666 100644 --- a/Polyfills/File/Source/File.h +++ b/Polyfills/File/Source/File.h @@ -22,6 +22,8 @@ namespace Babylon::Polyfills::Internal Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); Napi::ObjectReference m_blob; std::string m_name; diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 6b153c59..122cc1b2 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1698,8 +1698,24 @@ describe("Web Streams", function () { }); describe("Blob", function () { + this.timeout(10000); + let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; + async function readStream(stream: ReadableStream, mode?: "byob"): Promise { + const reader: any = stream.getReader(mode === undefined ? undefined : { mode }); + const bytes: number[] = []; + while (true) { + const result = mode === "byob" + ? await reader.read(new Uint8Array(64)) + : await reader.read(); + if (result.done) { + return bytes; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + } + before(function () { emptyBlobs = [new Blob([]), new Blob([])]; stringBlob = new Blob(["Hello"]); @@ -1742,6 +1758,120 @@ describe("Blob", function () { expect(modelGltfJson.type).to.equal("model/gltf+json"); }); + // Focused ports from WPT FileAPI/blob/Blob-constructor.any.js. + it("accepts iterable parts and preserves their order", async function () { + const parts = { + *[Symbol.iterator]() { + yield "foo"; + yield new Uint8Array([98, 97, 114]); + yield new Blob(["baz"]); + } + }; + const blob = new Blob(parts as any); + expect(blob.size).to.equal(9); + expect(await blob.text()).to.equal("foobarbaz"); + }); + + it("uses an Array's overridden iterator", async function () { + const parts = ["ignored"]; + parts[Symbol.iterator] = function* () { + yield "custom"; + }; + + expect(await new Blob(parts).text()).to.equal("custom"); + }); + + it("closes an iterator when BlobPart conversion throws", function () { + let closed = false; + const badPart = { + toString() { + throw new Error("part conversion failed"); + } + }; + const parts = (function* () { + try { + yield badPart; + } finally { + closed = true; + } + })(); + + // QuickJS currently wraps an exception rethrown through a native + // constructor as its generic JS error type, so assert the observable + // iterator-close behavior separately from the adapter's error text. + expect(() => new Blob(parts as any)).to.throw(); + expect(closed).to.equal(true); + }); + + it("observes BlobPart array mutations during iteration", async function () { + const parts: any[] = [ + { + toString() { + parts.pop(); + return "PASS"; + } + }, + { + toString() { + throw new Error("removed part was converted"); + } + } + ]; + + expect(await new Blob(parts).text()).to.equal("PASS"); + }); + + it("converts parts before reading options in WebIDL order", function () { + const accesses: string[] = []; + const part = { + toString() { + accesses.push("part"); + return "data"; + } + }; + new Blob([part], { + get type() { + accesses.push("type"); + return "TEXT/PLAIN"; + }, + get endings() { + accesses.push("endings"); + return "transparent" as EndingType; + } + }); + + expect(accesses).to.deep.equal(["part", "endings", "type"]); + }); + + it("validates the endings enum and options dictionary", function () { + expect(() => new Blob([], { endings: "NATIVE" as EndingType })).to.throw(); + expect(() => new Blob([], { endings: "invalid" as EndingType })).to.throw(); + for (const value of [123, true, "abc"]) { + expect(() => new Blob([], value as any)).to.throw(); + } + expect(() => new Blob([], null as any)).not.to.throw(); + expect(() => new Blob([], undefined)).not.to.throw(); + }); + + it("exposes browser-compatible class tags", function () { + expect(String(new Blob())).to.equal("[object Blob]"); + expect(String(new File([], "empty.txt"))).to.equal("[object File]"); + }); + + it("rejects primitive parts containers", function () { + for (const value of [null, true, 7, "not a sequence"]) { + // Some Node-API adapters currently wrap a Napi::TypeError thrown + // by a constructor as their generic JS error type. + expect(() => new Blob(value as any)).to.throw(); + } + }); + + it("normalizes valid MIME types and clears invalid types", function () { + expect(new Blob([], { type: "TEXT/PLAIN" }).type).to.equal("text/plain"); + expect(new Blob([], { type: "te\x09xt/plain" }).type).to.equal(""); + expect(new Blob([], { type: "text/\x7fplain" }).type).to.equal(""); + }); + // -------------------------------- Blob.text() -------------------------------- it("returns empty string for empty blobs", async function () { for (const blob of emptyBlobs) { @@ -1763,6 +1893,11 @@ describe("Blob", function () { expect(text).to.equal("你好, 世界"); }); + it("replaces invalid UTF-8 bytes", async function () { + const invalid = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]); + expect(await new Blob([invalid]).text()).to.equal("\ufffd".repeat(invalid.length)); + }); + it("preserves line endings like default transparent mode", async function () { const lineEndingsBlob = new Blob(["Hello\nWorld"]); const text = await lineEndingsBlob.text(); @@ -1809,6 +1944,82 @@ describe("Blob", function () { } }); + + // Focused ports from WPT FileAPI/blob/Blob-slice.any.js. + it("slices across part boundaries and applies clamp rounding", async function () { + const blob = new Blob(["foo", new Blob(["bar"]), "baz"]); + expect(await blob.slice(2, 7).text()).to.equal("obarb"); + expect(await new Blob(["abcd"]).slice(1.5).text()).to.equal("cd"); + expect(await new Blob(["abcd"]).slice(2.5).text()).to.equal("cd"); + expect(await blob.slice(-3, undefined, "TEXT/PLAIN").text()).to.equal("baz"); + expect(blob.slice(-3, undefined, "TEXT/PLAIN").type).to.equal("text/plain"); + }); + + // Focused ports from WPT FileAPI/blob/Blob-stream.any.js. + it("streams binary data through default and BYOB readers", async function () { + const input = [8, 241, 48, 123, 151]; + const blob = new Blob([new Uint8Array(input)]); + expect(await readStream(blob.stream())).to.deep.equal(input); + expect(await readStream(blob.stream(), "byob")).to.deep.equal(input); + expect(await readStream(new Blob().stream())).to.deep.equal([]); + }); + + it("keeps independent stream cursors after the Blob reference is dropped", async function () { + let blob: Blob | null = new Blob(["PASS"]); + const first = blob.stream(); + const second = blob.stream(); + blob = null; + expect(await readStream(first)).to.deep.equal([80, 65, 83, 83]); + expect(await readStream(second)).to.deep.equal([80, 65, 83, 83]); + }); + + // Adapted from WebKit's fast/files/blob-stream-chunks.html. + it("chunks a large Blob and supports cancellation without retaining work", async function () { + const blob = new Blob([new Uint8Array(5 * 1024 * 1024)]); + const reader = blob.stream().getReader(); + const first = await reader.read(); + expect(first.done).to.equal(false); + expect(first.value!.byteLength).to.be.at.most(64 * 1024); + await reader.cancel(); + await reader.closed; + }); + + // Adapted from WebKit's blob-stream crash regression and exercises + // teardown of the C++ pull-state closures under repeated construction. + it("constructs and cancels many empty streams without crashing", async function () { + for (let index = 0; index < 1000; ++index) { + await new Blob().stream().cancel(); + } + }); + + // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. + it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + const pattern = new Uint8Array(256 * 1024); + for (let index = 0; index < pattern.length; ++index) { + pattern[index] = index % 256; + } + const pair = new Blob([pattern, pattern]); + const nested = new Blob([pair, pair, pair, pair, pair, pair]); + let position = 0; + + await nested.stream().pipeTo(new WritableStream({ + write(chunk: Uint8Array) { + for (const value of chunk) { + const expected = position % pattern.length % 256; + if (value !== expected) { + throw new Error(`Blob stream byte ${position}: expected ${expected}, received ${value}`); + } + ++position; + } + } + })); + expect(position).to.equal(pattern.length * 12); + }); + + it("uses a File's Blob bytes when composing parts", async function () { + const file = new File(["a", "b"], "letters.txt"); + expect(await new Blob(["<", file, ">"]).text()).to.equal(""); + }); }); describe("napi class prototype isolation (#172)", function () { @@ -2162,6 +2373,22 @@ describe("File", function () { expect(text).to.equal("你好, 世界"); }); + // Adapted from WebKit's fast/files/blob-stream-crash-2.html. + it("streams and slices multiple File parts through the Blob API", async function () { + const file = new File(["a", new Blob(), "b", new Blob(), "c", new Blob(), "d"], "letters.txt"); + const reader = file.stream().getReader(); + const bytes: number[] = []; + while (true) { + const result = await reader.read(); + if (result.done) { + break; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + expect(bytes).to.deep.equal([97, 98, 99, 100]); + expect(await file.slice(1, 3).text()).to.equal("bc"); + }); + // -------------------------------- Blob inheritance -------------------------------- it("is an instance of Blob (prototype chain wired up)", function () { // BJS core (fileTools, Offline/database, abstractEngine, From aeffa22ca5ec36d8b4367a697fceaad4ffe4e17c Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:26:50 -0700 Subject: [PATCH 073/174] Keep Streams implementations internally consistent Replace a partial or null host Streams surface as a complete constructor suite so stream products retain compatible instanceof relationships. Preserve a complete suite on repeated initialization.\n\nHarden the native initialization test so N-API failures complete the test promise instead of hanging, and cover partial host replacement plus null handling and cross-constructor compatibility. --- Polyfills/Streams/Source/Streams.cpp | 8 ++---- Tests/UnitTests/Shared/Shared.cpp | 42 +++++++++++++++++++++------- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp index 4552ed07..e742344f 100644 --- a/Polyfills/Streams/Source/Streams.cpp +++ b/Polyfills/Streams/Source/Streams.cpp @@ -31,7 +31,8 @@ namespace Babylon::Polyfills::Streams bool needsPonyfill{}; for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) + const auto constructor = global.Get(name.data()); + if (constructor.IsUndefined() || constructor.IsNull()) { needsPonyfill = true; break; @@ -46,10 +47,7 @@ namespace Babylon::Polyfills::Streams const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) - { - global.Set(name.data(), exports.Get(name.data())); - } + global.Set(name.data(), exports.Get(name.data())); } } } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index b71218bd..f27cad71 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -168,28 +168,50 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } -TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; + + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; - runtime.Dispatch([&done](Napi::Env env) { + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); global.Set("ReadableStream", hostReadableStream); + global.Set("TransformStream", env.Null()); Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); - EXPECT_TRUE(global.Get("TransformStream").IsFunction()); - + const auto installedReadableStream = global.Get("ReadableStream"); const auto installedTransformStream = global.Get("TransformStream"); + EXPECT_FALSE(installedReadableStream.StrictEquals(hostReadableStream)); + if (!installedReadableStream.IsFunction() || !installedTransformStream.IsFunction()) + { + complete("Streams::Initialize did not install a complete constructor suite."); + return; + } + + const auto transform = installedTransformStream.As().New({}); + EXPECT_TRUE(transform.Get("readable").As().InstanceOf(installedReadableStream.As())); + Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(installedReadableStream)); EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Console, Log) From 1da1abbf3ab5725dd4d348c781ebcb47c2cf6feb Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:29:36 -0700 Subject: [PATCH 074/174] Write Blob BYOB reads into caller buffers Use ReadableByteStreamController.byobRequest views directly and respond with the produced byte count instead of allocating and enqueueing a 64 KiB intermediate chunk. Keep the existing bounded allocation path for default readers.\n\nAdd WPT-derived coverage for small offset BYOB views that cross immutable Blob segment boundaries. --- Polyfills/Blob/Source/Blob.cpp | 69 +++++++++++++++++++++----------- Tests/UnitTests/Scripts/tests.ts | 27 +++++++++++++ 2 files changed, 73 insertions(+), 23 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index bed99cb6..635bb7e1 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -310,33 +310,56 @@ namespace Babylon::Polyfills::Internal } constexpr size_t CHUNK_SIZE = 64 * 1024; - const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); - auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); - auto destination = static_cast(outputBuffer.Data()); - auto segmentIndex = state->SegmentIndex; - auto segmentOffset = state->SegmentOffset; - size_t remaining = outputLength; - - while (remaining > 0) + const auto copyInto = [&state](std::byte* destination, size_t outputLength) { + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + }; + + const auto byobRequestValue = controller.Get("byobRequest"); + if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) { - const auto& segment = state->BlobData->Segments[segmentIndex]; - const auto copyLength = std::min(segment.Length - segmentOffset, remaining); - std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); - destination += copyLength; - remaining -= copyLength; - segmentOffset += copyLength; - if (segmentOffset == segment.Length) + const auto byobRequest = byobRequestValue.As(); + const auto viewValue = byobRequest.Get("view"); + if (!viewValue.IsTypedArray()) { - ++segmentIndex; - segmentOffset = 0; + throw Napi::TypeError::New(callbackEnv, "Blob.stream() received an invalid BYOB request view."); } - } - auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); - controller.Get("enqueue").As().Call(controller, {output}); - state->Position += outputLength; - state->SegmentIndex = segmentIndex; - state->SegmentOffset = segmentOffset; + const auto view = viewValue.As(); + const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); + const auto outputBuffer = view.ArrayBuffer(); + auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); + copyInto(destination, outputLength); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); + } + else + { + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + copyInto(static_cast(outputBuffer.Data()), outputLength); + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + } if (state->Position == state->BlobData->Size) { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 122cc1b2..458bd4ea 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1964,6 +1964,33 @@ describe("Blob", function () { expect(await readStream(new Blob().stream())).to.deep.equal([]); }); + // Adapted from WPT streams/readable-byte-streams/general.any.js BYOB + // coverage. Small, offset views exercise the caller-owned output path. + it("fills bounded BYOB views across Blob segment boundaries", async function () { + const input = new Uint8Array(97); + for (let index = 0; index < input.length; ++index) { + input[index] = (index * 31) & 0xff; + } + + const blob = new Blob([input.subarray(0, 11), input.subarray(11, 53), input.subarray(53)]); + const reader = blob.stream().getReader({ mode: "byob" }); + const output: number[] = []; + const requestSizes = [1, 3, 7, 16]; + let requestIndex = 0; + while (true) { + const requestSize = requestSizes[requestIndex++ % requestSizes.length]; + const request = new Uint8Array(new ArrayBuffer(requestSize + 4), 2, requestSize); + const result = await reader.read(request); + if (result.done) { + break; + } + expect(result.value!.byteLength).to.be.at.most(requestSize); + output.push(...Array.from(result.value!)); + } + + expect(output).to.deep.equal(Array.from(input)); + }); + it("keeps independent stream cursors after the Blob reference is dropped", async function () { let blob: Blob | null = new Blob(["PASS"]); const first = blob.stream(); From 34a7ead5475b644d406dd64272440fedac6d2c4e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 02:14:50 -0700 Subject: [PATCH 075/174] Preserve Streams bundle bytes across source splits --- Polyfills/Streams/Source/StreamsScripts.h.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 9bf7f5bf..126a23f7 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -9,9 +9,10 @@ namespace Babylon::Polyfills::Internal::StreamsScripts (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@ -)JSRHSTREAM"; +@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; + // Keep the split transparent: inserting whitespace here can divide an + // identifier or string literal when the vendored bundle is regenerated. inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ return module.exports; })() From c3d924e71710e114ded152adb0396d8a0c784689 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 04:49:27 -0700 Subject: [PATCH 076/174] Avoid per-stream Blob callback wrappers --- Polyfills/Blob/Source/Blob.cpp | 151 +++++++++++++++++++-------------- Polyfills/Blob/Source/Blob.h | 2 + 2 files changed, 88 insertions(+), 65 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 635bb7e1..6568dca6 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -294,87 +294,108 @@ namespace Babylon::Polyfills::Internal throw Napi::TypeError::New(env, "Blob.stream() requires ReadableStream to be installed."); } - auto state = std::make_shared(); - state->BlobData = m_data; - auto source = Napi::Object::New(env); + auto stateOwner = Napi::External::New( + env, + new StreamState{m_data}, + [](Napi::Env, StreamState* state) { + delete state; + }); + auto state = stateOwner.Data(); + + // ReadableStream retains its underlying source as the receiver for the + // pull/cancel algorithms, so let that object own the callback state. + // The compile-time callback overload passes the state directly through + // napi_create_function. In contrast, a capturing Function::New allocates + // node-addon-api CallbackData and attaches it as a hidden property to + // every function. Besides two avoidable allocations per Blob stream, + // that path creates extra JSC Function structure transitions and exposed + // a system-WebKitGTK LeakSanitizer allocation during Worker teardown. + source.Set(Napi::Symbol::New(env, "Blob stream state"), stateOwner); source.Set("type", "bytes"); - source.Set("pull", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { - auto callbackEnv = callbackInfo.Env(); - auto controller = callbackInfo[0].As(); - if (!state->BlobData || state->Position >= state->BlobData->Size) - { - controller.Get("close").As().Call(controller, {}); - state->BlobData.reset(); - return callbackEnv.Undefined(); - } + source.Set("pull", Napi::Function::New<&Blob::PullStream>(env, "pull", state)); + source.Set("cancel", Napi::Function::New<&Blob::CancelStream>(env, "cancel", state)); - constexpr size_t CHUNK_SIZE = 64 * 1024; - const auto copyInto = [&state](std::byte* destination, size_t outputLength) { - auto segmentIndex = state->SegmentIndex; - auto segmentOffset = state->SegmentOffset; - size_t remaining = outputLength; + return readableStreamValue.As().New({source}); + } - while (remaining > 0) - { - const auto& segment = state->BlobData->Segments[segmentIndex]; - const auto copyLength = std::min(segment.Length - segmentOffset, remaining); - std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); - destination += copyLength; - remaining -= copyLength; - segmentOffset += copyLength; - if (segmentOffset == segment.Length) - { - ++segmentIndex; - segmentOffset = 0; - } - } + Napi::Value Blob::PullStream(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + auto state = static_cast(info.Data()); + auto controller = info[0].As(); + if (!state->BlobData || state->Position >= state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + return env.Undefined(); + } - state->Position += outputLength; - state->SegmentIndex = segmentIndex; - state->SegmentOffset = segmentOffset; - }; + constexpr size_t CHUNK_SIZE = 64 * 1024; + const auto copyInto = [state](std::byte* destination, size_t outputLength) { + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; - const auto byobRequestValue = controller.Get("byobRequest"); - if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) + while (remaining > 0) { - const auto byobRequest = byobRequestValue.As(); - const auto viewValue = byobRequest.Get("view"); - if (!viewValue.IsTypedArray()) + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) { - throw Napi::TypeError::New(callbackEnv, "Blob.stream() received an invalid BYOB request view."); + ++segmentIndex; + segmentOffset = 0; } - - const auto view = viewValue.As(); - const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); - const auto outputBuffer = view.ArrayBuffer(); - auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); - copyInto(destination, outputLength); - byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); - } - else - { - const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); - auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); - copyInto(static_cast(outputBuffer.Data()), outputLength); - auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); - controller.Get("enqueue").As().Call(controller, {output}); } - if (state->Position == state->BlobData->Size) + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + }; + + const auto byobRequestValue = controller.Get("byobRequest"); + if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) + { + const auto byobRequest = byobRequestValue.As(); + const auto viewValue = byobRequest.Get("view"); + if (!viewValue.IsTypedArray()) { - controller.Get("close").As().Call(controller, {}); - state->BlobData.reset(); + throw Napi::TypeError::New(env, "Blob.stream() received an invalid BYOB request view."); } - return callbackEnv.Undefined(); - })); - source.Set("cancel", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + const auto view = viewValue.As(); + const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); + const auto outputBuffer = view.ArrayBuffer(); + auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); + copyInto(destination, outputLength); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(env, outputLength)}); + } + else + { + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(env, outputLength); + copyInto(static_cast(outputBuffer.Data()), outputLength); + auto output = Napi::Uint8Array::New(env, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + } + + if (state->Position == state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); state->BlobData.reset(); - return callbackInfo.Env().Undefined(); - })); + } - return readableStreamValue.As().New({source}); + return env.Undefined(); + } + + Napi::Value Blob::CancelStream(const Napi::CallbackInfo& info) + { + static_cast(info.Data())->BlobData.reset(); + return info.Env().Undefined(); } bool Blob::AppendBlobPart(Storage& data, const Napi::Value& blobPart) diff --git a/Polyfills/Blob/Source/Blob.h b/Polyfills/Blob/Source/Blob.h index 1f061f97..ea39e9e0 100644 --- a/Polyfills/Blob/Source/Blob.h +++ b/Polyfills/Blob/Source/Blob.h @@ -33,6 +33,8 @@ namespace Babylon::Polyfills::Internal Napi::Value Bytes(const Napi::CallbackInfo& info); Napi::Value Slice(const Napi::CallbackInfo& info); Napi::Value Stream(const Napi::CallbackInfo& info); + static Napi::Value PullStream(const Napi::CallbackInfo& info); + static Napi::Value CancelStream(const Napi::CallbackInfo& info); struct Segment; struct Storage; From f23e672c9f9e7e074204b9ec29ae65b6b8a7ee1e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 05:06:43 -0700 Subject: [PATCH 077/174] Use JSC-compatible Blob stream state key --- Polyfills/Blob/Source/Blob.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 6568dca6..8493a57d 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -311,7 +311,11 @@ namespace Babylon::Polyfills::Internal // every function. Besides two avoidable allocations per Blob stream, // that path creates extra JSC Function structure transitions and exposed // a system-WebKitGTK LeakSanitizer allocation during Worker teardown. - source.Set(Napi::Symbol::New(env, "Blob stream state"), stateOwner); + // Keep the owner on the internal source object with a string key. + // The legacy JSC Node-API adapter stringifies property keys in + // napi_set_property, so passing a Symbol here throws even though + // modern engines accept it. + source.Set("__jsRuntimeHostBlobStreamState", stateOwner); source.Set("type", "bytes"); source.Set("pull", Napi::Function::New<&Blob::PullStream>(env, "pull", state)); source.Set("cancel", Napi::Function::New<&Blob::CancelStream>(env, "cancel", state)); From 760ae3cdcf182457bbb3e403355aaf5559a1008f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 05:39:02 -0700 Subject: [PATCH 078/174] Share Blob stream source callbacks --- Polyfills/Blob/Source/Blob.cpp | 234 ++++++++++++++++++--------------- Polyfills/Blob/Source/Blob.h | 4 +- 2 files changed, 127 insertions(+), 111 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 8493a57d..22dd3cc2 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -52,12 +52,119 @@ namespace Babylon::Polyfills::Internal } }; - struct Blob::StreamState + class Blob::StreamSource final : public Napi::ObjectWrap { - std::shared_ptr BlobData; - size_t Position{}; - size_t SegmentIndex{}; - size_t SegmentOffset{}; + public: + static Napi::Function Define(Napi::Env env) + { + return DefineClass( + env, + "BlobStreamSource", + { + InstanceMethod("pull", &StreamSource::Pull), + InstanceMethod("cancel", &StreamSource::Cancel), + }); + } + + explicit StreamSource(const Napi::CallbackInfo& info) + : Napi::ObjectWrap{info} + { + if (info.Length() != 1 || !info[0].IsObject()) + { + throw Napi::TypeError::New(info.Env(), "Blob stream source requires a Blob."); + } + + const auto blob = Napi::ObjectWrap::Unwrap(info[0].As()); + if (blob == nullptr) + { + throw Napi::TypeError::New(info.Env(), "Blob stream source requires a Blob."); + } + m_blobData = blob->m_data; + } + + private: + Napi::Value Pull(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + auto controller = info[0].As(); + if (!m_blobData || m_position >= m_blobData->Size) + { + controller.Get("close").As().Call(controller, {}); + m_blobData.reset(); + return env.Undefined(); + } + + constexpr size_t CHUNK_SIZE = 64 * 1024; + const auto copyInto = [this](std::byte* destination, size_t outputLength) { + auto segmentIndex = m_segmentIndex; + auto segmentOffset = m_segmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = m_blobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + m_position += outputLength; + m_segmentIndex = segmentIndex; + m_segmentOffset = segmentOffset; + }; + + const auto byobRequestValue = controller.Get("byobRequest"); + if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) + { + const auto byobRequest = byobRequestValue.As(); + const auto viewValue = byobRequest.Get("view"); + if (!viewValue.IsTypedArray()) + { + throw Napi::TypeError::New(env, "Blob.stream() received an invalid BYOB request view."); + } + + const auto view = viewValue.As(); + const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), m_blobData->Size - m_position}); + const auto outputBuffer = view.ArrayBuffer(); + auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); + copyInto(destination, outputLength); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(env, outputLength)}); + } + else + { + const auto outputLength = std::min(CHUNK_SIZE, m_blobData->Size - m_position); + auto outputBuffer = Napi::ArrayBuffer::New(env, outputLength); + copyInto(static_cast(outputBuffer.Data()), outputLength); + auto output = Napi::Uint8Array::New(env, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + } + + if (m_position == m_blobData->Size) + { + controller.Get("close").As().Call(controller, {}); + m_blobData.reset(); + } + + return env.Undefined(); + } + + Napi::Value Cancel(const Napi::CallbackInfo& info) + { + m_blobData.reset(); + return info.Env().Undefined(); + } + + std::shared_ptr m_blobData; + size_t m_position{}; + size_t m_segmentIndex{}; + size_t m_segmentOffset{}; }; void Blob::Initialize(Napi::Env env) @@ -82,6 +189,17 @@ namespace Babylon::Polyfills::Internal descriptor.Set("configurable", true); descriptor.Set("value", JS_BLOB_CONSTRUCTOR_NAME); env.Global().Get("Object").As().Get("defineProperty").As().Call(env.Global().Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); + + // Underlying stream sources are native ObjectWrap instances so + // pull/cancel live on one shared prototype. Creating two native + // functions for every Blob.stream() caused avoidable JSC Function + // structure transitions and exposed a WebKitGTK LeakSanitizer + // allocation during Worker teardown. + auto sourceDescriptor = Napi::Object::New(env); + sourceDescriptor.Set("value", StreamSource::Define(env)); + env.Global().Get("Object").As().Get("defineProperty").As().Call( + env.Global().Get("Object"), + {func, Napi::String::New(env, "__jsRuntimeHostBlobStreamSource"), sourceDescriptor}); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -294,114 +412,14 @@ namespace Babylon::Polyfills::Internal throw Napi::TypeError::New(env, "Blob.stream() requires ReadableStream to be installed."); } - auto source = Napi::Object::New(env); - auto stateOwner = Napi::External::New( - env, - new StreamState{m_data}, - [](Napi::Env, StreamState* state) { - delete state; - }); - auto state = stateOwner.Data(); - - // ReadableStream retains its underlying source as the receiver for the - // pull/cancel algorithms, so let that object own the callback state. - // The compile-time callback overload passes the state directly through - // napi_create_function. In contrast, a capturing Function::New allocates - // node-addon-api CallbackData and attaches it as a hidden property to - // every function. Besides two avoidable allocations per Blob stream, - // that path creates extra JSC Function structure transitions and exposed - // a system-WebKitGTK LeakSanitizer allocation during Worker teardown. - // Keep the owner on the internal source object with a string key. - // The legacy JSC Node-API adapter stringifies property keys in - // napi_set_property, so passing a Symbol here throws even though - // modern engines accept it. - source.Set("__jsRuntimeHostBlobStreamState", stateOwner); + const auto blobConstructor = env.Global().Get("Blob").As(); + const auto sourceConstructor = blobConstructor.Get("__jsRuntimeHostBlobStreamSource").As(); + auto source = sourceConstructor.New({info.This()}); source.Set("type", "bytes"); - source.Set("pull", Napi::Function::New<&Blob::PullStream>(env, "pull", state)); - source.Set("cancel", Napi::Function::New<&Blob::CancelStream>(env, "cancel", state)); return readableStreamValue.As().New({source}); } - Napi::Value Blob::PullStream(const Napi::CallbackInfo& info) - { - auto env = info.Env(); - auto state = static_cast(info.Data()); - auto controller = info[0].As(); - if (!state->BlobData || state->Position >= state->BlobData->Size) - { - controller.Get("close").As().Call(controller, {}); - state->BlobData.reset(); - return env.Undefined(); - } - - constexpr size_t CHUNK_SIZE = 64 * 1024; - const auto copyInto = [state](std::byte* destination, size_t outputLength) { - auto segmentIndex = state->SegmentIndex; - auto segmentOffset = state->SegmentOffset; - size_t remaining = outputLength; - - while (remaining > 0) - { - const auto& segment = state->BlobData->Segments[segmentIndex]; - const auto copyLength = std::min(segment.Length - segmentOffset, remaining); - std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); - destination += copyLength; - remaining -= copyLength; - segmentOffset += copyLength; - if (segmentOffset == segment.Length) - { - ++segmentIndex; - segmentOffset = 0; - } - } - - state->Position += outputLength; - state->SegmentIndex = segmentIndex; - state->SegmentOffset = segmentOffset; - }; - - const auto byobRequestValue = controller.Get("byobRequest"); - if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) - { - const auto byobRequest = byobRequestValue.As(); - const auto viewValue = byobRequest.Get("view"); - if (!viewValue.IsTypedArray()) - { - throw Napi::TypeError::New(env, "Blob.stream() received an invalid BYOB request view."); - } - - const auto view = viewValue.As(); - const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); - const auto outputBuffer = view.ArrayBuffer(); - auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); - copyInto(destination, outputLength); - byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(env, outputLength)}); - } - else - { - const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); - auto outputBuffer = Napi::ArrayBuffer::New(env, outputLength); - copyInto(static_cast(outputBuffer.Data()), outputLength); - auto output = Napi::Uint8Array::New(env, outputLength, outputBuffer, 0); - controller.Get("enqueue").As().Call(controller, {output}); - } - - if (state->Position == state->BlobData->Size) - { - controller.Get("close").As().Call(controller, {}); - state->BlobData.reset(); - } - - return env.Undefined(); - } - - Napi::Value Blob::CancelStream(const Napi::CallbackInfo& info) - { - static_cast(info.Data())->BlobData.reset(); - return info.Env().Undefined(); - } - bool Blob::AppendBlobPart(Storage& data, const Napi::Value& blobPart) { const std::byte* source{}; diff --git a/Polyfills/Blob/Source/Blob.h b/Polyfills/Blob/Source/Blob.h index ea39e9e0..3adcc41d 100644 --- a/Polyfills/Blob/Source/Blob.h +++ b/Polyfills/Blob/Source/Blob.h @@ -33,12 +33,10 @@ namespace Babylon::Polyfills::Internal Napi::Value Bytes(const Napi::CallbackInfo& info); Napi::Value Slice(const Napi::CallbackInfo& info); Napi::Value Stream(const Napi::CallbackInfo& info); - static Napi::Value PullStream(const Napi::CallbackInfo& info); - static Napi::Value CancelStream(const Napi::CallbackInfo& info); struct Segment; struct Storage; - struct StreamState; + class StreamSource; bool AppendBlobPart(Storage& data, const Napi::Value& blobPart); Napi::ArrayBuffer CreateArrayBuffer() const; From 2fa29efad092b10bccdc3ea0dc01c0386f28c94a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 21:55:02 -0700 Subject: [PATCH 079/174] Add optional WHATWG Streams polyfill Vendor the ES5 web-streams-polyfill 4.3.0 ponyfill and expose an idempotent Streams initializer that preserves constructors supplied by the selected JavaScript engine. Cover readable, writable, transform, BYOB, error, tee, subclassing, and host-constructor behavior with focused ports from WPT plus Firefox and Chromium regression tests. Validate the implementation on JavaScriptCore under ASan/UBSan and QuickJS Release. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 6 +- Polyfills/Streams/CMakeLists.txt | 30 ++++ .../Include/Babylon/Polyfills/Streams.h | 11 ++ Polyfills/Streams/README.md | 14 ++ Polyfills/Streams/Source/Streams.cpp | 55 ++++++ Polyfills/Streams/Source/StreamsScripts.h.in | 36 ++++ .../ThirdParty/web-streams-polyfill/LICENSE | 22 +++ .../web-streams-polyfill/ponyfill.es5.js | 8 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 156 ++++++++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 26 +++ 12 files changed, 365 insertions(+), 1 deletion(-) create mode 100644 Polyfills/Streams/CMakeLists.txt create mode 100644 Polyfills/Streams/Include/Babylon/Polyfills/Streams.h create mode 100644 Polyfills/Streams/README.md create mode 100644 Polyfills/Streams/Source/Streams.cpp create mode 100644 Polyfills/Streams/Source/StreamsScripts.h.in create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..6535a653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,6 +102,7 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) +option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index a44765fb..c952cf27 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -44,4 +44,8 @@ endif() if(JSRUNTIMEHOST_POLYFILL_TEXTENCODER) add_subdirectory(TextEncoder) -endif() \ No newline at end of file +endif() + +if(JSRUNTIMEHOST_POLYFILL_STREAMS) + add_subdirectory(Streams) +endif() diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt new file mode 100644 index 00000000..6c00ed81 --- /dev/null +++ b/Polyfills/Streams/CMakeLists.txt @@ -0,0 +1,30 @@ +set(WEB_STREAMS_POLYFILL_FILE + "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/web-streams-polyfill/ponyfill.es5.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${WEB_STREAMS_POLYFILL_FILE}") +file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +configure_file( + "Source/StreamsScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Streams.h" + "Source/Streams.cpp" + "Source/StreamsScripts.h.in" + "ThirdParty/web-streams-polyfill/LICENSE" + "ThirdParty/web-streams-polyfill/ponyfill.es5.js") + +add_library(Streams ${SOURCES}) +warnings_as_errors(Streams) + +target_include_directories(Streams + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Streams PUBLIC JsRuntime) + +set_property(TARGET Streams PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h new file mode 100644 index 00000000..01e5a15c --- /dev/null +++ b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + // Installs the WHATWG Streams constructors that are not already supplied + // by the JavaScript engine. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Streams/README.md b/Polyfills/Streams/README.md new file mode 100644 index 00000000..c84a38e3 --- /dev/null +++ b/Polyfills/Streams/README.md @@ -0,0 +1,14 @@ +# Web Streams + +Installs the standard `ReadableStream`, `WritableStream`, `TransformStream`, +reader, writer, controller, and queuing-strategy globals when the selected +JavaScript engine does not provide them. + +The implementation is the ES5 ponyfill bundle from +[`web-streams-polyfill` 4.3.0](https://github.com/MattiasBuelens/web-streams-polyfill/tree/add69059ed08eae6a18559aba49575a280d1529e), +which is based on the WHATWG reference implementation. The vendored project +tests this release against the Streams portion of WPT at revision +[`c05b4473`](https://github.com/web-platform-tests/wpt/tree/c05b447326585237713013c66341eab2cdf967b6/streams). + +`Initialize` preserves any Streams constructors already supplied by the host +engine and fills only missing globals. diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp new file mode 100644 index 00000000..4552ed07 --- /dev/null +++ b/Polyfills/Streams/Source/Streams.cpp @@ -0,0 +1,55 @@ +#include + +#include "StreamsScripts.h" + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + void BABYLON_API Initialize(Napi::Env env) + { + Napi::HandleScope scope{env}; + auto global = env.Global(); + + static constexpr std::array constructorNames{ + "ReadableStream", + "ReadableStreamDefaultController", + "ReadableByteStreamController", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultReader", + "ReadableStreamBYOBReader", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", + "ByteLengthQueuingStrategy", + "CountQueuingStrategy", + "TransformStream", + "TransformStreamDefaultController", + }; + + bool needsPonyfill{}; + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + needsPonyfill = true; + break; + } + } + + if (!needsPonyfill) + { + return; + } + + const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + global.Set(name.data(), exports.Get(name.data())); + } + } + } +} diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in new file mode 100644 index 00000000..9bf7f5bf --- /dev/null +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Internal::StreamsScripts +{ + inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( +(function() { + var exports = {}; + var module = { exports: exports }; +@WEB_STREAMS_POLYFILL_SOURCE_1@ +)JSRHSTREAM"; + + inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ + return module.exports; +})() +)JSRHSTREAM"; + + template + consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + { + std::array result{}; + for (std::size_t index{}; index < Part1Size - 1; ++index) + { + result[index] = part1[index]; + } + for (std::size_t index{}; index < Part2Size; ++index) + { + result[Part1Size - 1 + index] = part2[index]; + } + return result; + } + + inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); +} diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js new file mode 100644 index 00000000..18d63683 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js @@ -0,0 +1,8 @@ +/** + * @license + * web-streams-polyfill v4.3.0 + * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors. + * This code is released under the MIT license. + * SPDX-License-Identifier: MIT + */ +!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).WebStreamsPolyfill={})}(this,function(e){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?Symbol:function(e){return"Symbol(".concat(e,")")};function t(){}function o(e){return"object"==typeof e&&null!==e||"function"==typeof e}"function"==typeof SuppressedError&&SuppressedError;var n=t;function i(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch(e){}}var a=Promise,u=Promise.resolve.bind(a),l=Promise.prototype.then,s=Promise.reject.bind(a),c=u;function f(e){return new a(e)}function d(e){return f(function(r){return r(e)})}function p(e){return s(e)}function b(e,r,t){return l.call(e,r,t)}function h(e,r,t){b(b(e,r,t),void 0,n)}function _(e,r){h(e,r)}function m(e,r){h(e,void 0,r)}function v(e,r,t){return b(e,r,t)}function y(e){b(e,void 0,n)}var g=function(e){if("function"==typeof queueMicrotask)g=queueMicrotask;else{var r=d(void 0);g=function(e){return b(r,e)}}return g(e)};function S(e,r,t){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}function w(e,r,t){try{return d(S(e,r,t))}catch(e){return p(e)}}var R=function(){function e(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}return Object.defineProperty(e.prototype,"length",{get:function(){return this._size},enumerable:!1,configurable:!0}),e.prototype.push=function(e){var r=this._back,t=r;16383===r._elements.length&&(t={_elements:[],_next:void 0}),r._elements.push(e),t!==r&&(this._back=t,r._next=t),++this._size},e.prototype.shift=function(){var e=this._front,r=e,t=this._cursor,o=t+1,n=e._elements,i=n[t];return 16384===o&&(r=e._next,o=0),--this._size,this._cursor=o,e!==r&&(this._front=r),n[t]=void 0,i},e.prototype.forEach=function(e){for(var r=this._cursor,t=this._front,o=t._elements;!(r===o.length&&void 0===t._next||r===o.length&&(r=0,0===(o=(t=t._next)._elements).length));)e(o[r]),++r},e.prototype.peek=function(){var e=this._front,r=this._cursor;return e._elements[r]},e}(),T=r("[[AbortSteps]]"),P=r("[[ErrorSteps]]"),C=r("[[CancelSteps]]"),q=r("[[PullSteps]]"),E=r("[[CanPullSyncSteps]]"),W=r("[[ReleaseSteps]]");function O(e,r){e._ownerReadableStream=r,r._reader=e,"readable"===r._state?A(e):"closed"===r._state?function(e){A(e),F(e)}(e):z(e,r._storedError)}function j(e,r){return eo(e._ownerReadableStream,r)}function B(e){var r=e._ownerReadableStream;"readable"===r._state?D(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,r){z(e,r)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[W](),r._reader=void 0,e._ownerReadableStream=void 0}function k(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function A(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t})}function z(e,r){A(e),D(e,r)}function D(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function F(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var L=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},I=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function M(e,r){if(void 0!==e&&("object"!=typeof(t=e)&&"function"!=typeof t))throw new TypeError("".concat(r," is not an object."));var t}function x(e,r){if("function"!=typeof e)throw new TypeError("".concat(r," is not a function."))}function Y(e,r){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError("".concat(r," is not an object."))}function Q(e,r,t){if(void 0===e)throw new TypeError("Parameter ".concat(r," is required in '").concat(t,"'."))}function N(e,r,t){if(void 0===e)throw new TypeError("".concat(r," is required in '").concat(t,"'."))}function H(e){return Number(e)}function V(e){return 0===e?0:e}function U(e,r){var t=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=V(o),!L(o))throw new TypeError("".concat(r," is not a finite number"));if((o=function(e){return V(I(e))}(o))<0||o>t)throw new TypeError("".concat(r," is outside the accepted range of ").concat(0," to ").concat(t,", inclusive"));return L(o)&&0!==o?o:0}function G(e,r){if(!Zt(e))throw new TypeError("".concat(r," is not a ReadableStream."))}function X(e){return new ee(e)}function J(e,r){e._reader._readRequests.push(r)}function K(e,r,t){var o=e._reader._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}function Z(e){return e._reader._readRequests.length}function $(e){var r=e._reader;return void 0!==r&&!!ae(r)}var ee=function(){function ReadableStreamDefaultReader(e){if(Q(e,1,"ReadableStreamDefaultReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");O(this,e),this._readRequests=new R}return Object.defineProperty(ReadableStreamDefaultReader.prototype,"closed",{get:function(){return ae(this)?this._closedPromise:p(ce("closed"))},enumerable:!1,configurable:!0}),ReadableStreamDefaultReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),ae(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(ce("cancel"))},ReadableStreamDefaultReader.prototype.read=function(){if(!ae(this))return p(ce("read"));if(void 0===this._ownerReadableStream)return p(k("read from"));var e=le(this)?new ie:new ne;return ue(this,e),e._promise},ReadableStreamDefaultReader.prototype.releaseLock=function(){if(!ae(this))throw ce("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");se(e,r)}(this)},ReadableStreamDefaultReader}();Object.defineProperties(ee.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(ee.prototype.cancel,"cancel"),i(ee.prototype.read,"read"),i(ee.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ee.prototype,r.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var re,te,oe,ne=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(){this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),ie=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(){this._promise=c({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function ae(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ee)}function ue(e,r){var t=e._ownerReadableStream;t._disturbed=!0,"closed"===t._state?r._closeSteps():"errored"===t._state?r._errorSteps(t._storedError):t._readableStreamController[q](r)}function le(e){var r=e._ownerReadableStream;return"closed"===r._state||("errored"===r._state||r._readableStreamController[E]())}function se(e,r){var t=e._readRequests;e._readRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function ce(e){return new TypeError("ReadableStreamDefaultReader.prototype.".concat(e," can only be used on a ReadableStreamDefaultReader"))}function fe(e){return e.slice()}function de(e,r,t,o,n){new Uint8Array(e).set(new Uint8Array(t,o,n),r)}var pe=function(e){return(pe="function"==typeof e.transfer?function(e){return e.transfer()}:"function"==typeof structuredClone?function(e){return structuredClone(e,{transfer:[e]})}:function(e){return e})(e)},be=function(e){return(be="boolean"==typeof e.detached?function(e){return e.detached}:function(e){return 0===e.byteLength})(e)};function he(e,r,t){if(e.slice)return e.slice(r,t);var o=t-r,n=new ArrayBuffer(o);return de(n,0,e,r,o),n}function _e(e,r){var t=e[r];if(null!=t){if("function"!=typeof t)throw new TypeError("".concat(String(r)," is not a function"));return t}}function me(e){try{var r=e.done,t=e.value;return b(c(t),function(e){return{done:r,value:e}})}catch(e){return p(e)}}var ve,ye=null!==(oe=null!==(re=r.asyncIterator)&&void 0!==re?re:null===(te=r.for)||void 0===te?void 0:te.call(r,"Symbol.asyncIterator"))&&void 0!==oe?oe:"@@asyncIterator";function ge(e,t,n){if(void 0===t&&(t="sync"),void 0===n)if("async"===t){if(void 0===(n=_e(e,ye)))return function(e){var r={next:function(){var r;try{r=Se(e)}catch(e){return p(e)}return me(r)},return:function(r){var t;try{var n=_e(e.iterator,"return");if(void 0===n)return d({done:!0,value:r});t=S(n,e.iterator,[r])}catch(e){return p(e)}return o(t)?me(t):p(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(ge(e,"sync",_e(e,r.iterator)))}else n=_e(e,r.iterator);if(void 0===n)throw new TypeError("The object is not iterable");var i=S(n,e,[]);if(!o(i))throw new TypeError("The iterator method must return an object");return{iterator:i,nextMethod:i.next,done:!1}}function Se(e){var r=S(e.nextMethod,e.iterator,[]);if(!o(r))throw new TypeError("The iterator.next() method must return an object");return r}var we=function(){function e(e,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=r}return e.prototype.next=function(){var e=this,r=function(){return e._nextSteps()};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,r,r):r(),this._ongoingPromise},e.prototype.return=function(e){var r=this,t=function(){return r._returnSteps(e)};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,t,t):t(),this._ongoingPromise},e.prototype._nextSteps=function(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});var e=this._reader,r=new Re(this);return ue(e,r),r._promise},e.prototype._returnSteps=function(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;var r=this._reader;if(!this._preventCancel){var t=j(r,e);return B(r),v(t,function(){return{value:e,done:!0}})}return B(r),d({value:e,done:!0})},e}(),Re=function(){function e(e){var r=this;this._iterator=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){var r=this;this._iterator._ongoingPromise=void 0,g(function(){return r._resolvePromise({value:e,done:!1})})},e.prototype._closeSteps=function(){var e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){var r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,B(r._reader),this._rejectPromise(e)},e}(),Te=((ve={next:function(){return Pe(this)?this._asyncIteratorImpl.next():p(Ce("next"))},return:function(e){return Pe(this)?this._asyncIteratorImpl.return(e):p(Ce("return"))}})[ye]=function(){return this},ve);function Pe(e){if(!o(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof we}catch(e){return!1}}function Ce(e){return new TypeError("ReadableStreamAsyncIterator.".concat(e," can only be used on a ReadableSteamAsyncIterator"))}Object.defineProperty(Te,ye,{enumerable:!1});var qe=Number.isNaN||function(e){return e!=e};function Ee(e){var r=he(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}function We(e){var r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}function Oe(e,r,t){if("number"!=typeof(o=t)||qe(o)||o<0||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:r,size:t}),e._queueTotalSize+=t}function je(e){e._queue=new R,e._queueTotalSize=0}function Be(e){return e===DataView}function ke(e){return Be(e)?1:e.BYTES_PER_ELEMENT}var Ae=function(){function ReadableStreamBYOBRequest(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamBYOBRequest.prototype,"view",{get:function(){if(!Fe(this))throw sr("view");return this._view},enumerable:!1,configurable:!0}),ReadableStreamBYOBRequest.prototype.respond=function(e){if(!Fe(this))throw sr("respond");if(Q(e,1,"respond"),e=U(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");ar(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest.prototype.respondWithNewView=function(e){if(!Fe(this))throw sr("respondWithNewView");if(Q(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");ur(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest}();Object.defineProperties(Ae.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),i(Ae.prototype.respond,"respond"),i(Ae.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Ae.prototype,r.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var ze=function(){function ReadableByteStreamController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableByteStreamController.prototype,"byobRequest",{get:function(){if(!De(this))throw cr("byobRequest");return nr(this)},enumerable:!1,configurable:!0}),Object.defineProperty(ReadableByteStreamController.prototype,"desiredSize",{get:function(){if(!De(this))throw cr("desiredSize");return ir(this)},enumerable:!1,configurable:!0}),ReadableByteStreamController.prototype.close=function(){if(!De(this))throw cr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");var e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError("The stream (in ".concat(e," state) is not in the readable state and cannot be closed"));er(this)},ReadableByteStreamController.prototype.enqueue=function(e){if(!De(this))throw cr("enqueue");if(Q(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");var r=this._controlledReadableByteStream._state;if("readable"!==r)throw new TypeError("The stream (in ".concat(r," state) is not in the readable state and cannot be enqueued to"));rr(this,e)},ReadableByteStreamController.prototype.error=function(e){if(void 0===e&&(e=void 0),!De(this))throw cr("error");tr(this,e)},ReadableByteStreamController.prototype[C]=function(e){Ie(this),je(this);var r=this._cancelAlgorithm(e);return $e(this),r},ReadableByteStreamController.prototype[q]=function(e){var r=this._controlledReadableByteStream;if(this._queueTotalSize>0)or(this,e);else{var t=this._autoAllocateChunkSize;if(void 0!==t){var o=void 0;try{o=new ArrayBuffer(t)}catch(r){return void e._errorSteps(r)}var n={buffer:o,bufferByteLength:t,byteOffset:0,byteLength:t,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(n)}J(r,e),Le(this)}},ReadableByteStreamController.prototype[E]=function(){return this._queueTotalSize>0},ReadableByteStreamController.prototype[W]=function(){if(this._pendingPullIntos.length>0){var e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new R,this._pendingPullIntos.push(e)}},ReadableByteStreamController}();function De(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ze)}function Fe(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof Ae)}function Le(e){var r=function(e){var r=e._controlledReadableByteStream;if("readable"!==r._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if($(r)&&Z(r)>0)return!0;if(hr(r)&&br(r)>0)return!0;var t=ir(e);if(t>0)return!0;return!1}(e);r&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Le(e)),null},function(r){return tr(e,r),null})))}function Ie(e){Xe(e),e._pendingPullIntos=new R}function Me(e,r){var t=!1;"closed"===e._state&&(t=!0);var o=Ye(r);"default"===r.readerType?K(e,o,t):function(e,r,t){var o=e._reader,n=o._readIntoRequests.shift();t?n._closeSteps(r):n._chunkSteps(r)}(e,o,t)}function xe(e,r){for(var t=0;t0&&Ne(e,r.buffer,r.byteOffset,r.bytesFilled),Ze(e)}function Ve(e,r){var t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),o=r.bytesFilled+t,n=t,i=!1,a=o-o%r.elementSize;a>=r.minimumFill&&(n=a-r.bytesFilled,i=!0);for(var u=e._queue;n>0;){var l=u.peek(),s=Math.min(n,l.byteLength),c=r.byteOffset+r.bytesFilled;de(r.buffer,c,l.buffer,l.byteOffset,s),l.byteLength===s?u.shift():(l.byteOffset+=s,l.byteLength-=s),e._queueTotalSize-=s,Ue(e,s,r),n-=s}return i}function Ue(e,r,t){t.bytesFilled+=r}function Ge(e){0===e._queueTotalSize&&e._closeRequested?($e(e),ro(e._controlledReadableByteStream)):Le(e)}function Xe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Je(e){for(var r=[];e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){var t=e._pendingPullIntos.peek();Ve(e,t)&&(Ze(e),r.push(t))}return r}function Ke(e,r){var t=e._pendingPullIntos.peek();Xe(e),"closed"===e._controlledReadableByteStream._state?function(e,r){"none"===r.readerType&&Ze(e);var t=e._controlledReadableByteStream;if(hr(t)){for(var o=[];o.length0){var n=t.byteOffset+t.bytesFilled;Ne(e,t.buffer,n-o,o)}t.bytesFilled-=o;var i=Je(e);Me(e._controlledReadableByteStream,t),xe(e._controlledReadableByteStream,i)}}else{He(e,t);var a=Je(e);xe(e._controlledReadableByteStream,a)}}(e,r,t),Le(e)}function Ze(e){return e._pendingPullIntos.shift()}function $e(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function er(e){var r=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===r._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){var t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){var o=new TypeError("Insufficient bytes to fill elements in the given buffer");throw tr(e,o),o}}$e(e),ro(r)}}function rr(e,r){var t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state){var o=r.buffer,n=r.byteOffset,i=r.byteLength;if(be(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");var a=pe(o);if(e._pendingPullIntos.length>0){var u=e._pendingPullIntos.peek();if(be(u.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Xe(e),u.buffer=pe(u.buffer),"none"===u.readerType&&He(e,u)}if($(t))if(function(e){for(var r=e._controlledReadableByteStream._reader;r._readRequests.length>0;){if(0===e._queueTotalSize)return;or(e,r._readRequests.shift())}}(e),0===Z(t))Qe(e,a,n,i);else e._pendingPullIntos.length>0&&Ze(e),K(t,new Uint8Array(a,n,i),!1);else if(hr(t)){Qe(e,a,n,i),xe(t,Je(e))}else Qe(e,a,n,i);Le(e)}}function tr(e,r){var t=e._controlledReadableByteStream;"readable"===t._state&&(Ie(e),je(e),$e(e),to(t,r))}function or(e,r){var t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ge(e);var o=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(o)}function nr(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){var r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),o=Object.create(Ae.prototype);!function(e,r,t){e._associatedReadableByteStreamController=r,e._view=t}(o,e,t),e._byobRequest=o}return e._byobRequest}function ir(e){var r=e._controlledReadableByteStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function ar(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===r)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=pe(t.buffer),Ke(e,r)}function ur(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===r.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");var o=r.byteLength;t.buffer=pe(r.buffer),Ke(e,o)}function lr(e,r,t,o,n,i,a){r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,je(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,r._autoAllocateChunkSize=a,r._pendingPullIntos=new R,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,Le(r),null},function(e){return tr(r,e),null})}function sr(e){return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(e," can only be used on a ReadableStreamBYOBRequest"))}function cr(e){return new TypeError("ReadableByteStreamController.prototype.".concat(e," can only be used on a ReadableByteStreamController"))}function fr(e,r){if("byob"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamReaderMode"));return e}function dr(e){return new _r(e)}function pr(e,r){e._reader._readIntoRequests.push(r)}function br(e){return e._reader._readIntoRequests.length}function hr(e){var r=e._reader;return void 0!==r&&!!yr(r)}Object.defineProperties(ze.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),i(ze.prototype.close,"close"),i(ze.prototype.enqueue,"enqueue"),i(ze.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ze.prototype,r.toStringTag,{value:"ReadableByteStreamController",configurable:!0});var _r=function(){function ReadableStreamBYOBReader(e){if(Q(e,1,"ReadableStreamBYOBReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!De(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");O(this,e),this._readIntoRequests=new R}return Object.defineProperty(ReadableStreamBYOBReader.prototype,"closed",{get:function(){return yr(this)?this._closedPromise:p(wr("closed"))},enumerable:!1,configurable:!0}),ReadableStreamBYOBReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),yr(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(wr("cancel"))},ReadableStreamBYOBReader.prototype.read=function(e,r){if(void 0===r&&(r={}),!yr(this))return p(wr("read"));if(!ArrayBuffer.isView(e))return p(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return p(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return p(new TypeError("view's buffer must have non-zero byteLength"));if(be(e.buffer))return p(new TypeError("view's buffer has been detached"));var t;try{t=function(e,r){var t;return M(e,r),{min:U(null!==(t=null==e?void 0:e.min)&&void 0!==t?t:1,"".concat(r," has member 'min' that"))}}(r,"options")}catch(e){return p(e)}var o=t.min;if(0===o)return p(new TypeError("options.min must be greater than 0"));if(function(e){return Be(e.constructor)}(e)){if(o>e.byteLength)return p(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return p(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return p(k("read from"));var n=function(e,r,t){var o=e._ownerReadableStream;return"errored"===o._state||function(e,r,t){var o=e._controlledReadableByteStream,n=ke(r.constructor);r.byteLength;var i=t*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,r,t)}(this,e,o)?new vr:new mr;return gr(this,e,o,n),n._promise},ReadableStreamBYOBReader.prototype.releaseLock=function(){if(!yr(this))throw wr("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");Sr(e,r)}(this)},ReadableStreamBYOBReader}();Object.defineProperties(_r.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(_r.prototype.cancel,"cancel"),i(_r.prototype.read,"read"),i(_r.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(_r.prototype,r.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var mr=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(e){this._resolvePromise({value:e,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),vr=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(e){this._promise=c({value:e,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function yr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof _r)}function gr(e,r,t,o){var n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,r,t,o){var n,i=e._controlledReadableByteStream,a=r.constructor,u=ke(a),l=r.byteOffset,s=r.byteLength,c=t*u;try{n=pe(r.buffer)}catch(p){return void o._errorSteps(p)}var f={buffer:n,bufferByteLength:n.byteLength,byteOffset:l,byteLength:s,bytesFilled:0,minimumFill:c,elementSize:u,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(f),void pr(i,o);if("closed"!==i._state){if(e._queueTotalSize>0){if(Ve(e,f)){var d=Ye(f);return Ge(e),void o._chunkSteps(d)}if(e._closeRequested){var p=new TypeError("Insufficient bytes to fill elements in the given buffer");return tr(e,p),void o._errorSteps(p)}}e._pendingPullIntos.push(f),pr(i,o),Le(e)}else{var b=new a(f.buffer,f.byteOffset,0);o._closeSteps(b)}}(n._readableStreamController,r,t,o)}function Sr(e,r){var t=e._readIntoRequests;e._readIntoRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function wr(e){return new TypeError("ReadableStreamBYOBReader.prototype.".concat(e," can only be used on a ReadableStreamBYOBReader"))}function Rr(e,r){var t=e.highWaterMark;if(void 0===t)return r;if(qe(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}function Tr(e){var r=e.size;return r||function(){return 1}}function Pr(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===t?void 0:H(t),size:void 0===o?void 0:Cr(o,"".concat(r," has member 'size' that"))}}function Cr(e,r){return x(e,r),function(r){return H(e(r))}}function qr(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Er(e,r,t){return x(e,t),function(){return w(e,r,[])}}function Wr(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Or(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function jr(e,r){if(!zr(e))throw new TypeError("".concat(r," is not a WritableStream."))}var Br=function(){function WritableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,i=null==e?void 0:e.type,a=null==e?void 0:e.write;return{abort:void 0===t?void 0:qr(t,e,"".concat(r," has member 'abort' that")),close:void 0===o?void 0:Er(o,e,"".concat(r," has member 'close' that")),start:void 0===n?void 0:Wr(n,e,"".concat(r," has member 'start' that")),write:void 0===a?void 0:Or(a,e,"".concat(r," has member 'write' that")),type:i}}(e,"First parameter");if(Ar(this),void 0!==o.type)throw new RangeError("Invalid type is specified");var n=Tr(t);!function(e,r,t,o){var n,i,a,u,l=Object.create($r.prototype);n=void 0!==r.start?function(){return r.start(l)}:function(){};i=void 0!==r.write?function(e){return r.write(e,l)}:function(){return d(void 0)};a=void 0!==r.close?function(){return r.close()}:function(){return d(void 0)};u=void 0!==r.abort?function(e){return r.abort(e)}:function(){return d(void 0)};rt(e,l,n,i,a,u,t,o)}(this,o,Rr(t,1),n)}return Object.defineProperty(WritableStream.prototype,"locked",{get:function(){if(!zr(this))throw lt("locked");return Dr(this)},enumerable:!1,configurable:!0}),WritableStream.prototype.abort=function(e){return void 0===e&&(e=void 0),zr(this)?Dr(this)?p(new TypeError("Cannot abort a stream that already has a writer")):Fr(this,e):p(lt("abort"))},WritableStream.prototype.close=function(){return zr(this)?Dr(this)?p(new TypeError("Cannot close a stream that already has a writer")):Yr(this)?p(new TypeError("Cannot close an already-closing stream")):Lr(this):p(lt("close"))},WritableStream.prototype.getWriter=function(){if(!zr(this))throw lt("getWriter");return kr(this)},WritableStream}();function kr(e){return new Hr(e)}function Ar(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new R,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function zr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof Br)}function Dr(e){return void 0!==e._writer}function Fr(e,r){var t;if("closed"===e._state||"errored"===e._state)return d(void 0);e._writableStreamController._abortReason=r,null===(t=e._writableStreamController._abortController)||void 0===t||t.abort(r);var o=e._state;if("closed"===o||"errored"===o)return d(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;var n=!1;"erroring"===o&&(n=!0,r=void 0);var i=f(function(t,o){e._pendingAbortRequest={_promise:void 0,_resolve:t,_reject:o,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=i,n||Mr(e,r),i}function Lr(e){var r=e._state;if("closed"===r||"errored"===r)return p(new TypeError("The stream (in ".concat(r," state) is not in the writable state and cannot be closed")));var t,o=f(function(r,t){var o={_resolve:r,_reject:t};e._closeRequest=o}),n=e._writer;return void 0!==n&&e._backpressure&&"writable"===r&>(n),Oe(t=e._writableStreamController,Zr,0),nt(t),o}function Ir(e,r){"writable"!==e._state?xr(e):Mr(e,r)}function Mr(e,r){var t=e._writableStreamController;e._state="erroring",e._storedError=r;var o=e._writer;void 0!==o&&Xr(o,r),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&t._started&&xr(e)}function xr(e){e._state="errored",e._writableStreamController[P]();var r=e._storedError;if(e._writeRequests.forEach(function(e){e._reject(r)}),e._writeRequests=new R,void 0!==e._pendingAbortRequest){var t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring)return t._reject(r),void Qr(e);h(e._writableStreamController[T](t._reason),function(){return t._resolve(),Qr(e),null},function(r){return t._reject(r),Qr(e),null})}else Qr(e)}function Yr(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function Qr(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);var r=e._writer;void 0!==r&&bt(r,e._storedError)}function Nr(e,r){var t=e._writer;void 0!==t&&r!==e._backpressure&&(r?function(e){_t(e)}(t):gt(t)),e._backpressure=r}Object.defineProperties(Br.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),i(Br.prototype.abort,"abort"),i(Br.prototype.close,"close"),i(Br.prototype.getWriter,"getWriter"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Br.prototype,r.toStringTag,{value:"WritableStream",configurable:!0});var Hr=function(){function WritableStreamDefaultWriter(e){if(Q(e,1,"WritableStreamDefaultWriter"),jr(e,"First parameter"),Dr(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;var r,t=e._state;if("writable"===t)!Yr(e)&&e._backpressure?_t(this):vt(this),dt(this);else if("erroring"===t)mt(this,e._storedError),dt(this);else if("closed"===t)vt(this),dt(r=this),ht(r);else{var o=e._storedError;mt(this,o),pt(this,o)}}return Object.defineProperty(WritableStreamDefaultWriter.prototype,"closed",{get:function(){return Vr(this)?this._closedPromise:p(ct("closed"))},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"desiredSize",{get:function(){if(!Vr(this))throw ct("desiredSize");if(void 0===this._ownerWritableStream)throw ft("desiredSize");return function(e){var r=e._ownerWritableStream,t=r._state;if("errored"===t||"erroring"===t)return null;if("closed"===t)return 0;return ot(r._writableStreamController)}(this)},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"ready",{get:function(){return Vr(this)?this._readyPromise:p(ct("ready"))},enumerable:!1,configurable:!0}),WritableStreamDefaultWriter.prototype.abort=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("abort")):function(e,r){return Fr(e._ownerWritableStream,r)}(this,e):p(ct("abort"))},WritableStreamDefaultWriter.prototype.close=function(){if(!Vr(this))return p(ct("close"));var e=this._ownerWritableStream;return void 0===e?p(ft("close")):Yr(e)?p(new TypeError("Cannot close an already-closing stream")):Ur(this)},WritableStreamDefaultWriter.prototype.releaseLock=function(){if(!Vr(this))throw ct("releaseLock");void 0!==this._ownerWritableStream&&Jr(this)},WritableStreamDefaultWriter.prototype.write=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("write to")):Kr(this,e):p(ct("write"))},WritableStreamDefaultWriter}();function Vr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof Hr)}function Ur(e){return Lr(e._ownerWritableStream)}function Gr(e,r){"pending"===e._closedPromiseState?bt(e,r):function(e,r){pt(e,r)}(e,r)}function Xr(e,r){"pending"===e._readyPromiseState?yt(e,r):function(e,r){mt(e,r)}(e,r)}function Jr(e){var r=e._ownerWritableStream,t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Xr(e,t),Gr(e,t),r._writer=void 0,e._ownerWritableStream=void 0}function Kr(e,r){var t=e._ownerWritableStream,o=t._writableStreamController,n=function(e,r){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(r)}catch(r){return it(e,r),1}}(o,r);if(t!==e._ownerWritableStream)return p(ft("write to"));var i=t._state;if("errored"===i)return p(t._storedError);if(Yr(t)||"closed"===i)return p(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===i)return p(t._storedError);var a=function(e){return f(function(r,t){var o={_resolve:r,_reject:t};e._writeRequests.push(o)})}(t);return function(e,r,t){try{Oe(e,r,t)}catch(r){return void it(e,r)}var o=e._controlledWritableStream;if(!Yr(o)&&"writable"===o._state){Nr(o,at(e))}nt(e)}(o,r,n),a}Object.defineProperties(Hr.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),i(Hr.prototype.abort,"abort"),i(Hr.prototype.close,"close"),i(Hr.prototype.releaseLock,"releaseLock"),i(Hr.prototype.write,"write"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Hr.prototype,r.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});var Zr={},$r=function(){function WritableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(WritableStreamDefaultController.prototype,"abortReason",{get:function(){if(!et(this))throw st("abortReason");return this._abortReason},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultController.prototype,"signal",{get:function(){if(!et(this))throw st("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal},enumerable:!1,configurable:!0}),WritableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!et(this))throw st("error");"writable"===this._controlledWritableStream._state&&ut(this,e)},WritableStreamDefaultController.prototype[T]=function(e){var r=this._abortAlgorithm(e);return tt(this),r},WritableStreamDefaultController.prototype[P]=function(){je(this)},WritableStreamDefaultController}();function et(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof $r)}function rt(e,r,t,o,n,i,a,u){r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._abortReason=void 0,r._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),r._started=!1,r._strategySizeAlgorithm=u,r._strategyHWM=a,r._writeAlgorithm=o,r._closeAlgorithm=n,r._abortAlgorithm=i;var l=at(r);Nr(e,l),h(d(t()),function(){return r._started=!0,nt(r),null},function(t){return r._started=!0,Ir(e,t),null})}function tt(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ot(e){return e._strategyHWM-e._queueTotalSize}function nt(e){var r=e._controlledWritableStream;if(e._started&&void 0===r._inFlightWriteRequest)if("erroring"!==r._state){if(0!==e._queue.length){var t=e._queue.peek().value;t===Zr?function(e){var r=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(r),We(e);var t=e._closeAlgorithm();tt(e),h(t,function(){return function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";var r=e._writer;void 0!==r&&ht(r)}(r),null},function(e){return function(e,r){e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Ir(e,r)}(r,e),null})}(e):function(e,r){var t=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(t);var o=e._writeAlgorithm(r);h(o,function(){!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(t);var r=t._state;if(We(e),!Yr(t)&&"writable"===r){var o=at(e);Nr(t,o)}return nt(e),null},function(r){return"writable"===t._state&&tt(e),function(e,r){e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,Ir(e,r)}(t,r),null})}(e,t)}}else xr(r)}function it(e,r){"writable"===e._controlledWritableStream._state&&ut(e,r)}function at(e){return ot(e)<=0}function ut(e,r){var t=e._controlledWritableStream;tt(e),Mr(t,r)}function lt(e){return new TypeError("WritableStream.prototype.".concat(e," can only be used on a WritableStream"))}function st(e){return new TypeError("WritableStreamDefaultController.prototype.".concat(e," can only be used on a WritableStreamDefaultController"))}function ct(e){return new TypeError("WritableStreamDefaultWriter.prototype.".concat(e," can only be used on a WritableStreamDefaultWriter"))}function ft(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function dt(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}function pt(e,r){dt(e),bt(e,r)}function bt(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ht(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function _t(e){e._readyPromise=f(function(r,t){e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}function mt(e,r){_t(e),yt(e,r)}function vt(e){_t(e),gt(e)}function yt(e,r){void 0!==e._readyPromise_reject&&(y(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function gt(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties($r.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty($r.prototype,r.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});var St="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;var wt,Rt=(function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(wt=null==St?void 0:St.DOMException)?wt:void 0)||function(){var e=function(e,r){this.message=e||"",this.name=r||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return i(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function Tt(e,r,t,o,n,i){var a=X(e),u=kr(r);e._disturbed=!0;var l=new Pt(u),s=new qt(l);return f(function(c,m){var v,g,S,w;if(void 0!==i){if(v=function(){var t=void 0!==i.reason?i.reason:new Rt("Aborted","AbortError"),a=[];o||a.push(function(){return"writable"===r._state?Fr(r,t):d(void 0)}),n||a.push(function(){return"readable"===e._state?eo(e,t):d(void 0)}),P(function(){return Promise.all(a.map(function(e){return e()}))},!0,t)},i.aborted)return void v();i.addEventListener("abort",v)}function R(){for(;!l._shuttingDown&&!r._backpressure&&"writable"===r._state&&!Yr(r)&&"readable"===e._state&&le(a);)ue(a,s);if(l._shuttingDown)return d(!0);if(r._backpressure)return b(u._readyPromise,R);var t=new Ct(l);return ue(a,t),t._promise}if(Et(e,a._closedPromise,function(e){return o?C(!0,e):P(function(){return Fr(r,e)},!0,e),null}),Et(r,u._closedPromise,function(r){return n?C(!0,r):P(function(){return eo(e,r)},!0,r),null}),g=e,S=a._closedPromise,w=function(){return t?C():P(function(){return function(e){var r=e._ownerWritableStream,t=r._state;return Yr(r)||"closed"===t?d(void 0):"errored"===t?p(r._storedError):Ur(e)}(u)}),null},"closed"===g._state?w():_(S,w),Yr(r)||"closed"===r._state){var T=new TypeError("the destination writable stream closed before all data could be piped to it");n?C(!0,T):P(function(){return eo(e,T)},!0,T)}function P(e,t,o){function n(){return h(e(),function(){return q(t,o)},function(e){return q(!0,e)}),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?n():_(l._waitForWritesToFinish(),n))}function C(e,t){l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?q(e,t):_(l._waitForWritesToFinish(),function(){return q(e,t)}))}function q(e,r){return Jr(u),B(a),void 0!==i&&i.removeEventListener("abort",v),e?m(r):c(void 0),null}y(f(function(e,r){!function t(o){o?e():b(R(),t,r)}(!1)}))})}var Pt=function(){function e(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=d(void 0)}return e.prototype._waitForWritesToFinish=function(){var e=this,r=this._currentWrite;return b(this._currentWrite,function(){return r!==e._currentWrite?e._waitForWritesToFinish():void 0})},e}(),Ct=function(){function e(e){var r=this;this._state=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t),this._resolvePromise(!1)},e.prototype._closeSteps=function(){this._resolvePromise(!0)},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),qt=function(){function e(e){this._state=e}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t)},e.prototype._closeSteps=function(){},e.prototype._errorSteps=function(e){},e}();function Et(e,r,t){"errored"===e._state?t(e._storedError):m(r,t)}var Wt=function(){function ReadableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Ot(this))throw Mt("desiredSize");return Ft(this)},enumerable:!1,configurable:!0}),ReadableStreamDefaultController.prototype.close=function(){if(!Ot(this))throw Mt("close");if(!Lt(this))throw new TypeError("The stream is not in a state that permits close");At(this)},ReadableStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("enqueue");if(!Lt(this))throw new TypeError("The stream is not in a state that permits enqueue");return zt(this,e)},ReadableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("error");Dt(this,e)},ReadableStreamDefaultController.prototype[C]=function(e){je(this);var r=this._cancelAlgorithm(e);return kt(this),r},ReadableStreamDefaultController.prototype[q]=function(e){var r=this._controlledReadableStream;if(this._queue.length>0){var t=We(this);this._closeRequested&&0===this._queue.length?(kt(this),ro(r)):jt(this),e._chunkSteps(t)}else J(r,e),jt(this)},ReadableStreamDefaultController.prototype[E]=function(){return this._queue.length>0},ReadableStreamDefaultController.prototype[W]=function(){},ReadableStreamDefaultController}();function Ot(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof Wt)}function jt(e){Bt(e)&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,jt(e)),null},function(r){return Dt(e,r),null})))}function Bt(e){var r=e._controlledReadableStream;return!!Lt(e)&&(!!e._started&&(!!($t(r)&&Z(r)>0)||Ft(e)>0))}function kt(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function At(e){if(Lt(e)){var r=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(kt(e),ro(r))}}function zt(e,r){if(Lt(e)){var t=e._controlledReadableStream;if($t(t)&&Z(t)>0)K(t,r,!1);else{var o=void 0;try{o=e._strategySizeAlgorithm(r)}catch(r){throw Dt(e,r),r}try{Oe(e,r,o)}catch(r){throw Dt(e,r),r}}jt(e)}}function Dt(e,r){var t=e._controlledReadableStream;"readable"===t._state&&(je(e),kt(e),to(t,r))}function Ft(e){var r=e._controlledReadableStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function Lt(e){var r=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===r}function It(e,r,t,o,n,i,a){r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=a,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,jt(r),null},function(e){return Dt(r,e),null})}function Mt(e){return new TypeError("ReadableStreamDefaultController.prototype.".concat(e," can only be used on a ReadableStreamDefaultController"))}function xt(e,r){return De(e._readableStreamController)?function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=!1,b=f(function(e){i=e});function h(e){m(e._closedPromise,function(r){return e!==a||(tr(o._readableStreamController,r),tr(n._readableStreamController,r),c&&p||i(void 0)),null})}function _(){yr(a)&&(B(a),h(a=X(e))),ue(a,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var t=r,a=r;if(!c&&!p)try{a=Ee(r)}catch(r){return tr(o._readableStreamController,r),tr(n._readableStreamController,r),void i(eo(e,r))}c||rr(o._readableStreamController,t),p||rr(n._readableStreamController,a),u=!1,l?y():s&&S()})},_closeSteps:function(){u=!1,c||er(o._readableStreamController),p||er(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&ar(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&ar(n._readableStreamController,0),c&&p||i(void 0)},_errorSteps:function(){u=!1}})}function v(r,t){ae(a)&&(B(a),h(a=dr(e)));var f=t?n:o,d=t?o:n;gr(a,r,1,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var o=t?p:c;if(t?c:p)o||ur(f._readableStreamController,r);else{var n=void 0;try{n=Ee(r)}catch(r){return tr(f._readableStreamController,r),tr(d._readableStreamController,r),void i(eo(e,r))}o||ur(f._readableStreamController,r),rr(d._readableStreamController,n)}u=!1,l?y():s&&S()})},_closeSteps:function(e){u=!1;var r=t?p:c,o=t?c:p;r||er(f._readableStreamController),o||er(d._readableStreamController),void 0!==e&&(r||ur(f._readableStreamController,e),!o&&d._readableStreamController._pendingPullIntos.length>0&&ar(d._readableStreamController,0)),r&&o||i(void 0)},_errorSteps:function(){u=!1}})}function y(){if(u)return l=!0,d(void 0);u=!0;var e=nr(o._readableStreamController);return null===e?_():v(e._view,!1),d(void 0)}function S(){if(u)return s=!0,d(void 0);u=!0;var e=nr(n._readableStreamController);return null===e?_():v(e._view,!0),d(void 0)}function w(o){if(c=!0,r=o,p){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function R(o){if(p=!0,t=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function T(){}return o=Jt(T,y,w),n=Jt(T,S,R),h(a),[o,n]}(e):function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=f(function(e){i=e});function b(){return u?(l=!0,d(void 0)):(u=!0,ue(a,{_chunkSteps:function(e){g(function(){l=!1;var r=e,t=e;s||zt(o._readableStreamController,r),c||zt(n._readableStreamController,t),u=!1,l&&b()})},_closeSteps:function(){u=!1,s||At(o._readableStreamController),c||At(n._readableStreamController),s&&c||i(void 0)},_errorSteps:function(){u=!1}}),d(void 0))}function h(o){if(s=!0,r=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function _(o){if(c=!0,t=o,s){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function v(){}return o=Xt(v,b,h),n=Xt(v,b,_),m(a._closedPromise,function(e){return Dt(o._readableStreamController,e),Dt(n._readableStreamController,e),s&&c||i(void 0),null}),[o,n]}(e)}function Yt(e){return o(r=e)&&void 0!==r.getReader?function(e){var r;function n(){var t;try{t=e.read()}catch(e){return p(e)}return v(t,function(e){if(!o(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function i(r){try{return d(e.cancel(r))}catch(e){return p(e)}}return r=Xt(t,n,i,0),r}(e.getReader()):function(e){var r,n=ge(e,"async");function i(){var e;try{e=Se(n)}catch(e){return p(e)}return v(d(e),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function a(e){var r,t=n.iterator;try{r=_e(t,"return")}catch(e){return p(e)}return void 0===r?d(void 0):v(w(r,t,[e]),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return r=Xt(t,i,a,0),r}(e);var r}function Qt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Nt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Ht(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Vt(e,r){if("bytes"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamType"));return e}function Ut(e,r){M(e,r);var t=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,i=null==e?void 0:e.signal;return void 0!==i&&function(e,r){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError("".concat(r," is not an AbortSignal."))}(i,"".concat(r," has member 'signal' that")),{preventAbort:Boolean(t),preventCancel:Boolean(o),preventClose:Boolean(n),signal:i}}Object.defineProperties(Wt.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),i(Wt.prototype.close,"close"),i(Wt.prototype.enqueue,"enqueue"),i(Wt.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Wt.prototype,r.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});var Gt=function(){function ReadableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=e,o=null==t?void 0:t.autoAllocateChunkSize,n=null==t?void 0:t.cancel,i=null==t?void 0:t.pull,a=null==t?void 0:t.start,u=null==t?void 0:t.type;return{autoAllocateChunkSize:void 0===o?void 0:U(o,"".concat(r," has member 'autoAllocateChunkSize' that")),cancel:void 0===n?void 0:Qt(n,t,"".concat(r," has member 'cancel' that")),pull:void 0===i?void 0:Nt(i,t,"".concat(r," has member 'pull' that")),start:void 0===a?void 0:Ht(a,t,"".concat(r," has member 'start' that")),type:void 0===u?void 0:Vt(u,"".concat(r," has member 'type' that"))}}(e,"First parameter");if(Kt(this),"bytes"===o.type){if(void 0!==t.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,r,t){var o,n,i,a=Object.create(ze.prototype);o=void 0!==r.start?function(){return r.start(a)}:function(){},n=void 0!==r.pull?function(){return r.pull(a)}:function(){return d(void 0)},i=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};var u=r.autoAllocateChunkSize;if(0===u)throw new TypeError("autoAllocateChunkSize must be greater than 0");lr(e,a,o,n,i,t,u)}(this,o,Rr(t,0))}else{var n=Tr(t);!function(e,r,t,o){var n,i,a,u=Object.create(Wt.prototype);n=void 0!==r.start?function(){return r.start(u)}:function(){},i=void 0!==r.pull?function(){return r.pull(u)}:function(){return d(void 0)},a=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)},It(e,u,n,i,a,t,o)}(this,o,Rr(t,1),n)}}return Object.defineProperty(ReadableStream.prototype,"locked",{get:function(){if(!Zt(this))throw oo("locked");return $t(this)},enumerable:!1,configurable:!0}),ReadableStream.prototype.cancel=function(e){return void 0===e&&(e=void 0),Zt(this)?$t(this)?p(new TypeError("Cannot cancel a stream that already has a reader")):eo(this,e):p(oo("cancel"))},ReadableStream.prototype.getReader=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("getReader");return void 0===function(e,r){M(e,r);var t=null==e?void 0:e.mode;return{mode:void 0===t?void 0:fr(t,"".concat(r," has member 'mode' that"))}}(e,"First parameter").mode?X(this):dr(this)},ReadableStream.prototype.pipeThrough=function(e,r){if(void 0===r&&(r={}),!Zt(this))throw oo("pipeThrough");Q(e,1,"pipeThrough");var t=function(e,r){M(e,r);var t=null==e?void 0:e.readable;N(t,"readable","ReadableWritablePair"),G(t,"".concat(r," has member 'readable' that"));var o=null==e?void 0:e.writable;return N(o,"writable","ReadableWritablePair"),jr(o,"".concat(r," has member 'writable' that")),{readable:t,writable:o}}(e,"First parameter"),o=Ut(r,"Second parameter");if($t(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Dr(t.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return y(Tt(this,t.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),t.readable},ReadableStream.prototype.pipeTo=function(e,r){if(void 0===r&&(r={}),!Zt(this))return p(oo("pipeTo"));if(void 0===e)return p("Parameter 1 is required in 'pipeTo'.");if(!zr(e))return p(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));var t;try{t=Ut(r,"Second parameter")}catch(e){return p(e)}return $t(this)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Dr(e)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Tt(this,e,t.preventClose,t.preventAbort,t.preventCancel,t.signal)},ReadableStream.prototype.tee=function(){if(!Zt(this))throw oo("tee");return fe(xt(this))},ReadableStream.prototype.values=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("values");var r,t,o,n,i,a=function(e,r){M(e,r);var t=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(t)}}(e,"First parameter");return r=this,t=a.preventCancel,o=X(r),n=new we(o,t),(i=Object.create(Te))._asyncIteratorImpl=n,i},ReadableStream.prototype[ye]=function(e){return this.values(e)},ReadableStream.from=function(e){return Yt(e)},ReadableStream}();function Xt(e,r,t,o,n){void 0===o&&(o=1),void 0===n&&(n=function(){return 1});var i=Object.create(Gt.prototype);return Kt(i),It(i,Object.create(Wt.prototype),e,r,t,o,n),i}function Jt(e,r,t){var o=Object.create(Gt.prototype);return Kt(o),lr(o,Object.create(ze.prototype),e,r,t,0,void 0),o}function Kt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Zt(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof Gt)}function $t(e){return void 0!==e._reader}function eo(e,r){if(e._disturbed=!0,"closed"===e._state)return d(void 0);if("errored"===e._state)return p(e._storedError);ro(e);var o=e._reader;if(void 0!==o&&yr(o)){var n=o._readIntoRequests;o._readIntoRequests=new R,n.forEach(function(e){e._closeSteps(void 0)})}return v(e._readableStreamController[C](r),t)}function ro(e){e._state="closed";var r=e._reader;if(void 0!==r&&(F(r),ae(r))){var t=r._readRequests;r._readRequests=new R,t.forEach(function(e){e._closeSteps()})}}function to(e,r){e._state="errored",e._storedError=r;var t=e._reader;void 0!==t&&(D(t,r),ae(t)?se(t,r):Sr(t,r))}function oo(e){return new TypeError("ReadableStream.prototype.".concat(e," can only be used on a ReadableStream"))}function no(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark;return N(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:H(t)}}Object.defineProperties(Gt,{from:{enumerable:!0}}),Object.defineProperties(Gt.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),i(Gt.from,"from"),i(Gt.prototype.cancel,"cancel"),i(Gt.prototype.getReader,"getReader"),i(Gt.prototype.pipeThrough,"pipeThrough"),i(Gt.prototype.pipeTo,"pipeTo"),i(Gt.prototype.tee,"tee"),i(Gt.prototype.values,"values"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Gt.prototype,r.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(Gt.prototype,ye,{value:Gt.prototype.values,writable:!0,configurable:!0});var io=function(e){return e.byteLength};i(io,"size");var ao=function(){function ByteLengthQueuingStrategy(e){Q(e,1,"ByteLengthQueuingStrategy"),e=no(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(ByteLengthQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!lo(this))throw uo("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(ByteLengthQueuingStrategy.prototype,"size",{get:function(){if(!lo(this))throw uo("size");return io},enumerable:!1,configurable:!0}),ByteLengthQueuingStrategy}();function uo(e){return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(e," can only be used on a ByteLengthQueuingStrategy"))}function lo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ao)}Object.defineProperties(ao.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(ao.prototype,r.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});var so=function(){return 1};i(so,"size");var co=function(){function CountQueuingStrategy(e){Q(e,1,"CountQueuingStrategy"),e=no(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(CountQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!po(this))throw fo("highWaterMark");return this._countQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(CountQueuingStrategy.prototype,"size",{get:function(){if(!po(this))throw fo("size");return so},enumerable:!1,configurable:!0}),CountQueuingStrategy}();function fo(e){return new TypeError("CountQueuingStrategy.prototype.".concat(e," can only be used on a CountQueuingStrategy"))}function po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof co)}function bo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function ho(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function _o(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function mo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}Object.defineProperties(co.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(co.prototype,r.toStringTag,{value:"CountQueuingStrategy",configurable:!0});var vo=function(){function TransformStream(e,r,t){void 0===e&&(e={}),void 0===r&&(r={}),void 0===t&&(t={}),void 0===e&&(e=null);var o=Pr(r,"Second parameter"),n=Pr(t,"Third parameter"),i=function(e,r){M(e,r);var t=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,i=null==e?void 0:e.start,a=null==e?void 0:e.transform,u=null==e?void 0:e.writableType;return{cancel:void 0===t?void 0:mo(t,e,"".concat(r," has member 'cancel' that")),flush:void 0===o?void 0:bo(o,e,"".concat(r," has member 'flush' that")),readableType:n,start:void 0===i?void 0:ho(i,e,"".concat(r," has member 'start' that")),transform:void 0===a?void 0:_o(a,e,"".concat(r," has member 'transform' that")),writableType:u}}(e,"First parameter");if(void 0!==i.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==i.writableType)throw new RangeError("Invalid writableType specified");var a,u=Rr(n,0),l=Tr(n),s=Rr(o,1),c=Tr(o);!function(e,r,t,o,n,i){function a(){return r}function u(r){return function(e,r){var t=e._transformStreamController;if(e._backpressure){return v(e._backpressureChangePromise,function(){var o=e._writable;if("erroring"===o._state)throw o._storedError;return Eo(t,r)})}return Eo(t,r)}(e,r)}function l(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._readable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(Dt(o._readableStreamController,r),Oo(t)),null},function(e){return Dt(o._readableStreamController,e),jo(t,e),null}),t._finishPromise}(e,r)}function s(){return function(e){var r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;var t=e._readable;r._finishPromise=f(function(e,t){r._finishPromise_resolve=e,r._finishPromise_reject=t});var o=r._flushAlgorithm();return Co(r),h(o,function(){return"errored"===t._state?jo(r,t._storedError):(At(t._readableStreamController),Oo(r)),null},function(e){return Dt(t._readableStreamController,e),jo(r,e),null}),r._finishPromise}(e)}function c(){return function(e){return Ro(e,!1),e._backpressureChangePromise}(e)}function d(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._writable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(it(o._writableStreamController,r),wo(e),Oo(t)),null},function(r){return it(o._writableStreamController,r),wo(e),jo(t,r),null}),t._finishPromise}(e,r)}e._writable=function(e,r,t,o,n,i){void 0===n&&(n=1),void 0===i&&(i=function(){return 1});var a=Object.create(Br.prototype);return Ar(a),rt(a,Object.create($r.prototype),e,r,t,o,n,i),a}(a,u,s,l,t,o),e._readable=Xt(a,c,d,n,i),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,Ro(e,!0),e._transformStreamController=void 0}(this,f(function(e){a=e}),s,c,u,l),function(e,r){var t,o,n,i=Object.create(To.prototype);t=void 0!==r.transform?function(e){return r.transform(e,i)}:function(e){try{return qo(i,e),d(void 0)}catch(e){return p(e)}};o=void 0!==r.flush?function(){return r.flush(i)}:function(){return d(void 0)};n=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};!function(e,r,t,o,n){r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=o,r._cancelAlgorithm=n,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}(e,i,t,o,n)}(this,i),void 0!==i.start?a(i.start(this._transformStreamController)):a(void 0)}return Object.defineProperty(TransformStream.prototype,"readable",{get:function(){if(!yo(this))throw Bo("readable");return this._readable},enumerable:!1,configurable:!0}),Object.defineProperty(TransformStream.prototype,"writable",{get:function(){if(!yo(this))throw Bo("writable");return this._writable},enumerable:!1,configurable:!0}),TransformStream}();function yo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof vo)}function go(e,r){Dt(e._readable._readableStreamController,r),So(e,r)}function So(e,r){Co(e._transformStreamController),it(e._writable._writableStreamController,r),wo(e)}function wo(e){e._backpressure&&Ro(e,!1)}function Ro(e,r){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=f(function(r){e._backpressureChangePromise_resolve=r}),e._backpressure=r}Object.defineProperties(vo.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(vo.prototype,r.toStringTag,{value:"TransformStream",configurable:!0});var To=function(){function TransformStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(TransformStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Po(this))throw Wo("desiredSize");return Ft(this._controlledTransformStream._readable._readableStreamController)},enumerable:!1,configurable:!0}),TransformStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("enqueue");qo(this,e)},TransformStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("error");var r;r=e,go(this._controlledTransformStream,r)},TransformStreamDefaultController.prototype.terminate=function(){if(!Po(this))throw Wo("terminate");!function(e){var r=e._controlledTransformStream;At(r._readable._readableStreamController);var t=new TypeError("TransformStream terminated");So(r,t)}(this)},TransformStreamDefaultController}();function Po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof To)}function Co(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function qo(e,r){var t=e._controlledTransformStream,o=t._readable._readableStreamController;if(!Lt(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{zt(o,r)}catch(e){throw So(t,e),t._readable._storedError}var n=function(e){return!Bt(e)}(o);n!==t._backpressure&&Ro(t,!0)}function Eo(e,r){return v(e._transformAlgorithm(r),void 0,function(r){throw go(e._controlledTransformStream,r),r})}function Wo(e){return new TypeError("TransformStreamDefaultController.prototype.".concat(e," can only be used on a TransformStreamDefaultController"))}function Oo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function jo(e,r){void 0!==e._finishPromise_reject&&(y(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function Bo(e){return new TypeError("TransformStream.prototype.".concat(e," can only be used on a TransformStream"))}Object.defineProperties(To.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),i(To.prototype.enqueue,"enqueue"),i(To.prototype.error,"error"),i(To.prototype.terminate,"terminate"),"symbol"==typeof r.toStringTag&&Object.defineProperty(To.prototype,r.toStringTag,{value:"TransformStreamDefaultController",configurable:!0}),e.ByteLengthQueuingStrategy=ao,e.CountQueuingStrategy=co,e.ReadableByteStreamController=ze,e.ReadableStream=Gt,e.ReadableStreamBYOBReader=_r,e.ReadableStreamBYOBRequest=Ae,e.ReadableStreamDefaultController=Wt,e.ReadableStreamDefaultReader=ee,e.TransformStream=vo,e.TransformStreamDefaultController=To,e.WritableStream=Br,e.WritableStreamDefaultController=$r,e.WritableStreamDefaultWriter=Hr}); diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..254b10dc 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -78,6 +78,7 @@ target_link_libraries(UnitTests PRIVATE Performance PRIVATE TextDecoder PRIVATE TextEncoder + PRIVATE Streams ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..6b153c59 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1541,6 +1541,162 @@ describe("Console", function () { }); }); +describe("Web Streams", function () { + // Focused ports from the WHATWG Streams WPT suites at c05b4473: + // readable-streams/general.any.js and tee.any.js, + // writable-streams/write.any.js, and transform-streams/general.any.js. + it("installs the standard stream constructors", function () { + expect(ReadableStream).to.be.a("function"); + expect(WritableStream).to.be.a("function"); + expect(TransformStream).to.be.a("function"); + expect(ByteLengthQueuingStrategy).to.be.a("function"); + expect(CountQueuingStrategy).to.be.a("function"); + }); + + it("delivers queued chunks in order and closes the reader", async function () { + const stream = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }); + const reader = stream.getReader(); + + expect(await reader.read()).to.deep.equal({ value: "a", done: false }); + expect(await reader.read()).to.deep.equal({ value: "b", done: false }); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + await reader.closed; + }); + + it("propagates a rejected pull to read and closed", async function () { + const failure = new Error("pull failed"); + const reader = new ReadableStream({ + pull() { + return Promise.reject(failure); + } + }).getReader(); + + let readFailure: unknown; + let closedFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + try { await reader.closed; } catch (error) { closedFailure = error; } + expect(readFailure).to.equal(failure); + expect(closedFailure).to.equal(failure); + }); + + it("tees without one branch consuming the other", async function () { + const [first, second] = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }).tee(); + const firstReader = first.getReader(); + const secondReader = second.getReader(); + + expect(await firstReader.read()).to.deep.equal({ value: "a", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: "b", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: undefined, done: true }); + expect(await secondReader.read()).to.deep.equal({ value: "a", done: false }); + }); + + it("waits for asynchronous writes before closing", async function () { + const stored: number[] = []; + const writable = new WritableStream({ + write(chunk) { + return Promise.resolve().then(() => stored.push(chunk)); + } + }); + const writer = writable.getWriter(); + + writer.write(1); + writer.write(2); + await writer.close(); + expect(stored).to.deep.equal([1, 2]); + }); + + it("applies transform output and backpressure", async function () { + const transform = new TransformStream({ + transform(chunk, controller) { + controller.enqueue(chunk.toUpperCase()); + } + }); + const writer = transform.writable.getWriter(); + const reader = transform.readable.getReader(); + const write = writer.write("native"); + + expect(await reader.read()).to.deep.equal({ value: "NATIVE", done: false }); + await write; + await writer.close(); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + }); + + it("supports BYOB reads from byte streams", async function () { + let sent = false; + const stream = new ReadableStream({ + type: "bytes", + pull(controller) { + if (!sent) { + sent = true; + controller.enqueue(new Uint8Array([8, 241, 48, 123, 151])); + controller.close(); + } + } + } as any); + const reader = stream.getReader({ mode: "byob" }); + const result = await reader.read(new Uint8Array(8)); + + expect(result.done).to.equal(false); + expect(Array.from(result.value!)).to.deep.equal([8, 241, 48, 123, 151]); + expect((await reader.read(new Uint8Array(8))).done).to.equal(true); + }); + + // Ported from Firefox's dom/streams/test/xpcshell/subclassing.js. + it("supports subclassed streams, readers, and queuing strategies", async function () { + class SubclassedStream extends ReadableStream {} + class SubclassedStrategy extends CountQueuingStrategy {} + const stream = new SubclassedStream({ + start(controller) { + controller.enqueue("first"); + controller.close(); + } + }); + const Reader = stream.getReader().constructor as typeof ReadableStreamDefaultReader; + class SubclassedReader extends Reader {} + + expect(stream).to.be.instanceOf(ReadableStream); + expect(new SubclassedStrategy({ highWaterMark: 4 }).highWaterMark).to.equal(4); + + const secondStream = new ReadableStream({ + start(controller) { + controller.enqueue("second"); + controller.close(); + } + }); + const reader = new SubclassedReader(secondStream); + expect(await reader.read()).to.deep.equal({ value: "second", done: false }); + }); + + // Ported from Chromium's http/tests/streams/chromium/transform-stream-enqueue.html. + it("rejects enqueues after a transform is terminated or errored", function () { + expect(() => new TransformStream({ + start(controller) { + controller.terminate(); + controller.enqueue("late"); + } + })).to.throw(TypeError); + + expect(() => new TransformStream({ + start(controller) { + controller.error(new Error("failed")); + controller.enqueue("late"); + } + })).to.throw(TypeError); + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..b71218bd 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -90,6 +91,7 @@ TEST(JavaScript, All) Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -166,6 +168,30 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } +TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); + global.Set("ReadableStream", hostReadableStream); + + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").IsFunction()); + + const auto installedTransformStream = global.Get("TransformStream"); + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 6f460de0e8017352ff581ed05e5490510ced1b20 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 22:19:21 -0700 Subject: [PATCH 080/174] Complete Blob streaming and slicing support Implement iterable BlobPart conversion, MIME and endings normalization, zero-copy Blob composition and slicing, and lazy 64 KiB byte streams. Delegate File streaming and slicing to its backing Blob while preserving browser class identity.\n\nUse immutable shared segments so nested Blob and slice construction do not duplicate payload bytes. Add focused WPT, WebKit, and Firefox regression coverage for constructor ordering, iterator closure, UTF-8 decoding, BYOB reads, cancellation, lifetime safety, and large nested streams. --- Polyfills/Blob/CMakeLists.txt | 1 + Polyfills/Blob/README.md | 12 + Polyfills/Blob/Source/Blob.cpp | 507 ++++++++++++++++++++++++++++--- Polyfills/Blob/Source/Blob.h | 27 +- Polyfills/File/Source/File.cpp | 47 ++- Polyfills/File/Source/File.h | 2 + Tests/UnitTests/Scripts/tests.ts | 227 ++++++++++++++ 7 files changed, 761 insertions(+), 62 deletions(-) create mode 100644 Polyfills/Blob/README.md diff --git a/Polyfills/Blob/CMakeLists.txt b/Polyfills/Blob/CMakeLists.txt index b8da610e..d2f9d88f 100644 --- a/Polyfills/Blob/CMakeLists.txt +++ b/Polyfills/Blob/CMakeLists.txt @@ -1,6 +1,7 @@ set(SOURCES "Include/Babylon/Polyfills/Blob.h" "InternalInclude/Babylon/Polyfills/BlobInternal.h" + "README.md" "Source/Blob.cpp" "Source/Blob.h") diff --git a/Polyfills/Blob/README.md b/Polyfills/Blob/README.md new file mode 100644 index 00000000..2206f9c4 --- /dev/null +++ b/Polyfills/Blob/README.md @@ -0,0 +1,12 @@ +# Blob + +Provides the browser `Blob` constructor, byte/text readers, zero-copy Blob +composition and slicing, and a lazily pulled byte `ReadableStream`. + +Call `Babylon::Polyfills::Streams::Initialize` before using `Blob.stream()` on +engines that do not provide Web Streams. Stream reads copy only the requested +chunk into JavaScript-owned memory; composing Blobs and slicing share immutable +native byte segments. + +The focused tests are adapted from WPT `FileAPI/blob`, WebKit's Blob stream +chunk/crash regressions, and Firefox's large Blob `pipeTo` regression. diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 242763fe..bed99cb6 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -3,8 +3,63 @@ #include #include +#include +#include +#include + namespace Babylon::Polyfills::Internal { + struct Blob::Segment + { + std::shared_ptr> Bytes; + size_t Offset{}; + size_t Length{}; + }; + + struct Blob::Storage + { + std::vector Segments; + size_t Size{}; + + void Append(const Segment& segment) + { + if (segment.Length == 0) + { + return; + } + + Segments.emplace_back(segment); + Size += segment.Length; + } + + void CopyTo(size_t position, std::byte* destination, size_t length) const + { + size_t segmentStart{}; + for (const auto& segment : Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + if (position < segmentEnd && length > 0) + { + const auto localOffset = position > segmentStart ? position - segmentStart : 0; + const auto copyLength = std::min(segment.Length - localOffset, length); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + localOffset, copyLength); + destination += copyLength; + position += copyLength; + length -= copyLength; + } + segmentStart = segmentEnd; + } + } + }; + + struct Blob::StreamState + { + std::shared_ptr BlobData; + size_t Position{}; + size_t SegmentIndex{}; + size_t SegmentOffset{}; + }; + void Blob::Initialize(Napi::Env env) { static constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; @@ -19,8 +74,14 @@ namespace Babylon::Polyfills::Internal InstanceMethod("text", &Blob::Text), InstanceMethod("arrayBuffer", &Blob::ArrayBuffer), InstanceMethod("bytes", &Blob::Bytes), + InstanceMethod("slice", &Blob::Slice), + InstanceMethod("stream", &Blob::Stream), }); + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_BLOB_CONSTRUCTOR_NAME); + env.Global().Get("Object").As().Get("defineProperty").As().Call(env.Global().Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -28,36 +89,122 @@ namespace Babylon::Polyfills::Internal Blob::Blob(const Napi::CallbackInfo& info) : Napi::ObjectWrap(info) { - if (info.Length() > 0) + auto env = Env(); + auto data = std::make_shared(); + std::vector stringSegmentIndices; + bool convertLineEndings{}; + + if (info.Length() > 0 && !info[0].IsUndefined()) { - const auto blobParts = info[0].As(); + if (!info[0].IsObject() && !info[0].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob parts must be an iterable object."); + } + + const auto blobParts = info[0].As(); + if (blobParts.IsArray()) + { + data->Segments.reserve(blobParts.As().Length()); + } - if (blobParts.Length() > 0) + const auto reflect = env.Global().Get("Reflect").As(); + const auto iteratorMethod = reflect.Get("get").As().Call( + reflect, + {blobParts, Napi::Symbol::WellKnown(env, "iterator")}); + if (!iteratorMethod.IsFunction()) { - const auto firstPart = blobParts.Get(uint32_t{0}); - ProcessBlobPart(firstPart); + throw Napi::TypeError::New(env, "Blob parts must be iterable."); + } - if (blobParts.Length() > 1) + const auto iterator = iteratorMethod.As().Call(blobParts, {}).As(); + const auto next = iterator.Get("next").As(); + try + { + while (true) { - throw Napi::Error::New(Env(), "Using multiple BlobParts in Blob constructor is not implemented."); + const auto result = next.Call(iterator, {}).As(); + if (result.Get("done").ToBoolean().Value()) + { + break; + } + + if (AppendBlobPart(*data, result.Get("value"))) + { + stringSegmentIndices.emplace_back(data->Segments.size() - 1); + } } } + catch (...) + { + try + { + const auto returnMethod = iterator.Get("return"); + if (returnMethod.IsFunction()) + { + returnMethod.As().Call(iterator, {}); + } + } + catch (...) + { + // Preserve the exception that interrupted part conversion. + } + throw; + } } - if (info.Length() > 1) + if (info.Length() > 1 && !info[1].IsUndefined() && !info[1].IsNull()) { + if (!info[1].IsObject() && !info[1].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob options must be an object."); + } + const auto options = info[1].As(); + const auto endings = options.Get("endings"); + if (!endings.IsUndefined()) + { + const auto value = endings.ToString().Utf8Value(); + if (value != "transparent" && value != "native") + { + throw Napi::TypeError::New(env, "Blob endings must be 'transparent' or 'native'."); + } + convertLineEndings = value == "native"; + } + + const auto type = options.Get("type"); + if (!type.IsUndefined()) + { + m_type = NormalizeType(type.ToString().Utf8Value()); + } + } - if (options.Has("type")) + if (convertLineEndings) + { + for (const auto segmentIndex : stringSegmentIndices) { - m_type = options.Get("type").As().Utf8Value(); + auto& segment = data->Segments[segmentIndex]; + auto value = std::string{ + reinterpret_cast(segment.Bytes->data() + segment.Offset), + segment.Length}; + value = NormalizeLineEndings(std::move(value)); + + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data->Size -= segment.Length; + segment = {std::move(bytes), 0, value.size()}; + data->Size += segment.Length; } } + + m_data = std::move(data); } Napi::Value Blob::GetSize(const Napi::CallbackInfo&) { - return Napi::Value::From(Env(), m_data->size()); + return Napi::Value::From(Env(), m_data->Size); } Napi::Value Blob::GetType(const Napi::CallbackInfo&) @@ -68,8 +215,11 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::Text(const Napi::CallbackInfo&) { // NOTE: This will not check for UTF-8 validity - const auto begin = reinterpret_cast(m_data->data()); - std::string text(begin, m_data->size()); + std::string text(m_data->Size, '\0'); + if (!text.empty()) + { + m_data->CopyTo(0, reinterpret_cast(text.data()), text.size()); + } const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(Napi::String::New(Env(), text)); @@ -78,60 +228,333 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::ArrayBuffer(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto deferred = Napi::Promise::Deferred::New(Env()); - deferred.Resolve(arrayBuffer); + deferred.Resolve(CreateArrayBuffer()); return deferred.Promise(); } Napi::Value Blob::Bytes(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->size(), arrayBuffer, 0); + const auto arrayBuffer = CreateArrayBuffer(); + const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->Size, arrayBuffer, 0); const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(uint8Array); return deferred.Promise(); } - void Blob::ProcessBlobPart(const Napi::Value& blobPart) + Napi::Value Blob::Slice(const Napi::CallbackInfo& info) { + const auto start = NormalizeSliceIndex( + info.Length() > 0 && !info[0].IsUndefined() ? info[0].ToNumber().DoubleValue() : 0, + m_data->Size); + const auto end = NormalizeSliceIndex( + info.Length() > 1 && !info[1].IsUndefined() ? info[1].ToNumber().DoubleValue() : static_cast(m_data->Size), + m_data->Size); + const auto sliceEnd = std::max(start, end); + + auto sliceData = std::make_shared(); + size_t segmentStart{}; + for (const auto& segment : m_data->Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + const auto overlapStart = std::max(start, segmentStart); + const auto overlapEnd = std::min(sliceEnd, segmentEnd); + if (overlapStart < overlapEnd) + { + sliceData->Append({segment.Bytes, segment.Offset + overlapStart - segmentStart, overlapEnd - overlapStart}); + } + segmentStart = segmentEnd; + if (segmentStart >= sliceEnd) + { + break; + } + } + + std::string contentType; + if (info.Length() > 2 && !info[2].IsUndefined()) + { + contentType = NormalizeType(info[2].ToString().Utf8Value()); + } + + const auto blobConstructor = Env().Global().Get("Blob").As(); + const auto result = blobConstructor.New({Napi::Array::New(Env())}); + auto resultBlob = Napi::ObjectWrap::Unwrap(result); + resultBlob->m_data = std::move(sliceData); + resultBlob->m_type = std::move(contentType); + return result; + } + + Napi::Value Blob::Stream(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + const auto readableStreamValue = env.Global().Get("ReadableStream"); + if (!readableStreamValue.IsFunction()) + { + throw Napi::TypeError::New(env, "Blob.stream() requires ReadableStream to be installed."); + } + + auto state = std::make_shared(); + state->BlobData = m_data; + + auto source = Napi::Object::New(env); + source.Set("type", "bytes"); + source.Set("pull", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + auto callbackEnv = callbackInfo.Env(); + auto controller = callbackInfo[0].As(); + if (!state->BlobData || state->Position >= state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + return callbackEnv.Undefined(); + } + + constexpr size_t CHUNK_SIZE = 64 * 1024; + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + auto destination = static_cast(outputBuffer.Data()); + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + + if (state->Position == state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + } + + return callbackEnv.Undefined(); + })); + source.Set("cancel", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + state->BlobData.reset(); + return callbackInfo.Env().Undefined(); + })); + + return readableStreamValue.As().New({source}); + } + + bool Blob::AppendBlobPart(Storage& data, const Napi::Value& blobPart) + { + const std::byte* source{}; + size_t length{}; + bool isBufferSource{}; + if (blobPart.IsArrayBuffer()) { const auto buffer = blobPart.As(); - const auto begin = static_cast(buffer.Data()); - m_data = std::make_shared>(begin, begin + buffer.ByteLength()); + source = static_cast(buffer.Data()); + length = buffer.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsTypedArray() || blobPart.IsDataView()) + else if (blobPart.IsTypedArray()) { const auto array = blobPart.As(); const auto buffer = array.ArrayBuffer(); - const auto begin = static_cast(buffer.Data()) + array.ByteOffset(); - m_data = std::make_shared>(begin, begin + array.ByteLength()); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + array.ByteOffset(); + length = array.ByteLength(); + isBufferSource = true; + } + else if (blobPart.IsDataView()) + { + const auto view = blobPart.As(); + const auto buffer = view.ArrayBuffer(); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); + length = view.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsString()) + else if (blobPart.IsObject()) { - const auto str = blobPart.As().Utf8Value(); - const auto begin = reinterpret_cast(str.data()); - m_data = std::make_shared>(begin, begin + str.length()); + const auto object = blobPart.As(); + const auto blobConstructor = Env().Global().Get("Blob").As(); + if (object.InstanceOf(blobConstructor)) + { + auto nativeBlob = object; + if (!object.Get("constructor").StrictEquals(blobConstructor)) + { + nativeBlob = object.Get("slice").As().Call(object, {Napi::Number::New(Env(), 0), object.Get("size")}).As(); + } + + const auto blob = Napi::ObjectWrap::Unwrap(nativeBlob); + data.Segments.reserve(data.Segments.size() + blob->m_data->Segments.size()); + for (const auto& segment : blob->m_data->Segments) + { + data.Append(segment); + } + return false; + } } - else + + if (isBufferSource) { - // Assume it's another Blob object. Blobs are immutable, so the buffer can be shared - // rather than copied. - const auto obj = blobPart.As(); - const auto blobObj = Napi::ObjectWrap::Unwrap(obj); - m_data = blobObj->m_data; + auto bytes = std::make_shared>(length); + if (length > 0) + { + std::memcpy(bytes->data(), source, length); + } + data.Append({std::move(bytes), 0, length}); + return false; } + + auto value = blobPart.ToString().Utf8Value(); + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data.Append({std::move(bytes), 0, value.size()}); + return !value.empty(); + } + + Napi::ArrayBuffer Blob::CreateArrayBuffer() const + { + auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, static_cast(arrayBuffer.Data()), m_data->Size); + } + return arrayBuffer; + } + + const std::shared_ptr>& Blob::Data() const + { + if (!m_contiguous) + { + const auto& segments = m_data->Segments; + if (segments.size() == 1 && segments[0].Offset == 0 && segments[0].Length == segments[0].Bytes->size()) + { + m_contiguous = segments[0].Bytes; + } + else + { + auto bytes = std::make_shared>(m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, bytes->data(), m_data->Size); + } + m_contiguous = std::move(bytes); + } + } + return m_contiguous; + } + + std::string Blob::NormalizeType(std::string type) + { + for (auto& character : type) + { + const auto value = static_cast(character); + if (value < 0x20 || value > 0x7E) + { + return {}; + } + if (character >= 'A' && character <= 'Z') + { + character = static_cast(character - 'A' + 'a'); + } + } + return type; + } + + std::string Blob::NormalizeLineEndings(std::string value) + { +#ifdef _WIN32 + static constexpr auto nativeNewline = "\r\n"; +#else + static constexpr auto nativeNewline = "\n"; +#endif + size_t outputLength{}; + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + outputLength += std::char_traits::length(nativeNewline); + } + else if (value[index] == '\n') + { + outputLength += std::char_traits::length(nativeNewline); + } + else + { + ++outputLength; + } + } + + std::string result; + result.reserve(outputLength); + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + result.append(nativeNewline); + } + else if (value[index] == '\n') + { + result.append(nativeNewline); + } + else + { + result.push_back(value[index]); + } + } + return result; + } + + size_t Blob::NormalizeSliceIndex(double value, size_t size) + { + if (std::isnan(value)) + { + return 0; + } + + const auto magnitude = std::abs(value); + const auto lower = std::floor(magnitude); + const auto fraction = magnitude - lower; + auto rounded = lower; + if (fraction > 0.5 || (fraction == 0.5 && std::fmod(lower, 2.0) != 0.0)) + { + rounded += 1.0; + } + + if (value < 0) + { + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? 0 + : size - static_cast(rounded); + } + + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? size + : static_cast(rounded); } } diff --git a/Polyfills/Blob/Source/Blob.h b/Polyfills/Blob/Source/Blob.h index 5d0147d0..1f061f97 100644 --- a/Polyfills/Blob/Source/Blob.h +++ b/Polyfills/Blob/Source/Blob.h @@ -6,6 +6,7 @@ #include #include #include +#include namespace Babylon::Polyfills::Internal { @@ -17,9 +18,11 @@ namespace Babylon::Polyfills::Internal explicit Blob(const Napi::CallbackInfo& info); // Synchronous accessors for internal cross-polyfill use (e.g. URL.createObjectURL). - // A Blob is immutable once constructed, so the bytes are held in a shared_ptr and can be - // shared with consumers rather than copied. Never null. - const std::shared_ptr>& Data() const { return m_data; } + // A Blob is immutable once constructed, so its bytes can be shared with consumers rather + // than copied. Storage is segmented (slices and multi-part Blobs share their parts' + // buffers), so Data() hands back the one underlying buffer when there is exactly one, and + // otherwise materializes a contiguous copy once and caches it. Never null. + const std::shared_ptr>& Data() const; const std::string& Type() const { return m_type; } private: @@ -28,10 +31,22 @@ namespace Babylon::Polyfills::Internal Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); + + struct Segment; + struct Storage; + struct StreamState; + + bool AppendBlobPart(Storage& data, const Napi::Value& blobPart); + Napi::ArrayBuffer CreateArrayBuffer() const; - void ProcessBlobPart(const Napi::Value& blobPart); + static std::string NormalizeType(std::string type); + static std::string NormalizeLineEndings(std::string value); + static size_t NormalizeSliceIndex(double value, size_t size); - std::shared_ptr> m_data{std::make_shared>()}; + std::shared_ptr m_data; + mutable std::shared_ptr> m_contiguous; std::string m_type; }; -} \ No newline at end of file +} diff --git a/Polyfills/File/Source/File.cpp b/Polyfills/File/Source/File.cpp index 75261e79..47c07169 100644 --- a/Polyfills/File/Source/File.cpp +++ b/Polyfills/File/Source/File.cpp @@ -46,6 +46,8 @@ namespace Babylon::Polyfills::Internal InstanceMethod("arrayBuffer", &File::ArrayBuffer), InstanceMethod("text", &File::Text), InstanceMethod("bytes", &File::Bytes), + InstanceMethod("slice", &File::Slice), + InstanceMethod("stream", &File::Stream), }); global.Set(JS_FILE_CONSTRUCTOR_NAME, func); @@ -55,12 +57,16 @@ namespace Babylon::Polyfills::Internal // a Blob subtype; BJS core (fileTools, Offline/database, // abstractEngine, thinNativeEngine) branches on `instanceof Blob` // and needs File inputs to satisfy that check. - auto setPrototypeOf = env.Global().Get("Object").As() - .Get("setPrototypeOf").As(); + auto setPrototypeOf = env.Global().Get("Object").As().Get("setPrototypeOf").As(); setPrototypeOf.Call({ func.Get("prototype"), blob.As().Get("prototype"), }); + + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_FILE_CONSTRUCTOR_NAME); + global.Get("Object").As().Get("defineProperty").As().Call(global.Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); } File::File(const Napi::CallbackInfo& info) @@ -75,7 +81,7 @@ namespace Babylon::Polyfills::Internal { throw Napi::TypeError::New(env, "Failed to construct 'File': 2 arguments required, but only " + - std::to_string(info.Length()) + " present."); + std::to_string(info.Length()) + " present."); } Napi::Value parts = info[0]; @@ -114,21 +120,11 @@ namespace Babylon::Polyfills::Internal } } - Napi::Value partsArray; - if (parts.IsArray()) - { - partsArray = parts; - } - else - { - partsArray = Napi::Array::New(env, 0); - } - // Delegate byte-buffer construction to the native Blob polyfill so // we benefit from its existing BlobPart handling (ArrayBuffer, // typed array, string, Blob). auto blobCtor = env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).As(); - auto blobInstance = blobCtor.New({partsArray, blobOptions}); + auto blobInstance = blobCtor.New({parts, blobOptions}); m_blob = Napi::Persistent(blobInstance); } @@ -169,6 +165,29 @@ namespace Babylon::Polyfills::Internal auto blob = m_blob.Value(); return blob.Get("bytes").As().Call(blob, {}); } + + Napi::Value File::Slice(const Napi::CallbackInfo& info) + { + auto blob = m_blob.Value(); + const auto slice = blob.Get("slice").As(); + switch (info.Length()) + { + case 0: + return slice.Call(blob, {}); + case 1: + return slice.Call(blob, {info[0]}); + case 2: + return slice.Call(blob, {info[0], info[1]}); + default: + return slice.Call(blob, {info[0], info[1], info[2]}); + } + } + + Napi::Value File::Stream(const Napi::CallbackInfo&) + { + auto blob = m_blob.Value(); + return blob.Get("stream").As().Call(blob, {}); + } } namespace Babylon::Polyfills::File diff --git a/Polyfills/File/Source/File.h b/Polyfills/File/Source/File.h index 9d73edb2..49473666 100644 --- a/Polyfills/File/Source/File.h +++ b/Polyfills/File/Source/File.h @@ -22,6 +22,8 @@ namespace Babylon::Polyfills::Internal Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); Napi::ObjectReference m_blob; std::string m_name; diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 6b153c59..122cc1b2 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1698,8 +1698,24 @@ describe("Web Streams", function () { }); describe("Blob", function () { + this.timeout(10000); + let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; + async function readStream(stream: ReadableStream, mode?: "byob"): Promise { + const reader: any = stream.getReader(mode === undefined ? undefined : { mode }); + const bytes: number[] = []; + while (true) { + const result = mode === "byob" + ? await reader.read(new Uint8Array(64)) + : await reader.read(); + if (result.done) { + return bytes; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + } + before(function () { emptyBlobs = [new Blob([]), new Blob([])]; stringBlob = new Blob(["Hello"]); @@ -1742,6 +1758,120 @@ describe("Blob", function () { expect(modelGltfJson.type).to.equal("model/gltf+json"); }); + // Focused ports from WPT FileAPI/blob/Blob-constructor.any.js. + it("accepts iterable parts and preserves their order", async function () { + const parts = { + *[Symbol.iterator]() { + yield "foo"; + yield new Uint8Array([98, 97, 114]); + yield new Blob(["baz"]); + } + }; + const blob = new Blob(parts as any); + expect(blob.size).to.equal(9); + expect(await blob.text()).to.equal("foobarbaz"); + }); + + it("uses an Array's overridden iterator", async function () { + const parts = ["ignored"]; + parts[Symbol.iterator] = function* () { + yield "custom"; + }; + + expect(await new Blob(parts).text()).to.equal("custom"); + }); + + it("closes an iterator when BlobPart conversion throws", function () { + let closed = false; + const badPart = { + toString() { + throw new Error("part conversion failed"); + } + }; + const parts = (function* () { + try { + yield badPart; + } finally { + closed = true; + } + })(); + + // QuickJS currently wraps an exception rethrown through a native + // constructor as its generic JS error type, so assert the observable + // iterator-close behavior separately from the adapter's error text. + expect(() => new Blob(parts as any)).to.throw(); + expect(closed).to.equal(true); + }); + + it("observes BlobPart array mutations during iteration", async function () { + const parts: any[] = [ + { + toString() { + parts.pop(); + return "PASS"; + } + }, + { + toString() { + throw new Error("removed part was converted"); + } + } + ]; + + expect(await new Blob(parts).text()).to.equal("PASS"); + }); + + it("converts parts before reading options in WebIDL order", function () { + const accesses: string[] = []; + const part = { + toString() { + accesses.push("part"); + return "data"; + } + }; + new Blob([part], { + get type() { + accesses.push("type"); + return "TEXT/PLAIN"; + }, + get endings() { + accesses.push("endings"); + return "transparent" as EndingType; + } + }); + + expect(accesses).to.deep.equal(["part", "endings", "type"]); + }); + + it("validates the endings enum and options dictionary", function () { + expect(() => new Blob([], { endings: "NATIVE" as EndingType })).to.throw(); + expect(() => new Blob([], { endings: "invalid" as EndingType })).to.throw(); + for (const value of [123, true, "abc"]) { + expect(() => new Blob([], value as any)).to.throw(); + } + expect(() => new Blob([], null as any)).not.to.throw(); + expect(() => new Blob([], undefined)).not.to.throw(); + }); + + it("exposes browser-compatible class tags", function () { + expect(String(new Blob())).to.equal("[object Blob]"); + expect(String(new File([], "empty.txt"))).to.equal("[object File]"); + }); + + it("rejects primitive parts containers", function () { + for (const value of [null, true, 7, "not a sequence"]) { + // Some Node-API adapters currently wrap a Napi::TypeError thrown + // by a constructor as their generic JS error type. + expect(() => new Blob(value as any)).to.throw(); + } + }); + + it("normalizes valid MIME types and clears invalid types", function () { + expect(new Blob([], { type: "TEXT/PLAIN" }).type).to.equal("text/plain"); + expect(new Blob([], { type: "te\x09xt/plain" }).type).to.equal(""); + expect(new Blob([], { type: "text/\x7fplain" }).type).to.equal(""); + }); + // -------------------------------- Blob.text() -------------------------------- it("returns empty string for empty blobs", async function () { for (const blob of emptyBlobs) { @@ -1763,6 +1893,11 @@ describe("Blob", function () { expect(text).to.equal("你好, 世界"); }); + it("replaces invalid UTF-8 bytes", async function () { + const invalid = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]); + expect(await new Blob([invalid]).text()).to.equal("\ufffd".repeat(invalid.length)); + }); + it("preserves line endings like default transparent mode", async function () { const lineEndingsBlob = new Blob(["Hello\nWorld"]); const text = await lineEndingsBlob.text(); @@ -1809,6 +1944,82 @@ describe("Blob", function () { } }); + + // Focused ports from WPT FileAPI/blob/Blob-slice.any.js. + it("slices across part boundaries and applies clamp rounding", async function () { + const blob = new Blob(["foo", new Blob(["bar"]), "baz"]); + expect(await blob.slice(2, 7).text()).to.equal("obarb"); + expect(await new Blob(["abcd"]).slice(1.5).text()).to.equal("cd"); + expect(await new Blob(["abcd"]).slice(2.5).text()).to.equal("cd"); + expect(await blob.slice(-3, undefined, "TEXT/PLAIN").text()).to.equal("baz"); + expect(blob.slice(-3, undefined, "TEXT/PLAIN").type).to.equal("text/plain"); + }); + + // Focused ports from WPT FileAPI/blob/Blob-stream.any.js. + it("streams binary data through default and BYOB readers", async function () { + const input = [8, 241, 48, 123, 151]; + const blob = new Blob([new Uint8Array(input)]); + expect(await readStream(blob.stream())).to.deep.equal(input); + expect(await readStream(blob.stream(), "byob")).to.deep.equal(input); + expect(await readStream(new Blob().stream())).to.deep.equal([]); + }); + + it("keeps independent stream cursors after the Blob reference is dropped", async function () { + let blob: Blob | null = new Blob(["PASS"]); + const first = blob.stream(); + const second = blob.stream(); + blob = null; + expect(await readStream(first)).to.deep.equal([80, 65, 83, 83]); + expect(await readStream(second)).to.deep.equal([80, 65, 83, 83]); + }); + + // Adapted from WebKit's fast/files/blob-stream-chunks.html. + it("chunks a large Blob and supports cancellation without retaining work", async function () { + const blob = new Blob([new Uint8Array(5 * 1024 * 1024)]); + const reader = blob.stream().getReader(); + const first = await reader.read(); + expect(first.done).to.equal(false); + expect(first.value!.byteLength).to.be.at.most(64 * 1024); + await reader.cancel(); + await reader.closed; + }); + + // Adapted from WebKit's blob-stream crash regression and exercises + // teardown of the C++ pull-state closures under repeated construction. + it("constructs and cancels many empty streams without crashing", async function () { + for (let index = 0; index < 1000; ++index) { + await new Blob().stream().cancel(); + } + }); + + // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. + it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + const pattern = new Uint8Array(256 * 1024); + for (let index = 0; index < pattern.length; ++index) { + pattern[index] = index % 256; + } + const pair = new Blob([pattern, pattern]); + const nested = new Blob([pair, pair, pair, pair, pair, pair]); + let position = 0; + + await nested.stream().pipeTo(new WritableStream({ + write(chunk: Uint8Array) { + for (const value of chunk) { + const expected = position % pattern.length % 256; + if (value !== expected) { + throw new Error(`Blob stream byte ${position}: expected ${expected}, received ${value}`); + } + ++position; + } + } + })); + expect(position).to.equal(pattern.length * 12); + }); + + it("uses a File's Blob bytes when composing parts", async function () { + const file = new File(["a", "b"], "letters.txt"); + expect(await new Blob(["<", file, ">"]).text()).to.equal(""); + }); }); describe("napi class prototype isolation (#172)", function () { @@ -2162,6 +2373,22 @@ describe("File", function () { expect(text).to.equal("你好, 世界"); }); + // Adapted from WebKit's fast/files/blob-stream-crash-2.html. + it("streams and slices multiple File parts through the Blob API", async function () { + const file = new File(["a", new Blob(), "b", new Blob(), "c", new Blob(), "d"], "letters.txt"); + const reader = file.stream().getReader(); + const bytes: number[] = []; + while (true) { + const result = await reader.read(); + if (result.done) { + break; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + expect(bytes).to.deep.equal([97, 98, 99, 100]); + expect(await file.slice(1, 3).text()).to.equal("bc"); + }); + // -------------------------------- Blob inheritance -------------------------------- it("is an instance of Blob (prototype chain wired up)", function () { // BJS core (fileTools, Offline/database, abstractEngine, From c3c0a765bce1e98a0d9ed0af0ab23dc1eea7b5c6 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 22:44:34 -0700 Subject: [PATCH 081/174] Add browser-compatible Headers and Response Replace the ad hoc buffered fetch response object with standard-shaped Headers and Response classes backed by ReadableStream bodies. Preserve host constructors, normalize and validate header values, enforce single-use bodies, and expose native responses with one transport-to-JavaScript copy. Reuse normalized header views between mutations, compact header storage in place, retain stream chunks only until consumption, and allocate a contiguous body result at most once when required. Add focused WPT, WebKit, Firefox, and Chromium regression coverage plus JavaScriptCore/QuickJS and initialization tests. --- Polyfills/Fetch/CMakeLists.txt | 17 +- Polyfills/Fetch/Readme.md | 29 +- Polyfills/Fetch/Source/Fetch.cpp | 241 +++------ Polyfills/Fetch/Source/FetchPolyfill.js | 604 +++++++++++++++++++++++ Polyfills/Fetch/Source/FetchScripts.h.in | 8 + Tests/UnitTests/Scripts/tests.ts | 242 +++++++++ Tests/UnitTests/Shared/Shared.cpp | 31 +- 7 files changed, 973 insertions(+), 199 deletions(-) create mode 100644 Polyfills/Fetch/Source/FetchPolyfill.js create mode 100644 Polyfills/Fetch/Source/FetchScripts.h.in diff --git a/Polyfills/Fetch/CMakeLists.txt b/Polyfills/Fetch/CMakeLists.txt index 62b46175..24346db0 100644 --- a/Polyfills/Fetch/CMakeLists.txt +++ b/Polyfills/Fetch/CMakeLists.txt @@ -1,12 +1,25 @@ +set(FETCH_POLYFILL_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Source/FetchPolyfill.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${FETCH_POLYFILL_FILE}") +file(READ "${FETCH_POLYFILL_FILE}" FETCH_POLYFILL_SOURCE) +configure_file( + "Source/FetchScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/FetchScripts.h" + @ONLY) + set(SOURCES "Include/Babylon/Polyfills/Fetch.h" + "Readme.md" "Source/Fetch.h" - "Source/Fetch.cpp") + "Source/Fetch.cpp" + "Source/FetchPolyfill.js" + "Source/FetchScripts.h.in") add_library(Fetch ${SOURCES}) warnings_as_errors(Fetch) -target_include_directories(Fetch PUBLIC "Include") +target_include_directories(Fetch + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") target_link_libraries(Fetch PUBLIC JsRuntime diff --git a/Polyfills/Fetch/Readme.md b/Polyfills/Fetch/Readme.md index 00c41cfc..b3d21a4e 100644 --- a/Polyfills/Fetch/Readme.md +++ b/Polyfills/Fetch/Readme.md @@ -1,5 +1,7 @@ # Fetch -Minimal implementation of the [WHATWG `fetch()`](https://fetch.spec.whatwg.org/) API. Like `XMLHttpRequest`, it is implemented on top of the platform-specific transports in the `UrlLib` dependency, so network behavior (libcurl / WinHTTP / etc.) is identical between the two polyfills. +Implementation of the [WHATWG `fetch()`](https://fetch.spec.whatwg.org/) API. +Like `XMLHttpRequest`, it uses the platform-specific transport from `UrlLib`, so +network behavior is shared between the two polyfills. ```js const response = await fetch("https://example.com/data.json"); @@ -8,16 +10,24 @@ if (response.ok) { } ``` -## Response -`fetch()` returns a `Promise` that resolves to a `Response`-like object exposing: -* `ok`, `status`, `statusText`, `url`, `redirected`, `type`, `bodyUsed` -* `headers` with `get(name)`, `has(name)`, and `forEach(callback)` (header names are matched case-insensitively) -* `text()`, `arrayBuffer()`, `json()`, `blob()` (each returns a `Promise`) -* `clone()` +## Headers and Response +The module installs `Headers` and `Response` when the host does not already +provide them. Response bodies use a `ReadableStream` and follow the browser's +single-consumption behavior through `bodyUsed`. The supported body readers are +`arrayBuffer()`, `blob()`, `bytes()`, `json()`, and `text()`. -The response body is fully buffered before the promise resolves. The body accessors may therefore be called more than once (`bodyUsed` is always reported as `false`), which is a deliberate, lenient deviation from the spec's single-use semantics. +Initialize the Streams, Blob, TextEncoder, TextDecoder, and URL polyfills before +using body-bearing responses on engines that do not provide those globals. -`blob()` requires the `Blob` polyfill to be initialized; otherwise the returned promise rejects. +A completed native response is copied once into JavaScript-owned memory and +exposed as a byte stream. Body readers retain chunk references while consuming +a stream and allocate a contiguous result at most once when that result requires +one. Repeated header iteration reuses a mutation-versioned normalized view, and +header deletion and replacement compact the field list in place. + +The focused conformance tests are adapted from WPT `fetch/api/headers` and +`fetch/api/response`, plus WebKit, Firefox, and Chromium response-body +regressions. ## Local files Like `XMLHttpRequest`, `fetch()` supports loading local resources: @@ -60,4 +70,3 @@ The rejection's `stack` is captured synchronously at the `fetch()` call site (be is handed to a worker thread), so crash reports can attribute the failing call rather than an empty scheduler tick. (Engines that only materialize `.stack` when an error is thrown may omit the frames.) - diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index cf6c171e..5bbf6001 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -1,4 +1,5 @@ #include "Fetch.h" +#include "FetchScripts.h" #include #include @@ -14,22 +15,11 @@ #include #include #include -#include namespace Babylon::Polyfills::Internal { namespace { - // Buffered response payload shared between the Response object and any clones it produces. - struct ResponseData - { - int statusCode{}; - std::string statusText; - std::string url; - std::vector> headers; - std::vector body; - }; - // Shared state for honoring an AbortSignal passed via init.signal. Co-owned by the "abort" // listener (which sets the flag, captures the reason, and cancels the transport) and the // completion continuation (which reports the AbortError and tears the listener down). @@ -153,18 +143,6 @@ namespace Babylon::Polyfills::Internal throw std::runtime_error{"Unsupported fetch method: " + method + " (only GET and POST are supported)"}; } - std::optional FindHeader(const ResponseData& data, std::string_view name) - { - for (const auto& header : data.headers) - { - if (EqualsIgnoreCase(header.first, name)) - { - return header.second; - } - } - return std::nullopt; - } - void ApplyRequestHeaders(UrlLib::UrlRequest& request, const Napi::Value& headers) { if (headers.IsUndefined() || headers.IsNull()) @@ -172,166 +150,36 @@ namespace Babylon::Polyfills::Internal return; } - Napi::Env env = headers.Env(); - - // Array of [name, value] pairs. - if (headers.IsArray()) + const auto env = headers.Env(); + const auto headersConstructor = env.Global().Get("Headers"); + if (headersConstructor.IsUndefined() || headersConstructor.IsNull()) { - const auto array = headers.As(); - for (uint32_t i = 0; i < array.Length(); ++i) - { - const auto pair = array.Get(i); - if (pair.IsArray()) - { - const auto entry = pair.As(); - request.SetRequestHeader(entry.Get(0u).ToString().Utf8Value(), entry.Get(1u).ToString().Utf8Value()); - } - } - return; + throw Napi::TypeError::New(env, "fetch requires Headers to be installed."); } - if (headers.IsObject()) - { - const auto object = headers.As(); - - // Headers / Map instances expose forEach((value, key) => ...). - const auto forEach = object.Get("forEach"); - if (forEach.IsFunction()) + auto normalizedHeaders = headersConstructor.As().New({headers}); + const auto callback = Napi::Function::New(env, [&request](const Napi::CallbackInfo& info) { + if (info.Length() >= 2) { - const auto callback = Napi::Function::New(env, [&request](const Napi::CallbackInfo& info) { - if (info.Length() >= 2) - { - request.SetRequestHeader(info[1].ToString().Utf8Value(), info[0].ToString().Utf8Value()); - } - }); - forEach.As().Call(object, {callback}); - return; - } - - // Plain object of name/value properties. - const auto names = object.GetPropertyNames(); - for (uint32_t i = 0; i < names.Length(); ++i) - { - const auto key = names.Get(i); - request.SetRequestHeader(key.ToString().Utf8Value(), object.Get(key).ToString().Utf8Value()); - } - } - } - - Napi::Object BuildHeaders(Napi::Env env, const std::shared_ptr& data) - { - Napi::Object headers = Napi::Object::New(env); - - headers.Set("get", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto value = FindHeader(*data, info[0].ToString().Utf8Value()); - return value ? Napi::Value{Napi::String::New(env, *value)} : Napi::Value{env.Null()}; - }, "get")); - - headers.Set("has", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - return Napi::Boolean::New(info.Env(), FindHeader(*data, info[0].ToString().Utf8Value()).has_value()); - }, "has")); - - headers.Set("forEach", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto callback = info[0].As(); - const auto thisArg = info.Length() > 1 ? info[1] : env.Undefined(); - for (const auto& header : data->headers) - { - callback.Call(thisArg, {Napi::String::New(env, header.second), Napi::String::New(env, header.first)}); + request.SetRequestHeader(info[1].ToString().Utf8Value(), info[0].ToString().Utf8Value()); } - return env.Undefined(); - }, "forEach")); - - return headers; + }); + normalizedHeaders.Get("forEach").As().Call(normalizedHeaders, {callback}); } - Napi::Object BuildResponse(Napi::Env env, const std::shared_ptr& data) + void InitializeFetchClasses(Napi::Env env) { - Napi::Object response = Napi::Object::New(env); - - const bool ok = data->statusCode >= 200 && data->statusCode < 300; - response.Set("ok", Napi::Boolean::New(env, ok)); - response.Set("status", Napi::Number::New(env, data->statusCode)); - response.Set("statusText", Napi::String::New(env, data->statusText)); - response.Set("url", Napi::String::New(env, data->url)); - response.Set("redirected", Napi::Boolean::New(env, false)); - response.Set("type", Napi::String::New(env, "basic")); - response.Set("bodyUsed", Napi::Boolean::New(env, false)); - response.Set("headers", BuildHeaders(env, data)); - - response.Set("text", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - std::string text{reinterpret_cast(data->body.data()), data->body.size()}; - deferred.Resolve(Napi::String::New(env, text)); - return deferred.Promise(); - }, "text")); - - response.Set("arrayBuffer", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - const auto arrayBuffer = Napi::ArrayBuffer::New(env, data->body.size()); - if (!data->body.empty()) - { - std::memcpy(arrayBuffer.Data(), data->body.data(), data->body.size()); - } - deferred.Resolve(arrayBuffer); - return deferred.Promise(); - }, "arrayBuffer")); - - response.Set("json", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - std::string text{reinterpret_cast(data->body.data()), data->body.size()}; - const auto json = env.Global().Get("JSON").As(); - const auto parse = json.Get("parse").As(); - try - { - deferred.Resolve(parse.Call(json, {Napi::String::New(env, text)})); - } - catch (const Napi::Error& error) - { - deferred.Reject(error.Value()); - } - return deferred.Promise(); - }, "json")); - - response.Set("blob", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - - // Require the Blob polyfill to be installed. - const auto blobConstructor = env.Global().Get("Blob"); - if (!blobConstructor.IsFunction()) - { - deferred.Reject(Napi::Error::New(env, "fetch: Blob is not available in this environment").Value()); - return deferred.Promise(); - } - - const auto arrayBuffer = Napi::ArrayBuffer::New(env, data->body.size()); - if (!data->body.empty()) - { - std::memcpy(arrayBuffer.Data(), data->body.data(), data->body.size()); - } - const auto bytes = Napi::Uint8Array::New(env, data->body.size(), arrayBuffer, 0); - - Napi::Array parts = Napi::Array::New(env, 1); - parts.Set(0u, bytes); - - Napi::Object options = Napi::Object::New(env); - const auto contentType = FindHeader(*data, "content-type"); - options.Set("type", Napi::String::New(env, contentType.value_or(""))); - - deferred.Resolve(blobConstructor.As().New({parts, options})); - return deferred.Promise(); - }, "blob")); - - response.Set("clone", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - return BuildResponse(info.Env(), data); - }, "clone")); - - return response; + auto global = env.Global(); + const auto exports = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js").As(); + if (global.Get("Headers").IsUndefined()) + { + global.Set("Headers", exports.Get("Headers")); + } + if (global.Get("Response").IsUndefined()) + { + global.Set("Response", exports.Get("Response")); + } + JsRuntime::NativeObject::GetFromJavaScript(env).Set("createFetchResponse", exports.Get("createFetchResponse")); } } @@ -340,6 +188,7 @@ namespace Babylon::Polyfills::Internal void Initialize(Napi::Env env) { static constexpr auto JS_FETCH_NAME = "fetch"; + InitializeFetchClasses(env); auto fetchFunction = Napi::Function::New(env, [](const Napi::CallbackInfo& info) -> Napi::Value { Napi::Env env = info.Env(); @@ -487,18 +336,41 @@ namespace Babylon::Polyfills::Internal return; } - auto data = std::make_shared(); - data->statusCode = status; - data->statusText = std::string{request->StatusText()}; - data->url = std::string{request->ResponseUrl()}; + const auto responseBuffer = request->ResponseBuffer(); + auto arrayBuffer = Napi::ArrayBuffer::New(env, responseBuffer.size()); + if (!responseBuffer.empty()) + { + std::memcpy(arrayBuffer.Data(), responseBuffer.data(), responseBuffer.size()); + } + const auto bytes = Napi::Uint8Array::New(env, responseBuffer.size(), arrayBuffer, 0); + + auto responseHeaders = Napi::Array::New(env, request->GetAllResponseHeaders().size()); + uint32_t headerIndex{}; for (const auto& header : request->GetAllResponseHeaders()) { - data->headers.emplace_back(header.first, header.second); + auto pair = Napi::Array::New(env, 2); + pair.Set(uint32_t{0}, Napi::String::New(env, header.first)); + pair.Set(uint32_t{1}, Napi::String::New(env, header.second)); + responseHeaders.Set(headerIndex++, pair); } - const auto responseBuffer = request->ResponseBuffer(); - data->body.assign(responseBuffer.begin(), responseBuffer.end()); - deferred.Resolve(BuildResponse(env, data)); + auto init = Napi::Object::New(env); + init.Set("headers", responseHeaders); + init.Set("status", Napi::Number::New(env, status)); + const auto statusText = request->StatusText(); + init.Set("statusText", Napi::String::New(env, statusText.data(), statusText.size())); + + const std::string responseUrl{request->ResponseUrl()}; + auto metadata = Napi::Object::New(env); + metadata.Set("redirected", Napi::Boolean::New(env, !responseUrl.empty() && responseUrl != url)); + metadata.Set("type", Napi::String::New(env, "basic")); + metadata.Set("url", Napi::String::New(env, responseUrl.empty() ? url : responseUrl)); + + const auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); + const auto createResponse = nativeObject.Get("createFetchResponse").As(); + deferred.Resolve(createResponse.Call( + nativeObject, + {env.Global().Get("Response"), bytes, init, metadata})); }) .then(*scheduler, arcana::cancellation::none(), [deferred, env, scheduler](const arcana::expected& result) { @@ -518,8 +390,7 @@ namespace Babylon::Polyfills::Internal deferred.Reject(Napi::Error::New(env, std::current_exception()).Value()); } - return deferred.Promise(); - }, JS_FETCH_NAME); + return deferred.Promise(); }, JS_FETCH_NAME); if (env.Global().Get(JS_FETCH_NAME).IsUndefined()) { diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js new file mode 100644 index 00000000..93f6811a --- /dev/null +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -0,0 +1,604 @@ +(function(global) { + "use strict"; + + var headerStates = new WeakMap(); + var responseStates = new WeakMap(); + var headerNamePattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; + var nullBodyStatuses = [204, 205, 304]; + + function requireHeaderState(value) { + var state = headerStates.get(value); + if (!state) { + throw new TypeError("Illegal invocation"); + } + return state; + } + + function requireResponseState(value) { + var state = responseStates.get(value); + if (!state) { + throw new TypeError("Illegal invocation"); + } + return state; + } + + function toByteString(value, description) { + var string = String(value); + for (var index = 0; index < string.length; ++index) { + if (string.charCodeAt(index) > 255) { + throw new TypeError(description + " is not a valid ByteString"); + } + } + return string; + } + + function normalizeHeaderName(value) { + var name = toByteString(value, "Header name"); + if (!headerNamePattern.test(name)) { + throw new TypeError("Invalid header name"); + } + return name.toLowerCase(); + } + + function normalizeHeaderValue(value) { + var normalized = toByteString(value, "Header value") + .replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, ""); + if (/[\0\r\n]/.test(normalized)) { + throw new TypeError("Invalid header value"); + } + return normalized; + } + + function isForbiddenResponseHeader(name) { + return name === "set-cookie" || name === "set-cookie2"; + } + + function appendHeader(state, name, value) { + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + state.list.push([name, value]); + state.version++; + } + + function removeHeader(state, name) { + var writeIndex = 0; + var removed = false; + for (var readIndex = 0; readIndex < state.list.length; ++readIndex) { + var entry = state.list[readIndex]; + if (entry[0] === name) { + removed = true; + } else { + state.list[writeIndex++] = entry; + } + } + state.list.length = writeIndex; + return removed; + } + + function fillHeaders(target, init) { + var state = requireHeaderState(target); + if (init === undefined) { + return; + } + if ((typeof init !== "object" && typeof init !== "function") || init === null) { + throw new TypeError("Headers initializer must be an object"); + } + + var iteratorMethod = init[Symbol.iterator]; + if (iteratorMethod !== undefined) { + if (typeof iteratorMethod !== "function") { + throw new TypeError("Headers initializer is not iterable"); + } + for (var entry of init) { + if ((typeof entry !== "object" && typeof entry !== "function") || entry === null) { + throw new TypeError("Each header pair must be iterable"); + } + var pair = Array.from(entry); + if (pair.length !== 2) { + throw new TypeError("Each header pair must contain exactly two items"); + } + appendHeader(state, normalizeHeaderName(pair[0]), normalizeHeaderValue(pair[1])); + } + return; + } + + for (var name of Object.keys(init)) { + appendHeader(state, normalizeHeaderName(name), normalizeHeaderValue(init[name])); + } + } + + function combinedHeaderEntries(state) { + if (state.cacheVersion === state.version) { + return state.cache; + } + var valuesByName = new Map(); + for (var entry of state.list) { + var values = valuesByName.get(entry[0]); + if (!values) { + values = []; + valuesByName.set(entry[0], values); + } + values.push(entry[1]); + } + + var result = []; + var names = Array.from(valuesByName.keys()).sort(); + for (var name of names) { + var values = valuesByName.get(name); + if (name === "set-cookie") { + for (var value of values) { + result.push([name, value]); + } + } else { + result.push([name, values.join(", ")]); + } + } + state.cache = result; + state.cacheVersion = state.version; + return state.cache; + } + + function* iterateHeaders(headers, kind) { + var index = 0; + while (true) { + var entries = combinedHeaderEntries(requireHeaderState(headers)); + if (index >= entries.length) { + return; + } + var entry = entries[index++]; + if (kind === "key") { + yield entry[0]; + } else if (kind === "value") { + yield entry[1]; + } else { + yield [entry[0], entry[1]]; + } + } + } + + class Headers { + constructor(init) { + headerStates.set(this, { + cache: [], + cacheVersion: -1, + guard: "none", + list: [], + version: 0 + }); + fillHeaders(this, init); + } + + append(name, value) { + var state = requireHeaderState(this); + appendHeader(state, normalizeHeaderName(name), normalizeHeaderValue(value)); + } + + delete(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + if (removeHeader(state, name)) { + state.version++; + } + } + + get(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + var value = null; + for (var entry of state.list) { + if (entry[0] === name) { + value = value === null ? entry[1] : value + ", " + entry[1]; + } + } + return value; + } + + getSetCookie() { + var state = requireHeaderState(this); + var values = []; + for (var entry of state.list) { + if (entry[0] === "set-cookie") { + values.push(entry[1]); + } + } + return values; + } + + has(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + return state.list.some(function(entry) { return entry[0] === name; }); + } + + set(name, value) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + value = normalizeHeaderValue(value); + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + removeHeader(state, name); + state.list.push([name, value]); + state.version++; + } + + entries() { + requireHeaderState(this); + return iterateHeaders(this, "entry"); + } + + keys() { + requireHeaderState(this); + return iterateHeaders(this, "key"); + } + + values() { + requireHeaderState(this); + return iterateHeaders(this, "value"); + } + + forEach(callback, thisArg) { + requireHeaderState(this); + if (typeof callback !== "function") { + throw new TypeError("Headers.forEach callback must be a function"); + } + for (var entry of this) { + callback.call(thisArg, entry[1], entry[0], this); + } + } + + [Symbol.iterator]() { + return this.entries(); + } + } + + Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + configurable: true, + value: "Headers" + }); + + function createResponseHeaders(init) { + var headers = new Headers(init); + var state = requireHeaderState(headers); + state.guard = "response"; + var removedForbidden = removeHeader(state, "set-cookie"); + removedForbidden = removeHeader(state, "set-cookie2") || removedForbidden; + if (removedForbidden) { + state.version++; + } + return headers; + } + + function isReadableStream(value) { + return global.ReadableStream !== undefined && global.ReadableStream !== null && + value instanceof global.ReadableStream; + } + + function streamFromBytes(bytes) { + var chunk = bytes; + return new global.ReadableStream({ + type: "bytes", + pull: function(controller) { + if (chunk !== null) { + var value = chunk; + chunk = null; + controller.enqueue(value); + } + controller.close(); + }, + cancel: function() { + chunk = null; + } + }); + } + + function copyBufferSource(value) { + var source; + if (value instanceof ArrayBuffer) { + source = new Uint8Array(value); + } else { + source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + } + var copy = new Uint8Array(source.byteLength); + copy.set(source); + return copy; + } + + function extractBody(body) { + if (body === null || body === undefined) { + return { stream: null, contentType: null }; + } + if (isReadableStream(body)) { + if (body.locked || body._disturbed) { + throw new TypeError("Response body stream is already disturbed or locked"); + } + return { stream: body, contentType: null }; + } + if (global.Blob !== undefined && global.Blob !== null && body instanceof global.Blob) { + return { stream: body.stream(), contentType: body.type || null }; + } + if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) { + return { stream: streamFromBytes(copyBufferSource(body)), contentType: null }; + } + if (global.URLSearchParams !== undefined && global.URLSearchParams !== null && body instanceof global.URLSearchParams) { + return { + stream: streamFromBytes(new global.TextEncoder().encode(body.toString())), + contentType: "application/x-www-form-urlencoded;charset=UTF-8" + }; + } + if (global.FormData !== undefined && global.FormData !== null && body instanceof global.FormData) { + throw new TypeError("FormData response bodies are not supported by this runtime"); + } + + return { + stream: streamFromBytes(new global.TextEncoder().encode(String(body))), + contentType: "text/plain;charset=UTF-8" + }; + } + + function bodyIsUnusable(state) { + return state.used || (state.body !== null && (state.body.locked || state.body._disturbed)); + } + + async function readBodyChunks(state) { + if (state.body === null) { + return [[], 0]; + } + if (bodyIsUnusable(state)) { + throw new TypeError("Response body is already used"); + } + + state.used = true; + var chunks = []; + var total = 0; + var reader = state.body.getReader(); + while (true) { + var result = await reader.read(); + if (result.done) { + return [chunks, total]; + } + if (!(result.value instanceof Uint8Array)) { + throw new TypeError("Response body stream yielded a non-Uint8Array chunk"); + } + if (result.value.byteLength === 0) { + continue; + } + if (total > Number.MAX_SAFE_INTEGER - result.value.byteLength) { + throw new RangeError("Response body is too large"); + } + chunks.push(result.value); + total += result.value.byteLength; + } + } + + function joinChunks(chunksAndTotal) { + var chunks = chunksAndTotal[0]; + var total = chunksAndTotal[1]; + if (chunks.length === 0) { + return new Uint8Array(0); + } + if (chunks.length === 1) { + return chunks[0]; + } + + var bytes = new Uint8Array(total); + var offset = 0; + for (var chunk of chunks) { + bytes.set(chunk, offset); + offset += chunk.byteLength; + } + return bytes; + } + + async function consumeText(state) { + if (state.body === null) { + return ""; + } + if (bodyIsUnusable(state)) { + throw new TypeError("Response body is already used"); + } + + state.used = true; + var decoder = new global.TextDecoder(); + var pieces = []; + var reader = state.body.getReader(); + while (true) { + var result = await reader.read(); + if (result.done) { + pieces.push(decoder.decode()); + return pieces.join(""); + } + if (!(result.value instanceof Uint8Array)) { + throw new TypeError("Response body stream yielded a non-Uint8Array chunk"); + } + if (result.value.byteLength !== 0) { + pieces.push(decoder.decode(result.value, { stream: true })); + } + } + } + + function validateResponseInit(init) { + if (init === undefined || init === null) { + init = {}; + } else if (typeof init !== "object" && typeof init !== "function") { + throw new TypeError("Response init must be an object"); + } + + var status = init.status === undefined ? 200 : Math.trunc(Number(init.status)); + if (!Number.isFinite(status) || status < 200 || status > 599) { + throw new RangeError("Response status must be between 200 and 599"); + } + var statusText = init.statusText === undefined ? "" : + toByteString(init.statusText, "Response statusText"); + if (/[\r\n]/.test(statusText)) { + throw new TypeError("Invalid Response statusText"); + } + return { + headers: createResponseHeaders(init.headers), + status: status, + statusText: statusText + }; + } + + function initializeResponse(response, body, init, metadata) { + var normalizedInit = validateResponseInit(init); + var extracted = extractBody(body); + if (extracted.stream !== null && nullBodyStatuses.indexOf(normalizedInit.status) !== -1) { + throw new TypeError("Response with this status cannot have a body"); + } + if (extracted.contentType !== null && !normalizedInit.headers.has("content-type")) { + normalizedInit.headers.append("content-type", extracted.contentType); + } + + responseStates.set(response, { + body: extracted.stream, + headers: normalizedInit.headers, + redirected: metadata && metadata.redirected === true, + status: normalizedInit.status, + statusText: normalizedInit.statusText, + type: metadata && metadata.type ? String(metadata.type) : "default", + url: metadata && metadata.url ? String(metadata.url) : "", + used: false + }); + } + + class Response { + constructor(body, init) { + initializeResponse(this, body === undefined ? null : body, init, null); + } + + get body() { return requireResponseState(this).body; } + get bodyUsed() { + var state = requireResponseState(this); + return state.used || (state.body !== null && state.body._disturbed === true); + } + get headers() { return requireResponseState(this).headers; } + get ok() { + var status = requireResponseState(this).status; + return status >= 200 && status <= 299; + } + get redirected() { return requireResponseState(this).redirected; } + get status() { return requireResponseState(this).status; } + get statusText() { return requireResponseState(this).statusText; } + get type() { return requireResponseState(this).type; } + get url() { return requireResponseState(this).url; } + + async arrayBuffer() { + var bytes = joinChunks(await readBodyChunks(requireResponseState(this))); + if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) { + return bytes.buffer; + } + return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength); + } + + async blob() { + var state = requireResponseState(this); + var bytes = joinChunks(await readBodyChunks(state)); + return new global.Blob([bytes], { type: state.headers.get("content-type") || "" }); + } + + async bytes() { + return joinChunks(await readBodyChunks(requireResponseState(this))); + } + + clone() { + var state = requireResponseState(this); + if (bodyIsUnusable(state)) { + throw new TypeError("Cannot clone a used Response"); + } + + var cloneBody = null; + if (state.body !== null) { + var branches = state.body.tee(); + state.body = branches[0]; + cloneBody = branches[1]; + } + var clone = new Response(cloneBody, { + headers: state.headers, + status: state.status, + statusText: state.statusText + }); + var cloneState = requireResponseState(clone); + cloneState.redirected = state.redirected; + cloneState.type = state.type; + cloneState.url = state.url; + return clone; + } + + async json() { + return JSON.parse(await consumeText(requireResponseState(this))); + } + + async text() { + return consumeText(requireResponseState(this)); + } + + static error() { + var response = Object.create(Response.prototype); + responseStates.set(response, { + body: null, + headers: createResponseHeaders(), + redirected: false, + status: 0, + statusText: "", + type: "error", + url: "", + used: false + }); + return response; + } + + static json(data, init) { + var text = JSON.stringify(data); + if (text === undefined) { + throw new TypeError("Response.json data is not JSON serializable"); + } + var hasExplicitContentType = init !== undefined && init !== null && + new Headers(init.headers).has("content-type"); + var response = new Response(text, init); + if (!hasExplicitContentType) { + response.headers.set("content-type", "application/json"); + } + return response; + } + + static redirect(url, status) { + status = status === undefined ? 302 : Math.trunc(Number(status)); + if ([301, 302, 303, 307, 308].indexOf(status) === -1) { + throw new RangeError("Invalid redirect status"); + } + var location = global.URL !== undefined && global.URL !== null + ? new global.URL(String(url), global.location && global.location.href || undefined).toString() + : String(url); + return new Response(null, { status: status, headers: { location: location } }); + } + } + + Object.defineProperty(Response.prototype, Symbol.toStringTag, { + configurable: true, + value: "Response" + }); + + function createFetchResponse(ResponseConstructor, bytes, init, metadata) { + var status = init && init.status; + var body = nullBodyStatuses.indexOf(status) === -1 ? streamFromBytes(bytes) : null; + var response = new ResponseConstructor(body, init); + var state = responseStates.get(response); + if (state) { + state.redirected = metadata.redirected === true; + state.type = metadata.type || "basic"; + state.url = metadata.url || ""; + } + return response; + } + + return { + Headers: Headers, + Response: Response, + createFetchResponse: createFetchResponse + }; +})(globalThis) diff --git a/Polyfills/Fetch/Source/FetchScripts.h.in b/Polyfills/Fetch/Source/FetchScripts.h.in new file mode 100644 index 00000000..8cc0e511 --- /dev/null +++ b/Polyfills/Fetch/Source/FetchScripts.h.in @@ -0,0 +1,8 @@ +#pragma once + +namespace Babylon::Polyfills::Internal::FetchScripts +{ + inline constexpr char Polyfill[] = R"JSRHFETCH( +@FETCH_POLYFILL_SOURCE@ +)JSRHFETCH"; +} diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 122cc1b2..1eca74f0 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -302,11 +302,253 @@ describe("XMLHTTPRequest", function () { }); }); +describe("Headers", function () { + // Focused ports from WPT fetch/api/headers. + it("normalizes names and values and combines repeated fields", function () { + const headers = new Headers([ + ["X-Test", " first\t"], + ["x-test", "second"], + ["X-Other", "\r\n value \n"] + ]); + expect(headers.get("X-TEST")).to.equal("first, second"); + expect(headers.get("x-other")).to.equal("value"); + expect(Array.from(headers.keys())).to.deep.equal(["x-other", "x-test"]); + }); + + it("validates sequence shape and HTTP ByteStrings", function () { + expect(() => new Headers(null as any)).to.throw(); + expect(() => new Headers([["missing-value"]] as any)).to.throw(); + expect(() => new Headers([["too", "many", "values"]] as any)).to.throw(); + expect(() => new Headers([["invalid name", "value"]])).to.throw(); + expect(() => new Headers([["valid", "a\0b"]])).to.throw(); + expect(() => new Headers([["invalidĀ", "value"]])).to.throw(); + }); + + it("preserves Set-Cookie fields while combining other duplicates", function () { + const headers = new Headers([ + ["set-cookie", "a=1"], + ["x-value", "first"], + ["Set-Cookie", "b=2"], + ["X-Value", "second"] + ]); + expect(headers.getSetCookie()).to.deep.equal(["a=1", "b=2"]); + expect(Array.from(headers)).to.deep.equal([ + ["set-cookie", "a=1"], + ["set-cookie", "b=2"], + ["x-value", "first, second"] + ]); + }); + + it("keeps iteration live when headers are changed", function () { + const headers = new Headers({ bar: "0", baz: "1", foo: "2" }); + const seen: string[] = []; + for (const [name] of headers) { + seen.push(name); + headers.delete("foo"); + } + expect(seen).to.deep.equal(["bar", "baz"]); + }); + + it("copies an initializer and honors a custom iterator", function () { + const source = new Headers({ ignored: "value" }); + source[Symbol.iterator] = function* () { + yield ["custom", "value"]; + }; + const copy = new Headers(source); + source.set("custom", "changed"); + expect(Array.from(copy)).to.deep.equal([["custom", "value"]]); + }); +}); + +describe("Response", function () { + // Focused ports from WPT fetch/api/response. + it("exposes browser defaults and validates response metadata", function () { + const response = new Response(); + expect(String(response)).to.equal("[object Response]"); + expect(response.status).to.equal(200); + expect(response.statusText).to.equal(""); + expect(response.ok).to.equal(true); + expect(response.type).to.equal("default"); + expect(response.url).to.equal(""); + expect(response.body).to.equal(null); + expect(response.headers).to.equal(response.headers); + + expect(() => new Response("", { status: 199 })).to.throw(RangeError); + expect(() => new Response("", { status: 600 })).to.throw(RangeError); + expect(() => new Response("", { statusText: "bad\ntext" })).to.throw(TypeError); + expect(() => new Response("body", { status: 204 })).to.throw(TypeError); + }); + + it("streams strings and consumes a body only once", async function () { + const response = new Response("streamed text"); + expect(response.body).to.be.instanceOf(ReadableStream); + expect(response.bodyUsed).to.equal(false); + expect(await response.text()).to.equal("streamed text"); + expect(response.bodyUsed).to.equal(true); + + let rejected = false; + try { + await response.arrayBuffer(); + } catch (error) { + rejected = error instanceof TypeError; + } + expect(rejected).to.equal(true); + }); + + // Ported from WPT fetch/api/response/response-consume-empty.any.js. + it("consumes a null body as empty without disturbing it", async function () { + const textResponse = new Response(); + expect(await textResponse.text()).to.equal(""); + expect(textResponse.bodyUsed).to.equal(false); + + const bufferResponse = new Response(); + expect((await bufferResponse.arrayBuffer()).byteLength).to.equal(0); + expect(bufferResponse.bodyUsed).to.equal(false); + + const bytesResponse = new Response(); + expect((await bytesResponse.bytes()).byteLength).to.equal(0); + expect(bytesResponse.bodyUsed).to.equal(false); + + const blobResponse = new Response(); + expect((await blobResponse.blob()).size).to.equal(0); + expect(blobResponse.bodyUsed).to.equal(false); + + const jsonResponse = new Response(); + let jsonRejected = false; + try { + await jsonResponse.json(); + } catch { + jsonRejected = true; + } + expect(jsonRejected).to.equal(true); + expect(jsonResponse.bodyUsed).to.equal(false); + }); + + it("snapshots mutable BufferSource input once", async function () { + const input = new Uint8Array([80, 65, 83, 83]); + const response = new Response(input); + input.fill(0); + expect(await response.text()).to.equal("PASS"); + }); + + // Adapted from WebKit LayoutTests/fetch/body-init.html. + it("stringifies integer and object bodies", async function () { + expect(await new Response(1 as any).text()).to.equal("1"); + expect(await new Response({} as any).text()).to.equal("[object Object]"); + }); + + it("sets inferred content types without replacing explicit headers", async function () { + const text = new Response("text"); + expect(text.headers.get("content-type")).to.equal("text/plain;charset=UTF-8"); + + const blob = new Response(new Blob(["blob"], { type: "application/example" })); + expect(blob.headers.get("content-type")).to.equal("application/example"); + + const explicit = new Response("text", { headers: { "content-type": "text/custom" } }); + expect(explicit.headers.get("content-type")).to.equal("text/custom"); + }); + + it("clones stream branches for independent consumption", async function () { + const response = new Response("clone body", { + headers: { "x-test": "value" }, + status: 201, + statusText: "Created" + }); + const clone = response.clone(); + expect(clone.status).to.equal(201); + expect(clone.headers.get("x-test")).to.equal("value"); + expect(await response.text()).to.equal("clone body"); + expect(await clone.text()).to.equal("clone body"); + }); + + it("tracks direct stream reads and rejects invalid body chunks", async function () { + const direct = new Response("body"); + const reader = direct.body!.getReader(); + expect(direct.bodyUsed).to.equal(false); + await reader.read(); + expect(direct.bodyUsed).to.equal(true); + + const invalid = new Response(new ReadableStream({ + start(controller) { + controller.enqueue("not bytes"); + controller.close(); + } + }) as any); + let rejected = false; + try { + await invalid.bytes(); + } catch (error) { + rejected = error instanceof TypeError; + } + expect(rejected).to.equal(true); + }); + + // Adapted from Firefox dom/fetch/tests/crashtests/1939295.html. The + // unresolved read must remain safe through runtime teardown. + it("does not crash while consuming an open empty stream", function () { + const pending = new Response(new ReadableStream()).text(); + expect(pending).to.be.instanceOf(Promise); + }); + + // Adapted from WebKit's imported many-empty-chunks-crash.html. + it("consumes many empty chunks without retaining growing byte buffers", async function () { + const response = new Response(new ReadableStream({ + start(controller) { + for (let index = 0; index < 40000; ++index) { + controller.enqueue(new Uint8Array()); + } + controller.close(); + } + })); + expect((await response.arrayBuffer()).byteLength).to.equal(0); + }); + + // Bounded adaptation of Chromium's call-extra-crash-is-disturbed.html. + // QuickJS terminates before a JS-defined getter can run after a real + // native stack overflow, so retain the deep-call regression portably. + it("reads bodyUsed from a deep call stack without recursion", function () { + const response = new Response(new ReadableStream()); + function readAtDepth(depth: number): boolean { + return depth === 0 ? response.bodyUsed : readAtDepth(depth - 1); + } + expect(readAtDepth(128)).to.equal(false); + }); + + it("provides error, redirect, and JSON factories", async function () { + const error = Response.error(); + expect(error.type).to.equal("error"); + expect(error.status).to.equal(0); + + const redirect = Response.redirect("https://example.com/path", 307); + expect(redirect.status).to.equal(307); + expect(redirect.headers.get("location")).to.equal("https://example.com/path"); + + const json = Response.json({ value: 42 }); + expect(json.headers.get("content-type")).to.equal("application/json"); + expect(await json.json()).to.deep.equal({ value: 42 }); + }); + + it("filters forbidden response Set-Cookie fields", function () { + const response = new Response(null, { + headers: { + "set-cookie": "secret=value", + "set-cookie2": "legacy=value" + } + }); + response.headers.append("Set-Cookie", "other=value"); + expect(response.headers.getSetCookie()).to.deep.equal([]); + expect(response.headers.has("set-cookie2")).to.equal(false); + }); +}); + describe("fetch", function () { this.timeout(30000); it("should resolve with ok=true and status=200 for a resource that exists", async function () { const response = await fetch("https://github.com/"); + expect(response).to.be.instanceOf(Response); + expect(response.headers).to.be.instanceOf(Headers); + expect(response.body).to.be.instanceOf(ReadableStream); expect(response.ok).to.equal(true); expect(response.status).to.equal(200); }); diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index b71218bd..3b78d2fb 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -86,12 +86,12 @@ TEST(JavaScript, All) Babylon::Polyfills::URL::Initialize(env); Babylon::Polyfills::WebSocket::Initialize(env); Babylon::Polyfills::XMLHttpRequest::Initialize(env); - Babylon::Polyfills::Fetch::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); Babylon::Polyfills::Blob::Initialize(env); Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); - Babylon::Polyfills::Streams::Initialize(env); + Babylon::Polyfills::Fetch::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -192,6 +192,33 @@ TEST(Streams, PreservesHostConstructorsAndIsIdempotent) done.get_future().get(); } +TEST(Fetch, PreservesHostClassesAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); + const auto hostResponse = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostResponse"); + global.Set("Headers", hostHeaders); + global.Set("Response", hostResponse); + + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); + + const auto installedFetch = global.Get("fetch"); + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); + EXPECT_TRUE(global.Get("fetch").StrictEquals(installedFetch)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 8cd66a676df35d719d85ee160e1cb4e983e20286 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 23:28:31 -0700 Subject: [PATCH 082/174] Handle empty Response byte bodies Close byte streams for zero-length BufferSource bodies without enqueueing an invalid empty chunk. Preserve the non-null body and bodyUsed semantics, and add focused regression coverage alongside the WPT empty-response cases. --- Polyfills/Fetch/Source/FetchPolyfill.js | 4 +++- Tests/UnitTests/Scripts/tests.ts | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js index 93f6811a..e41ee182 100644 --- a/Polyfills/Fetch/Source/FetchPolyfill.js +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -286,7 +286,9 @@ if (chunk !== null) { var value = chunk; chunk = null; - controller.enqueue(value); + if (value.byteLength !== 0) { + controller.enqueue(value); + } } controller.close(); }, diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 1eca74f0..17a99a6d 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -424,6 +424,16 @@ describe("Response", function () { expect(jsonResponse.bodyUsed).to.equal(false); }); + // Byte streams reject zero-length enqueues. An empty BufferSource still + // represents a non-null body, but its stream must close without a chunk. + it("consumes an empty BufferSource without enqueueing an empty byte chunk", async function () { + const response = new Response(new Uint8Array(0)); + expect(response.body).to.be.instanceOf(ReadableStream); + expect(response.bodyUsed).to.equal(false); + expect(new Uint8Array(await response.arrayBuffer())).to.eql(new Uint8Array(0)); + expect(response.bodyUsed).to.equal(true); + }); + it("snapshots mutable BufferSource input once", async function () { const input = new Uint8Array([80, 65, 83, 83]); const response = new Response(input); From ac0294112d3e65ab5b4cac9798f79e9f148eae3a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:26:50 -0700 Subject: [PATCH 083/174] Keep Streams implementations internally consistent Replace a partial or null host Streams surface as a complete constructor suite so stream products retain compatible instanceof relationships. Preserve a complete suite on repeated initialization.\n\nHarden the native initialization test so N-API failures complete the test promise instead of hanging, and cover partial host replacement plus null handling and cross-constructor compatibility. --- Polyfills/Streams/Source/Streams.cpp | 8 ++---- Tests/UnitTests/Shared/Shared.cpp | 42 +++++++++++++++++++++------- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp index 4552ed07..e742344f 100644 --- a/Polyfills/Streams/Source/Streams.cpp +++ b/Polyfills/Streams/Source/Streams.cpp @@ -31,7 +31,8 @@ namespace Babylon::Polyfills::Streams bool needsPonyfill{}; for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) + const auto constructor = global.Get(name.data()); + if (constructor.IsUndefined() || constructor.IsNull()) { needsPonyfill = true; break; @@ -46,10 +47,7 @@ namespace Babylon::Polyfills::Streams const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) - { - global.Set(name.data(), exports.Get(name.data())); - } + global.Set(name.data(), exports.Get(name.data())); } } } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 3b78d2fb..e60e7b70 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -168,28 +168,50 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } -TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; - runtime.Dispatch([&done](Napi::Env env) { + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); global.Set("ReadableStream", hostReadableStream); + global.Set("TransformStream", env.Null()); Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); - EXPECT_TRUE(global.Get("TransformStream").IsFunction()); - + const auto installedReadableStream = global.Get("ReadableStream"); const auto installedTransformStream = global.Get("TransformStream"); + EXPECT_FALSE(installedReadableStream.StrictEquals(hostReadableStream)); + if (!installedReadableStream.IsFunction() || !installedTransformStream.IsFunction()) + { + complete("Streams::Initialize did not install a complete constructor suite."); + return; + } + + const auto transform = installedTransformStream.As().New({}); + EXPECT_TRUE(transform.Get("readable").As().InstanceOf(installedReadableStream.As())); + Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(installedReadableStream)); EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Fetch, PreservesHostClassesAndIsIdempotent) From 35d5a9fcb418062359b04478e14ae9d8d59b9837 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:39:52 -0700 Subject: [PATCH 084/174] Track Response body disturbance through stream operations Observe standard ReadableStream consumption paths with weak per-stream state instead of depending on web-streams-polyfill's private _disturbed field. Instrument stream readers and piping once during Fetch initialization, preserve stream identity, and cache the initialized Fetch implementation so repeated initialization does not stack wrappers or replace its internal state. Treat Headers and Response as an implementation pair when either host global is missing or null. Harden native initialization tests against unhandled N-API failures and add WPT-derived coverage for reads, cancellation, piping, and streams disturbed before Response construction. --- Polyfills/Fetch/Source/Fetch.cpp | 17 ++-- Polyfills/Fetch/Source/FetchPolyfill.js | 104 +++++++++++++++++++++++- Tests/UnitTests/Scripts/tests.ts | 60 +++++++++++++- Tests/UnitTests/Shared/Shared.cpp | 71 ++++++++++++++-- 4 files changed, 237 insertions(+), 15 deletions(-) diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index 5bbf6001..393bf1f9 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -57,6 +57,7 @@ namespace Babylon::Polyfills::Internal // this constant (the variable detail rides on `cause`) so crash-report grouping stays // intact; we follow Node/undici's "fetch failed" spelling. constexpr const char* FETCH_FAILED_MESSAGE = "fetch failed"; + constexpr const char* JS_FETCH_POLYFILL_EXPORTS_NAME = "fetchPolyfillExports"; // Snapshot the JS call-site stack synchronously, inside fetch(), before SendAsync() hands // the request to a worker thread. The transport-failure rejection is otherwise built in a @@ -170,16 +171,22 @@ namespace Babylon::Polyfills::Internal void InitializeFetchClasses(Napi::Env env) { auto global = env.Global(); - const auto exports = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js").As(); - if (global.Get("Headers").IsUndefined()) + auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); + auto exportsValue = nativeObject.Get(JS_FETCH_POLYFILL_EXPORTS_NAME); + if (exportsValue.IsUndefined() || exportsValue.IsNull()) { - global.Set("Headers", exports.Get("Headers")); + exportsValue = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js"); + nativeObject.Set(JS_FETCH_POLYFILL_EXPORTS_NAME, exportsValue); } - if (global.Get("Response").IsUndefined()) + const auto exports = exportsValue.As(); + const auto headers = global.Get("Headers"); + const auto response = global.Get("Response"); + if (headers.IsUndefined() || headers.IsNull() || response.IsUndefined() || response.IsNull()) { + global.Set("Headers", exports.Get("Headers")); global.Set("Response", exports.Get("Response")); } - JsRuntime::NativeObject::GetFromJavaScript(env).Set("createFetchResponse", exports.Get("createFetchResponse")); + nativeObject.Set("createFetchResponse", exports.Get("createFetchResponse")); } } diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js index e41ee182..4435d1ef 100644 --- a/Polyfills/Fetch/Source/FetchPolyfill.js +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -3,9 +3,105 @@ var headerStates = new WeakMap(); var responseStates = new WeakMap(); + var streamTrackers = new WeakMap(); + var readerTrackers = new WeakMap(); + var iteratorTrackers = new WeakMap(); var headerNamePattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; var nullBodyStatuses = [204, 205, 304]; + function wrapMethod(target, name, createWrapper) { + var descriptor = Object.getOwnPropertyDescriptor(target, name); + var original = descriptor ? descriptor.value : target[name]; + if (typeof original !== "function") { + return; + } + if (!descriptor) { + descriptor = { + configurable: true, + enumerable: false, + writable: true + }; + } + descriptor.value = createWrapper(original); + Object.defineProperty(target, name, descriptor); + } + + function trackStream(stream) { + var tracker = streamTrackers.get(stream); + if (!tracker) { + tracker = { disturbed: false }; + streamTrackers.set(stream, tracker); + } + return tracker; + } + + function trackReader(reader, tracker) { + if (readerTrackers.has(reader)) { + return reader; + } + readerTrackers.set(reader, tracker); + for (var name of ["read", "cancel"]) { + wrapMethod(reader, name, function(original) { + return function() { + tracker.disturbed = true; + return original.apply(this, arguments); + }; + }); + } + return reader; + } + + function trackIterator(iterator, tracker) { + if (iteratorTrackers.has(iterator)) { + return iterator; + } + iteratorTrackers.set(iterator, tracker); + for (var name of ["next", "return", "throw"]) { + wrapMethod(iterator, name, function(original) { + return function() { + tracker.disturbed = true; + return original.apply(this, arguments); + }; + }); + } + return iterator; + } + + function instrumentReadableStreams() { + if (global.ReadableStream === undefined || global.ReadableStream === null) { + return; + } + var prototype = global.ReadableStream.prototype; + wrapMethod(prototype, "getReader", function(original) { + return function() { + return trackReader(original.apply(this, arguments), trackStream(this)); + }; + }); + for (var name of ["cancel", "pipeTo", "pipeThrough", "tee"]) { + wrapMethod(prototype, name, function(original) { + return function() { + var result = original.apply(this, arguments); + trackStream(this).disturbed = true; + return result; + }; + }); + } + wrapMethod(prototype, "values", function(original) { + return function() { + return trackIterator(original.apply(this, arguments), trackStream(this)); + }; + }); + if (typeof Symbol.asyncIterator === "symbol") { + wrapMethod(prototype, Symbol.asyncIterator, function(original) { + return function() { + return trackIterator(original.apply(this, arguments), trackStream(this)); + }; + }); + } + } + + instrumentReadableStreams(); + function requireHeaderState(value) { var state = headerStates.get(value); if (!state) { @@ -315,7 +411,7 @@ return { stream: null, contentType: null }; } if (isReadableStream(body)) { - if (body.locked || body._disturbed) { + if (body.locked || trackStream(body).disturbed) { throw new TypeError("Response body stream is already disturbed or locked"); } return { stream: body, contentType: null }; @@ -343,7 +439,7 @@ } function bodyIsUnusable(state) { - return state.used || (state.body !== null && (state.body.locked || state.body._disturbed)); + return state.used || (state.body !== null && (state.body.locked || state.bodyTracker.disturbed)); } async function readBodyChunks(state) { @@ -458,6 +554,7 @@ responseStates.set(response, { body: extracted.stream, + bodyTracker: extracted.stream === null ? null : trackStream(extracted.stream), headers: normalizedInit.headers, redirected: metadata && metadata.redirected === true, status: normalizedInit.status, @@ -476,7 +573,7 @@ get body() { return requireResponseState(this).body; } get bodyUsed() { var state = requireResponseState(this); - return state.used || (state.body !== null && state.body._disturbed === true); + return state.used || (state.body !== null && state.bodyTracker.disturbed); } get headers() { return requireResponseState(this).headers; } get ok() { @@ -517,6 +614,7 @@ if (state.body !== null) { var branches = state.body.tee(); state.body = branches[0]; + state.bodyTracker = trackStream(state.body); cloneBody = branches[1]; } var clone = new Response(cloneBody, { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 17a99a6d..c2edb26e 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -471,8 +471,23 @@ describe("Response", function () { expect(await clone.text()).to.equal("clone body"); }); + function withoutPrivateDisturbedState(stream: ReadableStream): ReadableStream { + Object.defineProperty(stream, "_disturbed", { + configurable: true, + get() { return undefined; }, + set() {} + }); + return stream; + } + it("tracks direct stream reads and rejects invalid body chunks", async function () { - const direct = new Response("body"); + const directStream = withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.enqueue(new TextEncoder().encode("body")); + controller.close(); + } + })); + const direct = new Response(directStream); const reader = direct.body!.getReader(); expect(direct.bodyUsed).to.equal(false); await reader.read(); @@ -493,6 +508,49 @@ describe("Response", function () { expect(rejected).to.equal(true); }); + it("rejects a host-shaped stream disturbed before Response construction", async function () { + const stream = withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.enqueue(new Uint8Array([1])); + controller.close(); + } + })); + const reader = stream.getReader(); + await reader.read(); + reader.releaseLock(); + + expect(() => new Response(stream)).to.throw(TypeError); + }); + + // Focused ports from WPT response-stream-disturbed-6.any.js and + // response-stream-disturbed-by-pipe.any.js. These must not depend on a + // private field supplied by one particular Streams implementation. + it("tracks cancellation and piping through standard stream methods", async function () { + const cancelled = new Response(withoutPrivateDisturbedState(new ReadableStream())); + const cancelledReader = cancelled.body!.getReader(); + expect(cancelled.bodyUsed).to.equal(false); + await cancelledReader.cancel(); + expect(cancelled.bodyUsed).to.equal(true); + + const piped = new Response(withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.close(); + } + }))); + const pipePromise = piped.body!.pipeTo(new WritableStream({}, { highWaterMark: 0 })); + expect(piped.bodyUsed).to.equal(true); + await pipePromise; + + const pipedThrough = new Response(withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.close(); + } + }))); + const output = pipedThrough.body!.pipeThrough(new TransformStream()); + expect(pipedThrough.bodyUsed).to.equal(true); + await output.cancel(); + }); + // Adapted from Firefox dom/fetch/tests/crashtests/1939295.html. The // unresolved read must remain safe through runtime teardown. it("does not crash while consuming an open empty stream", function () { diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index e60e7b70..b646144f 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -214,12 +214,24 @@ TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) EXPECT_TRUE(error.empty()) << error; } -TEST(Fetch, PreservesHostClassesAndIsIdempotent) +TEST(Fetch, PreservesCompleteHostClassesAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; - runtime.Dispatch([&done](Napi::Env env) { + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); const auto hostResponse = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostResponse"); @@ -235,10 +247,57 @@ TEST(Fetch, PreservesHostClassesAndIsIdempotent) EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); EXPECT_TRUE(global.Get("fetch").StrictEquals(installedFetch)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; +} + +TEST(Fetch, ReplacesPartialOrNullHostClassesAsACompletePair) +{ + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; + + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { + auto global = env.Global(); + const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); + global.Set("Headers", hostHeaders); + global.Set("Response", env.Null()); + + Babylon::Polyfills::Fetch::Initialize(env); + const auto installedHeaders = global.Get("Headers"); + const auto installedResponse = global.Get("Response"); + EXPECT_FALSE(installedHeaders.StrictEquals(hostHeaders)); + if (!installedHeaders.IsFunction() || !installedResponse.IsFunction()) + { + complete("Fetch::Initialize did not install a complete Headers/Response pair."); + return; + } + + const auto response = installedResponse.As().New({}); + EXPECT_TRUE(response.Get("headers").As().InstanceOf(installedHeaders.As())); + + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(installedHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(installedResponse)); + complete({}); + }); + + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Console, Log) From c83873322b8a6c5d15369f37c8d6e752bb990ad0 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:29:36 -0700 Subject: [PATCH 085/174] Write Blob BYOB reads into caller buffers Use ReadableByteStreamController.byobRequest views directly and respond with the produced byte count instead of allocating and enqueueing a 64 KiB intermediate chunk. Keep the existing bounded allocation path for default readers.\n\nAdd WPT-derived coverage for small offset BYOB views that cross immutable Blob segment boundaries. --- Polyfills/Blob/Source/Blob.cpp | 69 +++++++++++++++++++++----------- Tests/UnitTests/Scripts/tests.ts | 27 +++++++++++++ 2 files changed, 73 insertions(+), 23 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index bed99cb6..635bb7e1 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -310,33 +310,56 @@ namespace Babylon::Polyfills::Internal } constexpr size_t CHUNK_SIZE = 64 * 1024; - const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); - auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); - auto destination = static_cast(outputBuffer.Data()); - auto segmentIndex = state->SegmentIndex; - auto segmentOffset = state->SegmentOffset; - size_t remaining = outputLength; - - while (remaining > 0) + const auto copyInto = [&state](std::byte* destination, size_t outputLength) { + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + }; + + const auto byobRequestValue = controller.Get("byobRequest"); + if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) { - const auto& segment = state->BlobData->Segments[segmentIndex]; - const auto copyLength = std::min(segment.Length - segmentOffset, remaining); - std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); - destination += copyLength; - remaining -= copyLength; - segmentOffset += copyLength; - if (segmentOffset == segment.Length) + const auto byobRequest = byobRequestValue.As(); + const auto viewValue = byobRequest.Get("view"); + if (!viewValue.IsTypedArray()) { - ++segmentIndex; - segmentOffset = 0; + throw Napi::TypeError::New(callbackEnv, "Blob.stream() received an invalid BYOB request view."); } - } - auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); - controller.Get("enqueue").As().Call(controller, {output}); - state->Position += outputLength; - state->SegmentIndex = segmentIndex; - state->SegmentOffset = segmentOffset; + const auto view = viewValue.As(); + const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); + const auto outputBuffer = view.ArrayBuffer(); + auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); + copyInto(destination, outputLength); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); + } + else + { + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + copyInto(static_cast(outputBuffer.Data()), outputLength); + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + } if (state->Position == state->BlobData->Size) { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index c2edb26e..ffab392b 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -2274,6 +2274,33 @@ describe("Blob", function () { expect(await readStream(new Blob().stream())).to.deep.equal([]); }); + // Adapted from WPT streams/readable-byte-streams/general.any.js BYOB + // coverage. Small, offset views exercise the caller-owned output path. + it("fills bounded BYOB views across Blob segment boundaries", async function () { + const input = new Uint8Array(97); + for (let index = 0; index < input.length; ++index) { + input[index] = (index * 31) & 0xff; + } + + const blob = new Blob([input.subarray(0, 11), input.subarray(11, 53), input.subarray(53)]); + const reader = blob.stream().getReader({ mode: "byob" }); + const output: number[] = []; + const requestSizes = [1, 3, 7, 16]; + let requestIndex = 0; + while (true) { + const requestSize = requestSizes[requestIndex++ % requestSizes.length]; + const request = new Uint8Array(new ArrayBuffer(requestSize + 4), 2, requestSize); + const result = await reader.read(request); + if (result.done) { + break; + } + expect(result.value!.byteLength).to.be.at.most(requestSize); + output.push(...Array.from(result.value!)); + } + + expect(output).to.deep.equal(Array.from(input)); + }); + it("keeps independent stream cursors after the Blob reference is dropped", async function () { let blob: Blob | null = new Blob(["PASS"]); const first = blob.stream(); From 8ecb9dff934df8347a843651a8672ed5b02845b2 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 02:14:55 -0700 Subject: [PATCH 086/174] Preserve Streams bundle bytes across source splits --- Polyfills/Streams/Source/StreamsScripts.h.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 9bf7f5bf..126a23f7 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -9,9 +9,10 @@ namespace Babylon::Polyfills::Internal::StreamsScripts (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@ -)JSRHSTREAM"; +@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; + // Keep the split transparent: inserting whitespace here can divide an + // identifier or string literal when the vendored bundle is regenerated. inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ return module.exports; })() From 29e0357c4e083095901f26eae615e9c743b62a28 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 21:55:02 -0700 Subject: [PATCH 087/174] Add optional WHATWG Streams polyfill Vendor the ES5 web-streams-polyfill 4.3.0 ponyfill and expose an idempotent Streams initializer that preserves constructors supplied by the selected JavaScript engine. Cover readable, writable, transform, BYOB, error, tee, subclassing, and host-constructor behavior with focused ports from WPT plus Firefox and Chromium regression tests. Validate the implementation on JavaScriptCore under ASan/UBSan and QuickJS Release. --- CMakeLists.txt | 1 + Polyfills/CMakeLists.txt | 6 +- Polyfills/Streams/CMakeLists.txt | 30 ++++ .../Include/Babylon/Polyfills/Streams.h | 11 ++ Polyfills/Streams/README.md | 14 ++ Polyfills/Streams/Source/Streams.cpp | 55 ++++++ Polyfills/Streams/Source/StreamsScripts.h.in | 36 ++++ .../ThirdParty/web-streams-polyfill/LICENSE | 22 +++ .../web-streams-polyfill/ponyfill.es5.js | 8 + Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Scripts/tests.ts | 156 ++++++++++++++++++ Tests/UnitTests/Shared/Shared.cpp | 26 +++ 12 files changed, 365 insertions(+), 1 deletion(-) create mode 100644 Polyfills/Streams/CMakeLists.txt create mode 100644 Polyfills/Streams/Include/Babylon/Polyfills/Streams.h create mode 100644 Polyfills/Streams/README.md create mode 100644 Polyfills/Streams/Source/Streams.cpp create mode 100644 Polyfills/Streams/Source/StreamsScripts.h.in create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE create mode 100644 Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 21882d3e..6535a653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,6 +102,7 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON) option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) +option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index a44765fb..c952cf27 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -44,4 +44,8 @@ endif() if(JSRUNTIMEHOST_POLYFILL_TEXTENCODER) add_subdirectory(TextEncoder) -endif() \ No newline at end of file +endif() + +if(JSRUNTIMEHOST_POLYFILL_STREAMS) + add_subdirectory(Streams) +endif() diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt new file mode 100644 index 00000000..6c00ed81 --- /dev/null +++ b/Polyfills/Streams/CMakeLists.txt @@ -0,0 +1,30 @@ +set(WEB_STREAMS_POLYFILL_FILE + "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/web-streams-polyfill/ponyfill.es5.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${WEB_STREAMS_POLYFILL_FILE}") +file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) +string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +configure_file( + "Source/StreamsScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" + @ONLY) + +set(SOURCES + "Include/Babylon/Polyfills/Streams.h" + "Source/Streams.cpp" + "Source/StreamsScripts.h.in" + "ThirdParty/web-streams-polyfill/LICENSE" + "ThirdParty/web-streams-polyfill/ponyfill.es5.js") + +add_library(Streams ${SOURCES}) +warnings_as_errors(Streams) + +target_include_directories(Streams + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") + +target_link_libraries(Streams PUBLIC JsRuntime) + +set_property(TARGET Streams PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h new file mode 100644 index 00000000..01e5a15c --- /dev/null +++ b/Polyfills/Streams/Include/Babylon/Polyfills/Streams.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + // Installs the WHATWG Streams constructors that are not already supplied + // by the JavaScript engine. + void BABYLON_API Initialize(Napi::Env env); +} diff --git a/Polyfills/Streams/README.md b/Polyfills/Streams/README.md new file mode 100644 index 00000000..c84a38e3 --- /dev/null +++ b/Polyfills/Streams/README.md @@ -0,0 +1,14 @@ +# Web Streams + +Installs the standard `ReadableStream`, `WritableStream`, `TransformStream`, +reader, writer, controller, and queuing-strategy globals when the selected +JavaScript engine does not provide them. + +The implementation is the ES5 ponyfill bundle from +[`web-streams-polyfill` 4.3.0](https://github.com/MattiasBuelens/web-streams-polyfill/tree/add69059ed08eae6a18559aba49575a280d1529e), +which is based on the WHATWG reference implementation. The vendored project +tests this release against the Streams portion of WPT at revision +[`c05b4473`](https://github.com/web-platform-tests/wpt/tree/c05b447326585237713013c66341eab2cdf967b6/streams). + +`Initialize` preserves any Streams constructors already supplied by the host +engine and fills only missing globals. diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp new file mode 100644 index 00000000..4552ed07 --- /dev/null +++ b/Polyfills/Streams/Source/Streams.cpp @@ -0,0 +1,55 @@ +#include + +#include "StreamsScripts.h" + +#include +#include + +namespace Babylon::Polyfills::Streams +{ + void BABYLON_API Initialize(Napi::Env env) + { + Napi::HandleScope scope{env}; + auto global = env.Global(); + + static constexpr std::array constructorNames{ + "ReadableStream", + "ReadableStreamDefaultController", + "ReadableByteStreamController", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultReader", + "ReadableStreamBYOBReader", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", + "ByteLengthQueuingStrategy", + "CountQueuingStrategy", + "TransformStream", + "TransformStreamDefaultController", + }; + + bool needsPonyfill{}; + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + needsPonyfill = true; + break; + } + } + + if (!needsPonyfill) + { + return; + } + + const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); + for (const auto name : constructorNames) + { + if (global.Get(name.data()).IsUndefined()) + { + global.Set(name.data(), exports.Get(name.data())); + } + } + } +} diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in new file mode 100644 index 00000000..9bf7f5bf --- /dev/null +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace Babylon::Polyfills::Internal::StreamsScripts +{ + inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( +(function() { + var exports = {}; + var module = { exports: exports }; +@WEB_STREAMS_POLYFILL_SOURCE_1@ +)JSRHSTREAM"; + + inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ + return module.exports; +})() +)JSRHSTREAM"; + + template + consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + { + std::array result{}; + for (std::size_t index{}; index < Part1Size - 1; ++index) + { + result[index] = part1[index]; + } + for (std::size_t index{}; index < Part2Size; ++index) + { + result[Part1Size - 1 + index] = part2[index]; + } + return result; + } + + inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); +} diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE new file mode 100644 index 00000000..7adbcf57 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2026 Mattias Buelens +Copyright (c) 2016 Diwank Singh Tomer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js new file mode 100644 index 00000000..18d63683 --- /dev/null +++ b/Polyfills/Streams/ThirdParty/web-streams-polyfill/ponyfill.es5.js @@ -0,0 +1,8 @@ +/** + * @license + * web-streams-polyfill v4.3.0 + * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors. + * This code is released under the MIT license. + * SPDX-License-Identifier: MIT + */ +!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).WebStreamsPolyfill={})}(this,function(e){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?Symbol:function(e){return"Symbol(".concat(e,")")};function t(){}function o(e){return"object"==typeof e&&null!==e||"function"==typeof e}"function"==typeof SuppressedError&&SuppressedError;var n=t;function i(e,r){try{Object.defineProperty(e,"name",{value:r,configurable:!0})}catch(e){}}var a=Promise,u=Promise.resolve.bind(a),l=Promise.prototype.then,s=Promise.reject.bind(a),c=u;function f(e){return new a(e)}function d(e){return f(function(r){return r(e)})}function p(e){return s(e)}function b(e,r,t){return l.call(e,r,t)}function h(e,r,t){b(b(e,r,t),void 0,n)}function _(e,r){h(e,r)}function m(e,r){h(e,void 0,r)}function v(e,r,t){return b(e,r,t)}function y(e){b(e,void 0,n)}var g=function(e){if("function"==typeof queueMicrotask)g=queueMicrotask;else{var r=d(void 0);g=function(e){return b(r,e)}}return g(e)};function S(e,r,t){if("function"!=typeof e)throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,r,t)}function w(e,r,t){try{return d(S(e,r,t))}catch(e){return p(e)}}var R=function(){function e(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}return Object.defineProperty(e.prototype,"length",{get:function(){return this._size},enumerable:!1,configurable:!0}),e.prototype.push=function(e){var r=this._back,t=r;16383===r._elements.length&&(t={_elements:[],_next:void 0}),r._elements.push(e),t!==r&&(this._back=t,r._next=t),++this._size},e.prototype.shift=function(){var e=this._front,r=e,t=this._cursor,o=t+1,n=e._elements,i=n[t];return 16384===o&&(r=e._next,o=0),--this._size,this._cursor=o,e!==r&&(this._front=r),n[t]=void 0,i},e.prototype.forEach=function(e){for(var r=this._cursor,t=this._front,o=t._elements;!(r===o.length&&void 0===t._next||r===o.length&&(r=0,0===(o=(t=t._next)._elements).length));)e(o[r]),++r},e.prototype.peek=function(){var e=this._front,r=this._cursor;return e._elements[r]},e}(),T=r("[[AbortSteps]]"),P=r("[[ErrorSteps]]"),C=r("[[CancelSteps]]"),q=r("[[PullSteps]]"),E=r("[[CanPullSyncSteps]]"),W=r("[[ReleaseSteps]]");function O(e,r){e._ownerReadableStream=r,r._reader=e,"readable"===r._state?A(e):"closed"===r._state?function(e){A(e),F(e)}(e):z(e,r._storedError)}function j(e,r){return eo(e._ownerReadableStream,r)}function B(e){var r=e._ownerReadableStream;"readable"===r._state?D(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):function(e,r){z(e,r)}(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),r._readableStreamController[W](),r._reader=void 0,e._ownerReadableStream=void 0}function k(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function A(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t})}function z(e,r){A(e),D(e,r)}function D(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function F(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var L=Number.isFinite||function(e){return"number"==typeof e&&isFinite(e)},I=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function M(e,r){if(void 0!==e&&("object"!=typeof(t=e)&&"function"!=typeof t))throw new TypeError("".concat(r," is not an object."));var t}function x(e,r){if("function"!=typeof e)throw new TypeError("".concat(r," is not a function."))}function Y(e,r){if(!function(e){return"object"==typeof e&&null!==e||"function"==typeof e}(e))throw new TypeError("".concat(r," is not an object."))}function Q(e,r,t){if(void 0===e)throw new TypeError("Parameter ".concat(r," is required in '").concat(t,"'."))}function N(e,r,t){if(void 0===e)throw new TypeError("".concat(r," is required in '").concat(t,"'."))}function H(e){return Number(e)}function V(e){return 0===e?0:e}function U(e,r){var t=Number.MAX_SAFE_INTEGER,o=Number(e);if(o=V(o),!L(o))throw new TypeError("".concat(r," is not a finite number"));if((o=function(e){return V(I(e))}(o))<0||o>t)throw new TypeError("".concat(r," is outside the accepted range of ").concat(0," to ").concat(t,", inclusive"));return L(o)&&0!==o?o:0}function G(e,r){if(!Zt(e))throw new TypeError("".concat(r," is not a ReadableStream."))}function X(e){return new ee(e)}function J(e,r){e._reader._readRequests.push(r)}function K(e,r,t){var o=e._reader._readRequests.shift();t?o._closeSteps():o._chunkSteps(r)}function Z(e){return e._reader._readRequests.length}function $(e){var r=e._reader;return void 0!==r&&!!ae(r)}var ee=function(){function ReadableStreamDefaultReader(e){if(Q(e,1,"ReadableStreamDefaultReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");O(this,e),this._readRequests=new R}return Object.defineProperty(ReadableStreamDefaultReader.prototype,"closed",{get:function(){return ae(this)?this._closedPromise:p(ce("closed"))},enumerable:!1,configurable:!0}),ReadableStreamDefaultReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),ae(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(ce("cancel"))},ReadableStreamDefaultReader.prototype.read=function(){if(!ae(this))return p(ce("read"));if(void 0===this._ownerReadableStream)return p(k("read from"));var e=le(this)?new ie:new ne;return ue(this,e),e._promise},ReadableStreamDefaultReader.prototype.releaseLock=function(){if(!ae(this))throw ce("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");se(e,r)}(this)},ReadableStreamDefaultReader}();Object.defineProperties(ee.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(ee.prototype.cancel,"cancel"),i(ee.prototype.read,"read"),i(ee.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ee.prototype,r.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});var re,te,oe,ne=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(){this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),ie=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(){this._promise=c({value:void 0,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function ae(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readRequests")&&e instanceof ee)}function ue(e,r){var t=e._ownerReadableStream;t._disturbed=!0,"closed"===t._state?r._closeSteps():"errored"===t._state?r._errorSteps(t._storedError):t._readableStreamController[q](r)}function le(e){var r=e._ownerReadableStream;return"closed"===r._state||("errored"===r._state||r._readableStreamController[E]())}function se(e,r){var t=e._readRequests;e._readRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function ce(e){return new TypeError("ReadableStreamDefaultReader.prototype.".concat(e," can only be used on a ReadableStreamDefaultReader"))}function fe(e){return e.slice()}function de(e,r,t,o,n){new Uint8Array(e).set(new Uint8Array(t,o,n),r)}var pe=function(e){return(pe="function"==typeof e.transfer?function(e){return e.transfer()}:"function"==typeof structuredClone?function(e){return structuredClone(e,{transfer:[e]})}:function(e){return e})(e)},be=function(e){return(be="boolean"==typeof e.detached?function(e){return e.detached}:function(e){return 0===e.byteLength})(e)};function he(e,r,t){if(e.slice)return e.slice(r,t);var o=t-r,n=new ArrayBuffer(o);return de(n,0,e,r,o),n}function _e(e,r){var t=e[r];if(null!=t){if("function"!=typeof t)throw new TypeError("".concat(String(r)," is not a function"));return t}}function me(e){try{var r=e.done,t=e.value;return b(c(t),function(e){return{done:r,value:e}})}catch(e){return p(e)}}var ve,ye=null!==(oe=null!==(re=r.asyncIterator)&&void 0!==re?re:null===(te=r.for)||void 0===te?void 0:te.call(r,"Symbol.asyncIterator"))&&void 0!==oe?oe:"@@asyncIterator";function ge(e,t,n){if(void 0===t&&(t="sync"),void 0===n)if("async"===t){if(void 0===(n=_e(e,ye)))return function(e){var r={next:function(){var r;try{r=Se(e)}catch(e){return p(e)}return me(r)},return:function(r){var t;try{var n=_e(e.iterator,"return");if(void 0===n)return d({done:!0,value:r});t=S(n,e.iterator,[r])}catch(e){return p(e)}return o(t)?me(t):p(new TypeError("The iterator.return() method must return an object"))}};return{iterator:r,nextMethod:r.next,done:!1}}(ge(e,"sync",_e(e,r.iterator)))}else n=_e(e,r.iterator);if(void 0===n)throw new TypeError("The object is not iterable");var i=S(n,e,[]);if(!o(i))throw new TypeError("The iterator method must return an object");return{iterator:i,nextMethod:i.next,done:!1}}function Se(e){var r=S(e.nextMethod,e.iterator,[]);if(!o(r))throw new TypeError("The iterator.next() method must return an object");return r}var we=function(){function e(e,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=e,this._preventCancel=r}return e.prototype.next=function(){var e=this,r=function(){return e._nextSteps()};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,r,r):r(),this._ongoingPromise},e.prototype.return=function(e){var r=this,t=function(){return r._returnSteps(e)};return this._ongoingPromise=this._ongoingPromise?v(this._ongoingPromise,t,t):t(),this._ongoingPromise},e.prototype._nextSteps=function(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});var e=this._reader,r=new Re(this);return ue(e,r),r._promise},e.prototype._returnSteps=function(e){if(this._isFinished)return Promise.resolve({value:e,done:!0});this._isFinished=!0;var r=this._reader;if(!this._preventCancel){var t=j(r,e);return B(r),v(t,function(){return{value:e,done:!0}})}return B(r),d({value:e,done:!0})},e}(),Re=function(){function e(e){var r=this;this._iterator=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){var r=this;this._iterator._ongoingPromise=void 0,g(function(){return r._resolvePromise({value:e,done:!1})})},e.prototype._closeSteps=function(){var e=this._iterator;e._ongoingPromise=void 0,e._isFinished=!0,B(e._reader),this._resolvePromise({value:void 0,done:!0})},e.prototype._errorSteps=function(e){var r=this._iterator;r._ongoingPromise=void 0,r._isFinished=!0,B(r._reader),this._rejectPromise(e)},e}(),Te=((ve={next:function(){return Pe(this)?this._asyncIteratorImpl.next():p(Ce("next"))},return:function(e){return Pe(this)?this._asyncIteratorImpl.return(e):p(Ce("return"))}})[ye]=function(){return this},ve);function Pe(e){if(!o(e))return!1;if(!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof we}catch(e){return!1}}function Ce(e){return new TypeError("ReadableStreamAsyncIterator.".concat(e," can only be used on a ReadableSteamAsyncIterator"))}Object.defineProperty(Te,ye,{enumerable:!1});var qe=Number.isNaN||function(e){return e!=e};function Ee(e){var r=he(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(r)}function We(e){var r=e._queue.shift();return e._queueTotalSize-=r.size,e._queueTotalSize<0&&(e._queueTotalSize=0),r.value}function Oe(e,r,t){if("number"!=typeof(o=t)||qe(o)||o<0||t===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");var o;e._queue.push({value:r,size:t}),e._queueTotalSize+=t}function je(e){e._queue=new R,e._queueTotalSize=0}function Be(e){return e===DataView}function ke(e){return Be(e)?1:e.BYTES_PER_ELEMENT}var Ae=function(){function ReadableStreamBYOBRequest(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamBYOBRequest.prototype,"view",{get:function(){if(!Fe(this))throw sr("view");return this._view},enumerable:!1,configurable:!0}),ReadableStreamBYOBRequest.prototype.respond=function(e){if(!Fe(this))throw sr("respond");if(Q(e,1,"respond"),e=U(e,"First parameter"),void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(this._view.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");ar(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest.prototype.respondWithNewView=function(e){if(!Fe(this))throw sr("respondWithNewView");if(Q(e,1,"respondWithNewView"),!ArrayBuffer.isView(e))throw new TypeError("You can only respond with array buffer views");if(void 0===this._associatedReadableByteStreamController)throw new TypeError("This BYOB request has been invalidated");if(be(e.buffer))throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");ur(this._associatedReadableByteStreamController,e)},ReadableStreamBYOBRequest}();Object.defineProperties(Ae.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),i(Ae.prototype.respond,"respond"),i(Ae.prototype.respondWithNewView,"respondWithNewView"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Ae.prototype,r.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var ze=function(){function ReadableByteStreamController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableByteStreamController.prototype,"byobRequest",{get:function(){if(!De(this))throw cr("byobRequest");return nr(this)},enumerable:!1,configurable:!0}),Object.defineProperty(ReadableByteStreamController.prototype,"desiredSize",{get:function(){if(!De(this))throw cr("desiredSize");return ir(this)},enumerable:!1,configurable:!0}),ReadableByteStreamController.prototype.close=function(){if(!De(this))throw cr("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");var e=this._controlledReadableByteStream._state;if("readable"!==e)throw new TypeError("The stream (in ".concat(e," state) is not in the readable state and cannot be closed"));er(this)},ReadableByteStreamController.prototype.enqueue=function(e){if(!De(this))throw cr("enqueue");if(Q(e,1,"enqueue"),!ArrayBuffer.isView(e))throw new TypeError("chunk must be an array buffer view");if(0===e.byteLength)throw new TypeError("chunk must have non-zero byteLength");if(0===e.buffer.byteLength)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");var r=this._controlledReadableByteStream._state;if("readable"!==r)throw new TypeError("The stream (in ".concat(r," state) is not in the readable state and cannot be enqueued to"));rr(this,e)},ReadableByteStreamController.prototype.error=function(e){if(void 0===e&&(e=void 0),!De(this))throw cr("error");tr(this,e)},ReadableByteStreamController.prototype[C]=function(e){Ie(this),je(this);var r=this._cancelAlgorithm(e);return $e(this),r},ReadableByteStreamController.prototype[q]=function(e){var r=this._controlledReadableByteStream;if(this._queueTotalSize>0)or(this,e);else{var t=this._autoAllocateChunkSize;if(void 0!==t){var o=void 0;try{o=new ArrayBuffer(t)}catch(r){return void e._errorSteps(r)}var n={buffer:o,bufferByteLength:t,byteOffset:0,byteLength:t,bytesFilled:0,minimumFill:1,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(n)}J(r,e),Le(this)}},ReadableByteStreamController.prototype[E]=function(){return this._queueTotalSize>0},ReadableByteStreamController.prototype[W]=function(){if(this._pendingPullIntos.length>0){var e=this._pendingPullIntos.peek();e.readerType="none",this._pendingPullIntos=new R,this._pendingPullIntos.push(e)}},ReadableByteStreamController}();function De(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")&&e instanceof ze)}function Fe(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")&&e instanceof Ae)}function Le(e){var r=function(e){var r=e._controlledReadableByteStream;if("readable"!==r._state)return!1;if(e._closeRequested)return!1;if(!e._started)return!1;if($(r)&&Z(r)>0)return!0;if(hr(r)&&br(r)>0)return!0;var t=ir(e);if(t>0)return!0;return!1}(e);r&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Le(e)),null},function(r){return tr(e,r),null})))}function Ie(e){Xe(e),e._pendingPullIntos=new R}function Me(e,r){var t=!1;"closed"===e._state&&(t=!0);var o=Ye(r);"default"===r.readerType?K(e,o,t):function(e,r,t){var o=e._reader,n=o._readIntoRequests.shift();t?n._closeSteps(r):n._chunkSteps(r)}(e,o,t)}function xe(e,r){for(var t=0;t0&&Ne(e,r.buffer,r.byteOffset,r.bytesFilled),Ze(e)}function Ve(e,r){var t=Math.min(e._queueTotalSize,r.byteLength-r.bytesFilled),o=r.bytesFilled+t,n=t,i=!1,a=o-o%r.elementSize;a>=r.minimumFill&&(n=a-r.bytesFilled,i=!0);for(var u=e._queue;n>0;){var l=u.peek(),s=Math.min(n,l.byteLength),c=r.byteOffset+r.bytesFilled;de(r.buffer,c,l.buffer,l.byteOffset,s),l.byteLength===s?u.shift():(l.byteOffset+=s,l.byteLength-=s),e._queueTotalSize-=s,Ue(e,s,r),n-=s}return i}function Ue(e,r,t){t.bytesFilled+=r}function Ge(e){0===e._queueTotalSize&&e._closeRequested?($e(e),ro(e._controlledReadableByteStream)):Le(e)}function Xe(e){null!==e._byobRequest&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Je(e){for(var r=[];e._pendingPullIntos.length>0&&0!==e._queueTotalSize;){var t=e._pendingPullIntos.peek();Ve(e,t)&&(Ze(e),r.push(t))}return r}function Ke(e,r){var t=e._pendingPullIntos.peek();Xe(e),"closed"===e._controlledReadableByteStream._state?function(e,r){"none"===r.readerType&&Ze(e);var t=e._controlledReadableByteStream;if(hr(t)){for(var o=[];o.length0){var n=t.byteOffset+t.bytesFilled;Ne(e,t.buffer,n-o,o)}t.bytesFilled-=o;var i=Je(e);Me(e._controlledReadableByteStream,t),xe(e._controlledReadableByteStream,i)}}else{He(e,t);var a=Je(e);xe(e._controlledReadableByteStream,a)}}(e,r,t),Le(e)}function Ze(e){return e._pendingPullIntos.shift()}function $e(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function er(e){var r=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===r._state)if(e._queueTotalSize>0)e._closeRequested=!0;else{if(e._pendingPullIntos.length>0){var t=e._pendingPullIntos.peek();if(t.bytesFilled%t.elementSize!==0){var o=new TypeError("Insufficient bytes to fill elements in the given buffer");throw tr(e,o),o}}$e(e),ro(r)}}function rr(e,r){var t=e._controlledReadableByteStream;if(!e._closeRequested&&"readable"===t._state){var o=r.buffer,n=r.byteOffset,i=r.byteLength;if(be(o))throw new TypeError("chunk's buffer is detached and so cannot be enqueued");var a=pe(o);if(e._pendingPullIntos.length>0){var u=e._pendingPullIntos.peek();if(be(u.buffer))throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");Xe(e),u.buffer=pe(u.buffer),"none"===u.readerType&&He(e,u)}if($(t))if(function(e){for(var r=e._controlledReadableByteStream._reader;r._readRequests.length>0;){if(0===e._queueTotalSize)return;or(e,r._readRequests.shift())}}(e),0===Z(t))Qe(e,a,n,i);else e._pendingPullIntos.length>0&&Ze(e),K(t,new Uint8Array(a,n,i),!1);else if(hr(t)){Qe(e,a,n,i),xe(t,Je(e))}else Qe(e,a,n,i);Le(e)}}function tr(e,r){var t=e._controlledReadableByteStream;"readable"===t._state&&(Ie(e),je(e),$e(e),to(t,r))}function or(e,r){var t=e._queue.shift();e._queueTotalSize-=t.byteLength,Ge(e);var o=new Uint8Array(t.buffer,t.byteOffset,t.byteLength);r._chunkSteps(o)}function nr(e){if(null===e._byobRequest&&e._pendingPullIntos.length>0){var r=e._pendingPullIntos.peek(),t=new Uint8Array(r.buffer,r.byteOffset+r.bytesFilled,r.byteLength-r.bytesFilled),o=Object.create(Ae.prototype);!function(e,r,t){e._associatedReadableByteStreamController=r,e._view=t}(o,e,t),e._byobRequest=o}return e._byobRequest}function ir(e){var r=e._controlledReadableByteStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function ar(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(0===r)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(t.bytesFilled+r>t.byteLength)throw new RangeError("bytesWritten out of range")}t.buffer=pe(t.buffer),Ke(e,r)}function ur(e,r){var t=e._pendingPullIntos.peek();if("closed"===e._controlledReadableByteStream._state){if(0!==r.byteLength)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(0===r.byteLength)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(t.byteOffset+t.bytesFilled!==r.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(t.bufferByteLength!==r.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(t.bytesFilled+r.byteLength>t.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");var o=r.byteLength;t.buffer=pe(r.buffer),Ke(e,o)}function lr(e,r,t,o,n,i,a){r._controlledReadableByteStream=e,r._pullAgain=!1,r._pulling=!1,r._byobRequest=null,r._queue=r._queueTotalSize=void 0,je(r),r._closeRequested=!1,r._started=!1,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,r._autoAllocateChunkSize=a,r._pendingPullIntos=new R,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,Le(r),null},function(e){return tr(r,e),null})}function sr(e){return new TypeError("ReadableStreamBYOBRequest.prototype.".concat(e," can only be used on a ReadableStreamBYOBRequest"))}function cr(e){return new TypeError("ReadableByteStreamController.prototype.".concat(e," can only be used on a ReadableByteStreamController"))}function fr(e,r){if("byob"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamReaderMode"));return e}function dr(e){return new _r(e)}function pr(e,r){e._reader._readIntoRequests.push(r)}function br(e){return e._reader._readIntoRequests.length}function hr(e){var r=e._reader;return void 0!==r&&!!yr(r)}Object.defineProperties(ze.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),i(ze.prototype.close,"close"),i(ze.prototype.enqueue,"enqueue"),i(ze.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(ze.prototype,r.toStringTag,{value:"ReadableByteStreamController",configurable:!0});var _r=function(){function ReadableStreamBYOBReader(e){if(Q(e,1,"ReadableStreamBYOBReader"),G(e,"First parameter"),$t(e))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!De(e._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");O(this,e),this._readIntoRequests=new R}return Object.defineProperty(ReadableStreamBYOBReader.prototype,"closed",{get:function(){return yr(this)?this._closedPromise:p(wr("closed"))},enumerable:!1,configurable:!0}),ReadableStreamBYOBReader.prototype.cancel=function(e){return void 0===e&&(e=void 0),yr(this)?void 0===this._ownerReadableStream?p(k("cancel")):j(this,e):p(wr("cancel"))},ReadableStreamBYOBReader.prototype.read=function(e,r){if(void 0===r&&(r={}),!yr(this))return p(wr("read"));if(!ArrayBuffer.isView(e))return p(new TypeError("view must be an array buffer view"));if(0===e.byteLength)return p(new TypeError("view must have non-zero byteLength"));if(0===e.buffer.byteLength)return p(new TypeError("view's buffer must have non-zero byteLength"));if(be(e.buffer))return p(new TypeError("view's buffer has been detached"));var t;try{t=function(e,r){var t;return M(e,r),{min:U(null!==(t=null==e?void 0:e.min)&&void 0!==t?t:1,"".concat(r," has member 'min' that"))}}(r,"options")}catch(e){return p(e)}var o=t.min;if(0===o)return p(new TypeError("options.min must be greater than 0"));if(function(e){return Be(e.constructor)}(e)){if(o>e.byteLength)return p(new RangeError("options.min must be less than or equal to view's byteLength"))}else if(o>e.length)return p(new RangeError("options.min must be less than or equal to view's length"));if(void 0===this._ownerReadableStream)return p(k("read from"));var n=function(e,r,t){var o=e._ownerReadableStream;return"errored"===o._state||function(e,r,t){var o=e._controlledReadableByteStream,n=ke(r.constructor);r.byteLength;var i=t*n;return!(e._pendingPullIntos.length>0)&&("closed"===o._state||e._queueTotalSize>=i)}(o._readableStreamController,r,t)}(this,e,o)?new vr:new mr;return gr(this,e,o,n),n._promise},ReadableStreamBYOBReader.prototype.releaseLock=function(){if(!yr(this))throw wr("releaseLock");void 0!==this._ownerReadableStream&&function(e){B(e);var r=new TypeError("Reader was released");Sr(e,r)}(this)},ReadableStreamBYOBReader}();Object.defineProperties(_r.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),i(_r.prototype.cancel,"cancel"),i(_r.prototype.read,"read"),i(_r.prototype.releaseLock,"releaseLock"),"symbol"==typeof r.toStringTag&&Object.defineProperty(_r.prototype,r.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});var mr=function(){function e(){var e=this;this._promise=f(function(r,t){e._resolvePromise=r,e._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._resolvePromise({value:e,done:!1})},e.prototype._closeSteps=function(e){this._resolvePromise({value:e,done:!0})},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),vr=function(){function e(){this._promise=void 0}return e.prototype._chunkSteps=function(e){this._promise=c({value:e,done:!1})},e.prototype._closeSteps=function(e){this._promise=c({value:e,done:!0})},e.prototype._errorSteps=function(e){this._promise=p(e)},e}();function yr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")&&e instanceof _r)}function gr(e,r,t,o){var n=e._ownerReadableStream;n._disturbed=!0,"errored"===n._state?o._errorSteps(n._storedError):function(e,r,t,o){var n,i=e._controlledReadableByteStream,a=r.constructor,u=ke(a),l=r.byteOffset,s=r.byteLength,c=t*u;try{n=pe(r.buffer)}catch(p){return void o._errorSteps(p)}var f={buffer:n,bufferByteLength:n.byteLength,byteOffset:l,byteLength:s,bytesFilled:0,minimumFill:c,elementSize:u,viewConstructor:a,readerType:"byob"};if(e._pendingPullIntos.length>0)return e._pendingPullIntos.push(f),void pr(i,o);if("closed"!==i._state){if(e._queueTotalSize>0){if(Ve(e,f)){var d=Ye(f);return Ge(e),void o._chunkSteps(d)}if(e._closeRequested){var p=new TypeError("Insufficient bytes to fill elements in the given buffer");return tr(e,p),void o._errorSteps(p)}}e._pendingPullIntos.push(f),pr(i,o),Le(e)}else{var b=new a(f.buffer,f.byteOffset,0);o._closeSteps(b)}}(n._readableStreamController,r,t,o)}function Sr(e,r){var t=e._readIntoRequests;e._readIntoRequests=new R,t.forEach(function(e){e._errorSteps(r)})}function wr(e){return new TypeError("ReadableStreamBYOBReader.prototype.".concat(e," can only be used on a ReadableStreamBYOBReader"))}function Rr(e,r){var t=e.highWaterMark;if(void 0===t)return r;if(qe(t)||t<0)throw new RangeError("Invalid highWaterMark");return t}function Tr(e){var r=e.size;return r||function(){return 1}}function Pr(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark,o=null==e?void 0:e.size;return{highWaterMark:void 0===t?void 0:H(t),size:void 0===o?void 0:Cr(o,"".concat(r," has member 'size' that"))}}function Cr(e,r){return x(e,r),function(r){return H(e(r))}}function qr(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Er(e,r,t){return x(e,t),function(){return w(e,r,[])}}function Wr(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Or(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function jr(e,r){if(!zr(e))throw new TypeError("".concat(r," is not a WritableStream."))}var Br=function(){function WritableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=null==e?void 0:e.abort,o=null==e?void 0:e.close,n=null==e?void 0:e.start,i=null==e?void 0:e.type,a=null==e?void 0:e.write;return{abort:void 0===t?void 0:qr(t,e,"".concat(r," has member 'abort' that")),close:void 0===o?void 0:Er(o,e,"".concat(r," has member 'close' that")),start:void 0===n?void 0:Wr(n,e,"".concat(r," has member 'start' that")),write:void 0===a?void 0:Or(a,e,"".concat(r," has member 'write' that")),type:i}}(e,"First parameter");if(Ar(this),void 0!==o.type)throw new RangeError("Invalid type is specified");var n=Tr(t);!function(e,r,t,o){var n,i,a,u,l=Object.create($r.prototype);n=void 0!==r.start?function(){return r.start(l)}:function(){};i=void 0!==r.write?function(e){return r.write(e,l)}:function(){return d(void 0)};a=void 0!==r.close?function(){return r.close()}:function(){return d(void 0)};u=void 0!==r.abort?function(e){return r.abort(e)}:function(){return d(void 0)};rt(e,l,n,i,a,u,t,o)}(this,o,Rr(t,1),n)}return Object.defineProperty(WritableStream.prototype,"locked",{get:function(){if(!zr(this))throw lt("locked");return Dr(this)},enumerable:!1,configurable:!0}),WritableStream.prototype.abort=function(e){return void 0===e&&(e=void 0),zr(this)?Dr(this)?p(new TypeError("Cannot abort a stream that already has a writer")):Fr(this,e):p(lt("abort"))},WritableStream.prototype.close=function(){return zr(this)?Dr(this)?p(new TypeError("Cannot close a stream that already has a writer")):Yr(this)?p(new TypeError("Cannot close an already-closing stream")):Lr(this):p(lt("close"))},WritableStream.prototype.getWriter=function(){if(!zr(this))throw lt("getWriter");return kr(this)},WritableStream}();function kr(e){return new Hr(e)}function Ar(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new R,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function zr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")&&e instanceof Br)}function Dr(e){return void 0!==e._writer}function Fr(e,r){var t;if("closed"===e._state||"errored"===e._state)return d(void 0);e._writableStreamController._abortReason=r,null===(t=e._writableStreamController._abortController)||void 0===t||t.abort(r);var o=e._state;if("closed"===o||"errored"===o)return d(void 0);if(void 0!==e._pendingAbortRequest)return e._pendingAbortRequest._promise;var n=!1;"erroring"===o&&(n=!0,r=void 0);var i=f(function(t,o){e._pendingAbortRequest={_promise:void 0,_resolve:t,_reject:o,_reason:r,_wasAlreadyErroring:n}});return e._pendingAbortRequest._promise=i,n||Mr(e,r),i}function Lr(e){var r=e._state;if("closed"===r||"errored"===r)return p(new TypeError("The stream (in ".concat(r," state) is not in the writable state and cannot be closed")));var t,o=f(function(r,t){var o={_resolve:r,_reject:t};e._closeRequest=o}),n=e._writer;return void 0!==n&&e._backpressure&&"writable"===r&>(n),Oe(t=e._writableStreamController,Zr,0),nt(t),o}function Ir(e,r){"writable"!==e._state?xr(e):Mr(e,r)}function Mr(e,r){var t=e._writableStreamController;e._state="erroring",e._storedError=r;var o=e._writer;void 0!==o&&Xr(o,r),!function(e){if(void 0===e._inFlightWriteRequest&&void 0===e._inFlightCloseRequest)return!1;return!0}(e)&&t._started&&xr(e)}function xr(e){e._state="errored",e._writableStreamController[P]();var r=e._storedError;if(e._writeRequests.forEach(function(e){e._reject(r)}),e._writeRequests=new R,void 0!==e._pendingAbortRequest){var t=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,t._wasAlreadyErroring)return t._reject(r),void Qr(e);h(e._writableStreamController[T](t._reason),function(){return t._resolve(),Qr(e),null},function(r){return t._reject(r),Qr(e),null})}else Qr(e)}function Yr(e){return void 0!==e._closeRequest||void 0!==e._inFlightCloseRequest}function Qr(e){void 0!==e._closeRequest&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);var r=e._writer;void 0!==r&&bt(r,e._storedError)}function Nr(e,r){var t=e._writer;void 0!==t&&r!==e._backpressure&&(r?function(e){_t(e)}(t):gt(t)),e._backpressure=r}Object.defineProperties(Br.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),i(Br.prototype.abort,"abort"),i(Br.prototype.close,"close"),i(Br.prototype.getWriter,"getWriter"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Br.prototype,r.toStringTag,{value:"WritableStream",configurable:!0});var Hr=function(){function WritableStreamDefaultWriter(e){if(Q(e,1,"WritableStreamDefaultWriter"),jr(e,"First parameter"),Dr(e))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=e,e._writer=this;var r,t=e._state;if("writable"===t)!Yr(e)&&e._backpressure?_t(this):vt(this),dt(this);else if("erroring"===t)mt(this,e._storedError),dt(this);else if("closed"===t)vt(this),dt(r=this),ht(r);else{var o=e._storedError;mt(this,o),pt(this,o)}}return Object.defineProperty(WritableStreamDefaultWriter.prototype,"closed",{get:function(){return Vr(this)?this._closedPromise:p(ct("closed"))},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"desiredSize",{get:function(){if(!Vr(this))throw ct("desiredSize");if(void 0===this._ownerWritableStream)throw ft("desiredSize");return function(e){var r=e._ownerWritableStream,t=r._state;if("errored"===t||"erroring"===t)return null;if("closed"===t)return 0;return ot(r._writableStreamController)}(this)},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultWriter.prototype,"ready",{get:function(){return Vr(this)?this._readyPromise:p(ct("ready"))},enumerable:!1,configurable:!0}),WritableStreamDefaultWriter.prototype.abort=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("abort")):function(e,r){return Fr(e._ownerWritableStream,r)}(this,e):p(ct("abort"))},WritableStreamDefaultWriter.prototype.close=function(){if(!Vr(this))return p(ct("close"));var e=this._ownerWritableStream;return void 0===e?p(ft("close")):Yr(e)?p(new TypeError("Cannot close an already-closing stream")):Ur(this)},WritableStreamDefaultWriter.prototype.releaseLock=function(){if(!Vr(this))throw ct("releaseLock");void 0!==this._ownerWritableStream&&Jr(this)},WritableStreamDefaultWriter.prototype.write=function(e){return void 0===e&&(e=void 0),Vr(this)?void 0===this._ownerWritableStream?p(ft("write to")):Kr(this,e):p(ct("write"))},WritableStreamDefaultWriter}();function Vr(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")&&e instanceof Hr)}function Ur(e){return Lr(e._ownerWritableStream)}function Gr(e,r){"pending"===e._closedPromiseState?bt(e,r):function(e,r){pt(e,r)}(e,r)}function Xr(e,r){"pending"===e._readyPromiseState?yt(e,r):function(e,r){mt(e,r)}(e,r)}function Jr(e){var r=e._ownerWritableStream,t=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Xr(e,t),Gr(e,t),r._writer=void 0,e._ownerWritableStream=void 0}function Kr(e,r){var t=e._ownerWritableStream,o=t._writableStreamController,n=function(e,r){if(void 0===e._strategySizeAlgorithm)return 1;try{return e._strategySizeAlgorithm(r)}catch(r){return it(e,r),1}}(o,r);if(t!==e._ownerWritableStream)return p(ft("write to"));var i=t._state;if("errored"===i)return p(t._storedError);if(Yr(t)||"closed"===i)return p(new TypeError("The stream is closing or closed and cannot be written to"));if("erroring"===i)return p(t._storedError);var a=function(e){return f(function(r,t){var o={_resolve:r,_reject:t};e._writeRequests.push(o)})}(t);return function(e,r,t){try{Oe(e,r,t)}catch(r){return void it(e,r)}var o=e._controlledWritableStream;if(!Yr(o)&&"writable"===o._state){Nr(o,at(e))}nt(e)}(o,r,n),a}Object.defineProperties(Hr.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),i(Hr.prototype.abort,"abort"),i(Hr.prototype.close,"close"),i(Hr.prototype.releaseLock,"releaseLock"),i(Hr.prototype.write,"write"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Hr.prototype,r.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});var Zr={},$r=function(){function WritableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(WritableStreamDefaultController.prototype,"abortReason",{get:function(){if(!et(this))throw st("abortReason");return this._abortReason},enumerable:!1,configurable:!0}),Object.defineProperty(WritableStreamDefaultController.prototype,"signal",{get:function(){if(!et(this))throw st("signal");if(void 0===this._abortController)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal},enumerable:!1,configurable:!0}),WritableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!et(this))throw st("error");"writable"===this._controlledWritableStream._state&&ut(this,e)},WritableStreamDefaultController.prototype[T]=function(e){var r=this._abortAlgorithm(e);return tt(this),r},WritableStreamDefaultController.prototype[P]=function(){je(this)},WritableStreamDefaultController}();function et(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")&&e instanceof $r)}function rt(e,r,t,o,n,i,a,u){r._controlledWritableStream=e,e._writableStreamController=r,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._abortReason=void 0,r._abortController=function(){if("function"==typeof AbortController)return new AbortController}(),r._started=!1,r._strategySizeAlgorithm=u,r._strategyHWM=a,r._writeAlgorithm=o,r._closeAlgorithm=n,r._abortAlgorithm=i;var l=at(r);Nr(e,l),h(d(t()),function(){return r._started=!0,nt(r),null},function(t){return r._started=!0,Ir(e,t),null})}function tt(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ot(e){return e._strategyHWM-e._queueTotalSize}function nt(e){var r=e._controlledWritableStream;if(e._started&&void 0===r._inFlightWriteRequest)if("erroring"!==r._state){if(0!==e._queue.length){var t=e._queue.peek().value;t===Zr?function(e){var r=e._controlledWritableStream;(function(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0})(r),We(e);var t=e._closeAlgorithm();tt(e),h(t,function(){return function(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,"erroring"===e._state&&(e._storedError=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";var r=e._writer;void 0!==r&&ht(r)}(r),null},function(e){return function(e,r){e._inFlightCloseRequest._reject(r),e._inFlightCloseRequest=void 0,void 0!==e._pendingAbortRequest&&(e._pendingAbortRequest._reject(r),e._pendingAbortRequest=void 0),Ir(e,r)}(r,e),null})}(e):function(e,r){var t=e._controlledWritableStream;!function(e){e._inFlightWriteRequest=e._writeRequests.shift()}(t);var o=e._writeAlgorithm(r);h(o,function(){!function(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}(t);var r=t._state;if(We(e),!Yr(t)&&"writable"===r){var o=at(e);Nr(t,o)}return nt(e),null},function(r){return"writable"===t._state&&tt(e),function(e,r){e._inFlightWriteRequest._reject(r),e._inFlightWriteRequest=void 0,Ir(e,r)}(t,r),null})}(e,t)}}else xr(r)}function it(e,r){"writable"===e._controlledWritableStream._state&&ut(e,r)}function at(e){return ot(e)<=0}function ut(e,r){var t=e._controlledWritableStream;tt(e),Mr(t,r)}function lt(e){return new TypeError("WritableStream.prototype.".concat(e," can only be used on a WritableStream"))}function st(e){return new TypeError("WritableStreamDefaultController.prototype.".concat(e," can only be used on a WritableStreamDefaultController"))}function ct(e){return new TypeError("WritableStreamDefaultWriter.prototype.".concat(e," can only be used on a WritableStreamDefaultWriter"))}function ft(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function dt(e){e._closedPromise=f(function(r,t){e._closedPromise_resolve=r,e._closedPromise_reject=t,e._closedPromiseState="pending"})}function pt(e,r){dt(e),bt(e,r)}function bt(e,r){void 0!==e._closedPromise_reject&&(y(e._closedPromise),e._closedPromise_reject(r),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ht(e){void 0!==e._closedPromise_resolve&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function _t(e){e._readyPromise=f(function(r,t){e._readyPromise_resolve=r,e._readyPromise_reject=t}),e._readyPromiseState="pending"}function mt(e,r){_t(e),yt(e,r)}function vt(e){_t(e),gt(e)}function yt(e,r){void 0!==e._readyPromise_reject&&(y(e._readyPromise),e._readyPromise_reject(r),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function gt(e){void 0!==e._readyPromise_resolve&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}Object.defineProperties($r.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty($r.prototype,r.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});var St="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof global?global:void 0;var wt,Rt=(function(e){if("function"!=typeof e&&"object"!=typeof e)return!1;if("DOMException"!==e.name)return!1;try{return new e,!0}catch(e){return!1}}(wt=null==St?void 0:St.DOMException)?wt:void 0)||function(){var e=function(e,r){this.message=e||"",this.name=r||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return i(e,"DOMException"),e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}();function Tt(e,r,t,o,n,i){var a=X(e),u=kr(r);e._disturbed=!0;var l=new Pt(u),s=new qt(l);return f(function(c,m){var v,g,S,w;if(void 0!==i){if(v=function(){var t=void 0!==i.reason?i.reason:new Rt("Aborted","AbortError"),a=[];o||a.push(function(){return"writable"===r._state?Fr(r,t):d(void 0)}),n||a.push(function(){return"readable"===e._state?eo(e,t):d(void 0)}),P(function(){return Promise.all(a.map(function(e){return e()}))},!0,t)},i.aborted)return void v();i.addEventListener("abort",v)}function R(){for(;!l._shuttingDown&&!r._backpressure&&"writable"===r._state&&!Yr(r)&&"readable"===e._state&&le(a);)ue(a,s);if(l._shuttingDown)return d(!0);if(r._backpressure)return b(u._readyPromise,R);var t=new Ct(l);return ue(a,t),t._promise}if(Et(e,a._closedPromise,function(e){return o?C(!0,e):P(function(){return Fr(r,e)},!0,e),null}),Et(r,u._closedPromise,function(r){return n?C(!0,r):P(function(){return eo(e,r)},!0,r),null}),g=e,S=a._closedPromise,w=function(){return t?C():P(function(){return function(e){var r=e._ownerWritableStream,t=r._state;return Yr(r)||"closed"===t?d(void 0):"errored"===t?p(r._storedError):Ur(e)}(u)}),null},"closed"===g._state?w():_(S,w),Yr(r)||"closed"===r._state){var T=new TypeError("the destination writable stream closed before all data could be piped to it");n?C(!0,T):P(function(){return eo(e,T)},!0,T)}function P(e,t,o){function n(){return h(e(),function(){return q(t,o)},function(e){return q(!0,e)}),null}l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?n():_(l._waitForWritesToFinish(),n))}function C(e,t){l._shuttingDown||(l._shuttingDown=!0,"writable"!==r._state||Yr(r)?q(e,t):_(l._waitForWritesToFinish(),function(){return q(e,t)}))}function q(e,r){return Jr(u),B(a),void 0!==i&&i.removeEventListener("abort",v),e?m(r):c(void 0),null}y(f(function(e,r){!function t(o){o?e():b(R(),t,r)}(!1)}))})}var Pt=function(){function e(e){this._writer=e,this._shuttingDown=!1,this._currentWrite=d(void 0)}return e.prototype._waitForWritesToFinish=function(){var e=this,r=this._currentWrite;return b(this._currentWrite,function(){return r!==e._currentWrite?e._waitForWritesToFinish():void 0})},e}(),Ct=function(){function e(e){var r=this;this._state=e,this._promise=f(function(e,t){r._resolvePromise=e,r._rejectPromise=t})}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t),this._resolvePromise(!1)},e.prototype._closeSteps=function(){this._resolvePromise(!0)},e.prototype._errorSteps=function(e){this._rejectPromise(e)},e}(),qt=function(){function e(e){this._state=e}return e.prototype._chunkSteps=function(e){this._state._currentWrite=b(Kr(this._state._writer,e),void 0,t)},e.prototype._closeSteps=function(){},e.prototype._errorSteps=function(e){},e}();function Et(e,r,t){"errored"===e._state?t(e._storedError):m(r,t)}var Wt=function(){function ReadableStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(ReadableStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Ot(this))throw Mt("desiredSize");return Ft(this)},enumerable:!1,configurable:!0}),ReadableStreamDefaultController.prototype.close=function(){if(!Ot(this))throw Mt("close");if(!Lt(this))throw new TypeError("The stream is not in a state that permits close");At(this)},ReadableStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("enqueue");if(!Lt(this))throw new TypeError("The stream is not in a state that permits enqueue");return zt(this,e)},ReadableStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Ot(this))throw Mt("error");Dt(this,e)},ReadableStreamDefaultController.prototype[C]=function(e){je(this);var r=this._cancelAlgorithm(e);return kt(this),r},ReadableStreamDefaultController.prototype[q]=function(e){var r=this._controlledReadableStream;if(this._queue.length>0){var t=We(this);this._closeRequested&&0===this._queue.length?(kt(this),ro(r)):jt(this),e._chunkSteps(t)}else J(r,e),jt(this)},ReadableStreamDefaultController.prototype[E]=function(){return this._queue.length>0},ReadableStreamDefaultController.prototype[W]=function(){},ReadableStreamDefaultController}();function Ot(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")&&e instanceof Wt)}function jt(e){Bt(e)&&(e._pulling?e._pullAgain=!0:(e._pulling=!0,h(e._pullAlgorithm(),function(){return e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,jt(e)),null},function(r){return Dt(e,r),null})))}function Bt(e){var r=e._controlledReadableStream;return!!Lt(e)&&(!!e._started&&(!!($t(r)&&Z(r)>0)||Ft(e)>0))}function kt(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function At(e){if(Lt(e)){var r=e._controlledReadableStream;e._closeRequested=!0,0===e._queue.length&&(kt(e),ro(r))}}function zt(e,r){if(Lt(e)){var t=e._controlledReadableStream;if($t(t)&&Z(t)>0)K(t,r,!1);else{var o=void 0;try{o=e._strategySizeAlgorithm(r)}catch(r){throw Dt(e,r),r}try{Oe(e,r,o)}catch(r){throw Dt(e,r),r}}jt(e)}}function Dt(e,r){var t=e._controlledReadableStream;"readable"===t._state&&(je(e),kt(e),to(t,r))}function Ft(e){var r=e._controlledReadableStream._state;return"errored"===r?null:"closed"===r?0:e._strategyHWM-e._queueTotalSize}function Lt(e){var r=e._controlledReadableStream._state;return!e._closeRequested&&"readable"===r}function It(e,r,t,o,n,i,a){r._controlledReadableStream=e,r._queue=void 0,r._queueTotalSize=void 0,je(r),r._started=!1,r._closeRequested=!1,r._pullAgain=!1,r._pulling=!1,r._strategySizeAlgorithm=a,r._strategyHWM=i,r._pullAlgorithm=o,r._cancelAlgorithm=n,e._readableStreamController=r,h(d(t()),function(){return r._started=!0,jt(r),null},function(e){return Dt(r,e),null})}function Mt(e){return new TypeError("ReadableStreamDefaultController.prototype.".concat(e," can only be used on a ReadableStreamDefaultController"))}function xt(e,r){return De(e._readableStreamController)?function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=!1,b=f(function(e){i=e});function h(e){m(e._closedPromise,function(r){return e!==a||(tr(o._readableStreamController,r),tr(n._readableStreamController,r),c&&p||i(void 0)),null})}function _(){yr(a)&&(B(a),h(a=X(e))),ue(a,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var t=r,a=r;if(!c&&!p)try{a=Ee(r)}catch(r){return tr(o._readableStreamController,r),tr(n._readableStreamController,r),void i(eo(e,r))}c||rr(o._readableStreamController,t),p||rr(n._readableStreamController,a),u=!1,l?y():s&&S()})},_closeSteps:function(){u=!1,c||er(o._readableStreamController),p||er(n._readableStreamController),o._readableStreamController._pendingPullIntos.length>0&&ar(o._readableStreamController,0),n._readableStreamController._pendingPullIntos.length>0&&ar(n._readableStreamController,0),c&&p||i(void 0)},_errorSteps:function(){u=!1}})}function v(r,t){ae(a)&&(B(a),h(a=dr(e)));var f=t?n:o,d=t?o:n;gr(a,r,1,{_chunkSteps:function(r){g(function(){l=!1,s=!1;var o=t?p:c;if(t?c:p)o||ur(f._readableStreamController,r);else{var n=void 0;try{n=Ee(r)}catch(r){return tr(f._readableStreamController,r),tr(d._readableStreamController,r),void i(eo(e,r))}o||ur(f._readableStreamController,r),rr(d._readableStreamController,n)}u=!1,l?y():s&&S()})},_closeSteps:function(e){u=!1;var r=t?p:c,o=t?c:p;r||er(f._readableStreamController),o||er(d._readableStreamController),void 0!==e&&(r||ur(f._readableStreamController,e),!o&&d._readableStreamController._pendingPullIntos.length>0&&ar(d._readableStreamController,0)),r&&o||i(void 0)},_errorSteps:function(){u=!1}})}function y(){if(u)return l=!0,d(void 0);u=!0;var e=nr(o._readableStreamController);return null===e?_():v(e._view,!1),d(void 0)}function S(){if(u)return s=!0,d(void 0);u=!0;var e=nr(n._readableStreamController);return null===e?_():v(e._view,!0),d(void 0)}function w(o){if(c=!0,r=o,p){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function R(o){if(p=!0,t=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return b}function T(){}return o=Jt(T,y,w),n=Jt(T,S,R),h(a),[o,n]}(e):function(e){var r,t,o,n,i,a=X(e),u=!1,l=!1,s=!1,c=!1,p=f(function(e){i=e});function b(){return u?(l=!0,d(void 0)):(u=!0,ue(a,{_chunkSteps:function(e){g(function(){l=!1;var r=e,t=e;s||zt(o._readableStreamController,r),c||zt(n._readableStreamController,t),u=!1,l&&b()})},_closeSteps:function(){u=!1,s||At(o._readableStreamController),c||At(n._readableStreamController),s&&c||i(void 0)},_errorSteps:function(){u=!1}}),d(void 0))}function h(o){if(s=!0,r=o,c){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function _(o){if(c=!0,t=o,s){var n=fe([r,t]),a=eo(e,n);i(a)}return p}function v(){}return o=Xt(v,b,h),n=Xt(v,b,_),m(a._closedPromise,function(e){return Dt(o._readableStreamController,e),Dt(n._readableStreamController,e),s&&c||i(void 0),null}),[o,n]}(e)}function Yt(e){return o(r=e)&&void 0!==r.getReader?function(e){var r;function n(){var t;try{t=e.read()}catch(e){return p(e)}return v(t,function(e){if(!o(e))throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function i(r){try{return d(e.cancel(r))}catch(e){return p(e)}}return r=Xt(t,n,i,0),r}(e.getReader()):function(e){var r,n=ge(e,"async");function i(){var e;try{e=Se(n)}catch(e){return p(e)}return v(d(e),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");if(e.done)At(r._readableStreamController);else{var t=e.value;zt(r._readableStreamController,t)}})}function a(e){var r,t=n.iterator;try{r=_e(t,"return")}catch(e){return p(e)}return void 0===r?d(void 0):v(w(r,t,[e]),function(e){if(!o(e))throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object")})}return r=Xt(t,i,a,0),r}(e);var r}function Qt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Nt(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function Ht(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function Vt(e,r){if("bytes"!==(e="".concat(e)))throw new TypeError("".concat(r," '").concat(e,"' is not a valid enumeration value for ReadableStreamType"));return e}function Ut(e,r){M(e,r);var t=null==e?void 0:e.preventAbort,o=null==e?void 0:e.preventCancel,n=null==e?void 0:e.preventClose,i=null==e?void 0:e.signal;return void 0!==i&&function(e,r){if(!function(e){if("object"!=typeof e||null===e)return!1;try{return"boolean"==typeof e.aborted}catch(e){return!1}}(e))throw new TypeError("".concat(r," is not an AbortSignal."))}(i,"".concat(r," has member 'signal' that")),{preventAbort:Boolean(t),preventCancel:Boolean(o),preventClose:Boolean(n),signal:i}}Object.defineProperties(Wt.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),i(Wt.prototype.close,"close"),i(Wt.prototype.enqueue,"enqueue"),i(Wt.prototype.error,"error"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Wt.prototype,r.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});var Gt=function(){function ReadableStream(e,r){void 0===e&&(e={}),void 0===r&&(r={}),void 0===e?e=null:Y(e,"First parameter");var t=Pr(r,"Second parameter"),o=function(e,r){M(e,r);var t=e,o=null==t?void 0:t.autoAllocateChunkSize,n=null==t?void 0:t.cancel,i=null==t?void 0:t.pull,a=null==t?void 0:t.start,u=null==t?void 0:t.type;return{autoAllocateChunkSize:void 0===o?void 0:U(o,"".concat(r," has member 'autoAllocateChunkSize' that")),cancel:void 0===n?void 0:Qt(n,t,"".concat(r," has member 'cancel' that")),pull:void 0===i?void 0:Nt(i,t,"".concat(r," has member 'pull' that")),start:void 0===a?void 0:Ht(a,t,"".concat(r," has member 'start' that")),type:void 0===u?void 0:Vt(u,"".concat(r," has member 'type' that"))}}(e,"First parameter");if(Kt(this),"bytes"===o.type){if(void 0!==t.size)throw new RangeError("The strategy for a byte stream cannot have a size function");!function(e,r,t){var o,n,i,a=Object.create(ze.prototype);o=void 0!==r.start?function(){return r.start(a)}:function(){},n=void 0!==r.pull?function(){return r.pull(a)}:function(){return d(void 0)},i=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};var u=r.autoAllocateChunkSize;if(0===u)throw new TypeError("autoAllocateChunkSize must be greater than 0");lr(e,a,o,n,i,t,u)}(this,o,Rr(t,0))}else{var n=Tr(t);!function(e,r,t,o){var n,i,a,u=Object.create(Wt.prototype);n=void 0!==r.start?function(){return r.start(u)}:function(){},i=void 0!==r.pull?function(){return r.pull(u)}:function(){return d(void 0)},a=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)},It(e,u,n,i,a,t,o)}(this,o,Rr(t,1),n)}}return Object.defineProperty(ReadableStream.prototype,"locked",{get:function(){if(!Zt(this))throw oo("locked");return $t(this)},enumerable:!1,configurable:!0}),ReadableStream.prototype.cancel=function(e){return void 0===e&&(e=void 0),Zt(this)?$t(this)?p(new TypeError("Cannot cancel a stream that already has a reader")):eo(this,e):p(oo("cancel"))},ReadableStream.prototype.getReader=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("getReader");return void 0===function(e,r){M(e,r);var t=null==e?void 0:e.mode;return{mode:void 0===t?void 0:fr(t,"".concat(r," has member 'mode' that"))}}(e,"First parameter").mode?X(this):dr(this)},ReadableStream.prototype.pipeThrough=function(e,r){if(void 0===r&&(r={}),!Zt(this))throw oo("pipeThrough");Q(e,1,"pipeThrough");var t=function(e,r){M(e,r);var t=null==e?void 0:e.readable;N(t,"readable","ReadableWritablePair"),G(t,"".concat(r," has member 'readable' that"));var o=null==e?void 0:e.writable;return N(o,"writable","ReadableWritablePair"),jr(o,"".concat(r," has member 'writable' that")),{readable:t,writable:o}}(e,"First parameter"),o=Ut(r,"Second parameter");if($t(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(Dr(t.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return y(Tt(this,t.writable,o.preventClose,o.preventAbort,o.preventCancel,o.signal)),t.readable},ReadableStream.prototype.pipeTo=function(e,r){if(void 0===r&&(r={}),!Zt(this))return p(oo("pipeTo"));if(void 0===e)return p("Parameter 1 is required in 'pipeTo'.");if(!zr(e))return p(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));var t;try{t=Ut(r,"Second parameter")}catch(e){return p(e)}return $t(this)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):Dr(e)?p(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Tt(this,e,t.preventClose,t.preventAbort,t.preventCancel,t.signal)},ReadableStream.prototype.tee=function(){if(!Zt(this))throw oo("tee");return fe(xt(this))},ReadableStream.prototype.values=function(e){if(void 0===e&&(e=void 0),!Zt(this))throw oo("values");var r,t,o,n,i,a=function(e,r){M(e,r);var t=null==e?void 0:e.preventCancel;return{preventCancel:Boolean(t)}}(e,"First parameter");return r=this,t=a.preventCancel,o=X(r),n=new we(o,t),(i=Object.create(Te))._asyncIteratorImpl=n,i},ReadableStream.prototype[ye]=function(e){return this.values(e)},ReadableStream.from=function(e){return Yt(e)},ReadableStream}();function Xt(e,r,t,o,n){void 0===o&&(o=1),void 0===n&&(n=function(){return 1});var i=Object.create(Gt.prototype);return Kt(i),It(i,Object.create(Wt.prototype),e,r,t,o,n),i}function Jt(e,r,t){var o=Object.create(Gt.prototype);return Kt(o),lr(o,Object.create(ze.prototype),e,r,t,0,void 0),o}function Kt(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function Zt(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")&&e instanceof Gt)}function $t(e){return void 0!==e._reader}function eo(e,r){if(e._disturbed=!0,"closed"===e._state)return d(void 0);if("errored"===e._state)return p(e._storedError);ro(e);var o=e._reader;if(void 0!==o&&yr(o)){var n=o._readIntoRequests;o._readIntoRequests=new R,n.forEach(function(e){e._closeSteps(void 0)})}return v(e._readableStreamController[C](r),t)}function ro(e){e._state="closed";var r=e._reader;if(void 0!==r&&(F(r),ae(r))){var t=r._readRequests;r._readRequests=new R,t.forEach(function(e){e._closeSteps()})}}function to(e,r){e._state="errored",e._storedError=r;var t=e._reader;void 0!==t&&(D(t,r),ae(t)?se(t,r):Sr(t,r))}function oo(e){return new TypeError("ReadableStream.prototype.".concat(e," can only be used on a ReadableStream"))}function no(e,r){M(e,r);var t=null==e?void 0:e.highWaterMark;return N(t,"highWaterMark","QueuingStrategyInit"),{highWaterMark:H(t)}}Object.defineProperties(Gt,{from:{enumerable:!0}}),Object.defineProperties(Gt.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),i(Gt.from,"from"),i(Gt.prototype.cancel,"cancel"),i(Gt.prototype.getReader,"getReader"),i(Gt.prototype.pipeThrough,"pipeThrough"),i(Gt.prototype.pipeTo,"pipeTo"),i(Gt.prototype.tee,"tee"),i(Gt.prototype.values,"values"),"symbol"==typeof r.toStringTag&&Object.defineProperty(Gt.prototype,r.toStringTag,{value:"ReadableStream",configurable:!0}),Object.defineProperty(Gt.prototype,ye,{value:Gt.prototype.values,writable:!0,configurable:!0});var io=function(e){return e.byteLength};i(io,"size");var ao=function(){function ByteLengthQueuingStrategy(e){Q(e,1,"ByteLengthQueuingStrategy"),e=no(e,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(ByteLengthQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!lo(this))throw uo("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(ByteLengthQueuingStrategy.prototype,"size",{get:function(){if(!lo(this))throw uo("size");return io},enumerable:!1,configurable:!0}),ByteLengthQueuingStrategy}();function uo(e){return new TypeError("ByteLengthQueuingStrategy.prototype.".concat(e," can only be used on a ByteLengthQueuingStrategy"))}function lo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")&&e instanceof ao)}Object.defineProperties(ao.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(ao.prototype,r.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});var so=function(){return 1};i(so,"size");var co=function(){function CountQueuingStrategy(e){Q(e,1,"CountQueuingStrategy"),e=no(e,"First parameter"),this._countQueuingStrategyHighWaterMark=e.highWaterMark}return Object.defineProperty(CountQueuingStrategy.prototype,"highWaterMark",{get:function(){if(!po(this))throw fo("highWaterMark");return this._countQueuingStrategyHighWaterMark},enumerable:!1,configurable:!0}),Object.defineProperty(CountQueuingStrategy.prototype,"size",{get:function(){if(!po(this))throw fo("size");return so},enumerable:!1,configurable:!0}),CountQueuingStrategy}();function fo(e){return new TypeError("CountQueuingStrategy.prototype.".concat(e," can only be used on a CountQueuingStrategy"))}function po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")&&e instanceof co)}function bo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}function ho(e,r,t){return x(e,t),function(t){return S(e,r,[t])}}function _o(e,r,t){return x(e,t),function(t,o){return w(e,r,[t,o])}}function mo(e,r,t){return x(e,t),function(t){return w(e,r,[t])}}Object.defineProperties(co.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(co.prototype,r.toStringTag,{value:"CountQueuingStrategy",configurable:!0});var vo=function(){function TransformStream(e,r,t){void 0===e&&(e={}),void 0===r&&(r={}),void 0===t&&(t={}),void 0===e&&(e=null);var o=Pr(r,"Second parameter"),n=Pr(t,"Third parameter"),i=function(e,r){M(e,r);var t=null==e?void 0:e.cancel,o=null==e?void 0:e.flush,n=null==e?void 0:e.readableType,i=null==e?void 0:e.start,a=null==e?void 0:e.transform,u=null==e?void 0:e.writableType;return{cancel:void 0===t?void 0:mo(t,e,"".concat(r," has member 'cancel' that")),flush:void 0===o?void 0:bo(o,e,"".concat(r," has member 'flush' that")),readableType:n,start:void 0===i?void 0:ho(i,e,"".concat(r," has member 'start' that")),transform:void 0===a?void 0:_o(a,e,"".concat(r," has member 'transform' that")),writableType:u}}(e,"First parameter");if(void 0!==i.readableType)throw new RangeError("Invalid readableType specified");if(void 0!==i.writableType)throw new RangeError("Invalid writableType specified");var a,u=Rr(n,0),l=Tr(n),s=Rr(o,1),c=Tr(o);!function(e,r,t,o,n,i){function a(){return r}function u(r){return function(e,r){var t=e._transformStreamController;if(e._backpressure){return v(e._backpressureChangePromise,function(){var o=e._writable;if("erroring"===o._state)throw o._storedError;return Eo(t,r)})}return Eo(t,r)}(e,r)}function l(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._readable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(Dt(o._readableStreamController,r),Oo(t)),null},function(e){return Dt(o._readableStreamController,e),jo(t,e),null}),t._finishPromise}(e,r)}function s(){return function(e){var r=e._transformStreamController;if(void 0!==r._finishPromise)return r._finishPromise;var t=e._readable;r._finishPromise=f(function(e,t){r._finishPromise_resolve=e,r._finishPromise_reject=t});var o=r._flushAlgorithm();return Co(r),h(o,function(){return"errored"===t._state?jo(r,t._storedError):(At(t._readableStreamController),Oo(r)),null},function(e){return Dt(t._readableStreamController,e),jo(r,e),null}),r._finishPromise}(e)}function c(){return function(e){return Ro(e,!1),e._backpressureChangePromise}(e)}function d(r){return function(e,r){var t=e._transformStreamController;if(void 0!==t._finishPromise)return t._finishPromise;var o=e._writable;t._finishPromise=f(function(e,r){t._finishPromise_resolve=e,t._finishPromise_reject=r});var n=t._cancelAlgorithm(r);return Co(t),h(n,function(){return"errored"===o._state?jo(t,o._storedError):(it(o._writableStreamController,r),wo(e),Oo(t)),null},function(r){return it(o._writableStreamController,r),wo(e),jo(t,r),null}),t._finishPromise}(e,r)}e._writable=function(e,r,t,o,n,i){void 0===n&&(n=1),void 0===i&&(i=function(){return 1});var a=Object.create(Br.prototype);return Ar(a),rt(a,Object.create($r.prototype),e,r,t,o,n,i),a}(a,u,s,l,t,o),e._readable=Xt(a,c,d,n,i),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,Ro(e,!0),e._transformStreamController=void 0}(this,f(function(e){a=e}),s,c,u,l),function(e,r){var t,o,n,i=Object.create(To.prototype);t=void 0!==r.transform?function(e){return r.transform(e,i)}:function(e){try{return qo(i,e),d(void 0)}catch(e){return p(e)}};o=void 0!==r.flush?function(){return r.flush(i)}:function(){return d(void 0)};n=void 0!==r.cancel?function(e){return r.cancel(e)}:function(){return d(void 0)};!function(e,r,t,o,n){r._controlledTransformStream=e,e._transformStreamController=r,r._transformAlgorithm=t,r._flushAlgorithm=o,r._cancelAlgorithm=n,r._finishPromise=void 0,r._finishPromise_resolve=void 0,r._finishPromise_reject=void 0}(e,i,t,o,n)}(this,i),void 0!==i.start?a(i.start(this._transformStreamController)):a(void 0)}return Object.defineProperty(TransformStream.prototype,"readable",{get:function(){if(!yo(this))throw Bo("readable");return this._readable},enumerable:!1,configurable:!0}),Object.defineProperty(TransformStream.prototype,"writable",{get:function(){if(!yo(this))throw Bo("writable");return this._writable},enumerable:!1,configurable:!0}),TransformStream}();function yo(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")&&e instanceof vo)}function go(e,r){Dt(e._readable._readableStreamController,r),So(e,r)}function So(e,r){Co(e._transformStreamController),it(e._writable._writableStreamController,r),wo(e)}function wo(e){e._backpressure&&Ro(e,!1)}function Ro(e,r){void 0!==e._backpressureChangePromise&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=f(function(r){e._backpressureChangePromise_resolve=r}),e._backpressure=r}Object.defineProperties(vo.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),"symbol"==typeof r.toStringTag&&Object.defineProperty(vo.prototype,r.toStringTag,{value:"TransformStream",configurable:!0});var To=function(){function TransformStreamDefaultController(){throw new TypeError("Illegal constructor")}return Object.defineProperty(TransformStreamDefaultController.prototype,"desiredSize",{get:function(){if(!Po(this))throw Wo("desiredSize");return Ft(this._controlledTransformStream._readable._readableStreamController)},enumerable:!1,configurable:!0}),TransformStreamDefaultController.prototype.enqueue=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("enqueue");qo(this,e)},TransformStreamDefaultController.prototype.error=function(e){if(void 0===e&&(e=void 0),!Po(this))throw Wo("error");var r;r=e,go(this._controlledTransformStream,r)},TransformStreamDefaultController.prototype.terminate=function(){if(!Po(this))throw Wo("terminate");!function(e){var r=e._controlledTransformStream;At(r._readable._readableStreamController);var t=new TypeError("TransformStream terminated");So(r,t)}(this)},TransformStreamDefaultController}();function Po(e){return!!o(e)&&(!!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")&&e instanceof To)}function Co(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0,e._cancelAlgorithm=void 0}function qo(e,r){var t=e._controlledTransformStream,o=t._readable._readableStreamController;if(!Lt(o))throw new TypeError("Readable side is not in a state that permits enqueue");try{zt(o,r)}catch(e){throw So(t,e),t._readable._storedError}var n=function(e){return!Bt(e)}(o);n!==t._backpressure&&Ro(t,!0)}function Eo(e,r){return v(e._transformAlgorithm(r),void 0,function(r){throw go(e._controlledTransformStream,r),r})}function Wo(e){return new TypeError("TransformStreamDefaultController.prototype.".concat(e," can only be used on a TransformStreamDefaultController"))}function Oo(e){void 0!==e._finishPromise_resolve&&(e._finishPromise_resolve(),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function jo(e,r){void 0!==e._finishPromise_reject&&(y(e._finishPromise),e._finishPromise_reject(r),e._finishPromise_resolve=void 0,e._finishPromise_reject=void 0)}function Bo(e){return new TypeError("TransformStream.prototype.".concat(e," can only be used on a TransformStream"))}Object.defineProperties(To.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),i(To.prototype.enqueue,"enqueue"),i(To.prototype.error,"error"),i(To.prototype.terminate,"terminate"),"symbol"==typeof r.toStringTag&&Object.defineProperty(To.prototype,r.toStringTag,{value:"TransformStreamDefaultController",configurable:!0}),e.ByteLengthQueuingStrategy=ao,e.CountQueuingStrategy=co,e.ReadableByteStreamController=ze,e.ReadableStream=Gt,e.ReadableStreamBYOBReader=_r,e.ReadableStreamBYOBRequest=Ae,e.ReadableStreamDefaultController=Wt,e.ReadableStreamDefaultReader=ee,e.TransformStream=vo,e.TransformStreamDefaultController=To,e.WritableStream=Br,e.WritableStreamDefaultController=$r,e.WritableStreamDefaultWriter=Hr}); diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..254b10dc 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -78,6 +78,7 @@ target_link_libraries(UnitTests PRIVATE Performance PRIVATE TextDecoder PRIVATE TextEncoder + PRIVATE Streams ${ADDITIONAL_LIBRARIES}) # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..6b153c59 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1541,6 +1541,162 @@ describe("Console", function () { }); }); +describe("Web Streams", function () { + // Focused ports from the WHATWG Streams WPT suites at c05b4473: + // readable-streams/general.any.js and tee.any.js, + // writable-streams/write.any.js, and transform-streams/general.any.js. + it("installs the standard stream constructors", function () { + expect(ReadableStream).to.be.a("function"); + expect(WritableStream).to.be.a("function"); + expect(TransformStream).to.be.a("function"); + expect(ByteLengthQueuingStrategy).to.be.a("function"); + expect(CountQueuingStrategy).to.be.a("function"); + }); + + it("delivers queued chunks in order and closes the reader", async function () { + const stream = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }); + const reader = stream.getReader(); + + expect(await reader.read()).to.deep.equal({ value: "a", done: false }); + expect(await reader.read()).to.deep.equal({ value: "b", done: false }); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + await reader.closed; + }); + + it("propagates a rejected pull to read and closed", async function () { + const failure = new Error("pull failed"); + const reader = new ReadableStream({ + pull() { + return Promise.reject(failure); + } + }).getReader(); + + let readFailure: unknown; + let closedFailure: unknown; + try { await reader.read(); } catch (error) { readFailure = error; } + try { await reader.closed; } catch (error) { closedFailure = error; } + expect(readFailure).to.equal(failure); + expect(closedFailure).to.equal(failure); + }); + + it("tees without one branch consuming the other", async function () { + const [first, second] = new ReadableStream({ + start(controller) { + controller.enqueue("a"); + controller.enqueue("b"); + controller.close(); + } + }).tee(); + const firstReader = first.getReader(); + const secondReader = second.getReader(); + + expect(await firstReader.read()).to.deep.equal({ value: "a", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: "b", done: false }); + expect(await firstReader.read()).to.deep.equal({ value: undefined, done: true }); + expect(await secondReader.read()).to.deep.equal({ value: "a", done: false }); + }); + + it("waits for asynchronous writes before closing", async function () { + const stored: number[] = []; + const writable = new WritableStream({ + write(chunk) { + return Promise.resolve().then(() => stored.push(chunk)); + } + }); + const writer = writable.getWriter(); + + writer.write(1); + writer.write(2); + await writer.close(); + expect(stored).to.deep.equal([1, 2]); + }); + + it("applies transform output and backpressure", async function () { + const transform = new TransformStream({ + transform(chunk, controller) { + controller.enqueue(chunk.toUpperCase()); + } + }); + const writer = transform.writable.getWriter(); + const reader = transform.readable.getReader(); + const write = writer.write("native"); + + expect(await reader.read()).to.deep.equal({ value: "NATIVE", done: false }); + await write; + await writer.close(); + expect(await reader.read()).to.deep.equal({ value: undefined, done: true }); + }); + + it("supports BYOB reads from byte streams", async function () { + let sent = false; + const stream = new ReadableStream({ + type: "bytes", + pull(controller) { + if (!sent) { + sent = true; + controller.enqueue(new Uint8Array([8, 241, 48, 123, 151])); + controller.close(); + } + } + } as any); + const reader = stream.getReader({ mode: "byob" }); + const result = await reader.read(new Uint8Array(8)); + + expect(result.done).to.equal(false); + expect(Array.from(result.value!)).to.deep.equal([8, 241, 48, 123, 151]); + expect((await reader.read(new Uint8Array(8))).done).to.equal(true); + }); + + // Ported from Firefox's dom/streams/test/xpcshell/subclassing.js. + it("supports subclassed streams, readers, and queuing strategies", async function () { + class SubclassedStream extends ReadableStream {} + class SubclassedStrategy extends CountQueuingStrategy {} + const stream = new SubclassedStream({ + start(controller) { + controller.enqueue("first"); + controller.close(); + } + }); + const Reader = stream.getReader().constructor as typeof ReadableStreamDefaultReader; + class SubclassedReader extends Reader {} + + expect(stream).to.be.instanceOf(ReadableStream); + expect(new SubclassedStrategy({ highWaterMark: 4 }).highWaterMark).to.equal(4); + + const secondStream = new ReadableStream({ + start(controller) { + controller.enqueue("second"); + controller.close(); + } + }); + const reader = new SubclassedReader(secondStream); + expect(await reader.read()).to.deep.equal({ value: "second", done: false }); + }); + + // Ported from Chromium's http/tests/streams/chromium/transform-stream-enqueue.html. + it("rejects enqueues after a transform is terminated or errored", function () { + expect(() => new TransformStream({ + start(controller) { + controller.terminate(); + controller.enqueue("late"); + } + })).to.throw(TypeError); + + expect(() => new TransformStream({ + start(controller) { + controller.error(new Error("failed")); + controller.enqueue("late"); + } + })).to.throw(TypeError); + }); +}); + describe("Blob", function () { let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..b71218bd 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -90,6 +91,7 @@ TEST(JavaScript, All) Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -166,6 +168,30 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } +TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); + global.Set("ReadableStream", hostReadableStream); + + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").IsFunction()); + + const auto installedTransformStream = global.Get("TransformStream"); + Babylon::Polyfills::Streams::Initialize(env); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 8e8ff8fc3eeb375aee07543988eb340636b9a573 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 22:19:21 -0700 Subject: [PATCH 088/174] Complete Blob streaming and slicing support Implement iterable BlobPart conversion, MIME and endings normalization, zero-copy Blob composition and slicing, and lazy 64 KiB byte streams. Delegate File streaming and slicing to its backing Blob while preserving browser class identity.\n\nUse immutable shared segments so nested Blob and slice construction do not duplicate payload bytes. Add focused WPT, WebKit, and Firefox regression coverage for constructor ordering, iterator closure, UTF-8 decoding, BYOB reads, cancellation, lifetime safety, and large nested streams. --- Polyfills/Blob/CMakeLists.txt | 1 + Polyfills/Blob/README.md | 12 + Polyfills/Blob/Source/Blob.cpp | 507 ++++++++++++++++++++++++++++--- Polyfills/Blob/Source/Blob.h | 27 +- Polyfills/File/Source/File.cpp | 47 ++- Polyfills/File/Source/File.h | 2 + Tests/UnitTests/Scripts/tests.ts | 227 ++++++++++++++ 7 files changed, 761 insertions(+), 62 deletions(-) create mode 100644 Polyfills/Blob/README.md diff --git a/Polyfills/Blob/CMakeLists.txt b/Polyfills/Blob/CMakeLists.txt index b8da610e..d2f9d88f 100644 --- a/Polyfills/Blob/CMakeLists.txt +++ b/Polyfills/Blob/CMakeLists.txt @@ -1,6 +1,7 @@ set(SOURCES "Include/Babylon/Polyfills/Blob.h" "InternalInclude/Babylon/Polyfills/BlobInternal.h" + "README.md" "Source/Blob.cpp" "Source/Blob.h") diff --git a/Polyfills/Blob/README.md b/Polyfills/Blob/README.md new file mode 100644 index 00000000..2206f9c4 --- /dev/null +++ b/Polyfills/Blob/README.md @@ -0,0 +1,12 @@ +# Blob + +Provides the browser `Blob` constructor, byte/text readers, zero-copy Blob +composition and slicing, and a lazily pulled byte `ReadableStream`. + +Call `Babylon::Polyfills::Streams::Initialize` before using `Blob.stream()` on +engines that do not provide Web Streams. Stream reads copy only the requested +chunk into JavaScript-owned memory; composing Blobs and slicing share immutable +native byte segments. + +The focused tests are adapted from WPT `FileAPI/blob`, WebKit's Blob stream +chunk/crash regressions, and Firefox's large Blob `pipeTo` regression. diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 242763fe..bed99cb6 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -3,8 +3,63 @@ #include #include +#include +#include +#include + namespace Babylon::Polyfills::Internal { + struct Blob::Segment + { + std::shared_ptr> Bytes; + size_t Offset{}; + size_t Length{}; + }; + + struct Blob::Storage + { + std::vector Segments; + size_t Size{}; + + void Append(const Segment& segment) + { + if (segment.Length == 0) + { + return; + } + + Segments.emplace_back(segment); + Size += segment.Length; + } + + void CopyTo(size_t position, std::byte* destination, size_t length) const + { + size_t segmentStart{}; + for (const auto& segment : Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + if (position < segmentEnd && length > 0) + { + const auto localOffset = position > segmentStart ? position - segmentStart : 0; + const auto copyLength = std::min(segment.Length - localOffset, length); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + localOffset, copyLength); + destination += copyLength; + position += copyLength; + length -= copyLength; + } + segmentStart = segmentEnd; + } + } + }; + + struct Blob::StreamState + { + std::shared_ptr BlobData; + size_t Position{}; + size_t SegmentIndex{}; + size_t SegmentOffset{}; + }; + void Blob::Initialize(Napi::Env env) { static constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; @@ -19,8 +74,14 @@ namespace Babylon::Polyfills::Internal InstanceMethod("text", &Blob::Text), InstanceMethod("arrayBuffer", &Blob::ArrayBuffer), InstanceMethod("bytes", &Blob::Bytes), + InstanceMethod("slice", &Blob::Slice), + InstanceMethod("stream", &Blob::Stream), }); + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_BLOB_CONSTRUCTOR_NAME); + env.Global().Get("Object").As().Get("defineProperty").As().Call(env.Global().Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -28,36 +89,122 @@ namespace Babylon::Polyfills::Internal Blob::Blob(const Napi::CallbackInfo& info) : Napi::ObjectWrap(info) { - if (info.Length() > 0) + auto env = Env(); + auto data = std::make_shared(); + std::vector stringSegmentIndices; + bool convertLineEndings{}; + + if (info.Length() > 0 && !info[0].IsUndefined()) { - const auto blobParts = info[0].As(); + if (!info[0].IsObject() && !info[0].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob parts must be an iterable object."); + } + + const auto blobParts = info[0].As(); + if (blobParts.IsArray()) + { + data->Segments.reserve(blobParts.As().Length()); + } - if (blobParts.Length() > 0) + const auto reflect = env.Global().Get("Reflect").As(); + const auto iteratorMethod = reflect.Get("get").As().Call( + reflect, + {blobParts, Napi::Symbol::WellKnown(env, "iterator")}); + if (!iteratorMethod.IsFunction()) { - const auto firstPart = blobParts.Get(uint32_t{0}); - ProcessBlobPart(firstPart); + throw Napi::TypeError::New(env, "Blob parts must be iterable."); + } - if (blobParts.Length() > 1) + const auto iterator = iteratorMethod.As().Call(blobParts, {}).As(); + const auto next = iterator.Get("next").As(); + try + { + while (true) { - throw Napi::Error::New(Env(), "Using multiple BlobParts in Blob constructor is not implemented."); + const auto result = next.Call(iterator, {}).As(); + if (result.Get("done").ToBoolean().Value()) + { + break; + } + + if (AppendBlobPart(*data, result.Get("value"))) + { + stringSegmentIndices.emplace_back(data->Segments.size() - 1); + } } } + catch (...) + { + try + { + const auto returnMethod = iterator.Get("return"); + if (returnMethod.IsFunction()) + { + returnMethod.As().Call(iterator, {}); + } + } + catch (...) + { + // Preserve the exception that interrupted part conversion. + } + throw; + } } - if (info.Length() > 1) + if (info.Length() > 1 && !info[1].IsUndefined() && !info[1].IsNull()) { + if (!info[1].IsObject() && !info[1].IsFunction()) + { + throw Napi::TypeError::New(env, "Blob options must be an object."); + } + const auto options = info[1].As(); + const auto endings = options.Get("endings"); + if (!endings.IsUndefined()) + { + const auto value = endings.ToString().Utf8Value(); + if (value != "transparent" && value != "native") + { + throw Napi::TypeError::New(env, "Blob endings must be 'transparent' or 'native'."); + } + convertLineEndings = value == "native"; + } + + const auto type = options.Get("type"); + if (!type.IsUndefined()) + { + m_type = NormalizeType(type.ToString().Utf8Value()); + } + } - if (options.Has("type")) + if (convertLineEndings) + { + for (const auto segmentIndex : stringSegmentIndices) { - m_type = options.Get("type").As().Utf8Value(); + auto& segment = data->Segments[segmentIndex]; + auto value = std::string{ + reinterpret_cast(segment.Bytes->data() + segment.Offset), + segment.Length}; + value = NormalizeLineEndings(std::move(value)); + + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data->Size -= segment.Length; + segment = {std::move(bytes), 0, value.size()}; + data->Size += segment.Length; } } + + m_data = std::move(data); } Napi::Value Blob::GetSize(const Napi::CallbackInfo&) { - return Napi::Value::From(Env(), m_data->size()); + return Napi::Value::From(Env(), m_data->Size); } Napi::Value Blob::GetType(const Napi::CallbackInfo&) @@ -68,8 +215,11 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::Text(const Napi::CallbackInfo&) { // NOTE: This will not check for UTF-8 validity - const auto begin = reinterpret_cast(m_data->data()); - std::string text(begin, m_data->size()); + std::string text(m_data->Size, '\0'); + if (!text.empty()) + { + m_data->CopyTo(0, reinterpret_cast(text.data()), text.size()); + } const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(Napi::String::New(Env(), text)); @@ -78,60 +228,333 @@ namespace Babylon::Polyfills::Internal Napi::Value Blob::ArrayBuffer(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto deferred = Napi::Promise::Deferred::New(Env()); - deferred.Resolve(arrayBuffer); + deferred.Resolve(CreateArrayBuffer()); return deferred.Promise(); } Napi::Value Blob::Bytes(const Napi::CallbackInfo&) { - const auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->size()); - if (m_data->data()) - { - std::memcpy(arrayBuffer.Data(), m_data->data(), m_data->size()); - } - const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->size(), arrayBuffer, 0); + const auto arrayBuffer = CreateArrayBuffer(); + const auto uint8Array = Napi::Uint8Array::New(Env(), m_data->Size, arrayBuffer, 0); const auto deferred = Napi::Promise::Deferred::New(Env()); deferred.Resolve(uint8Array); return deferred.Promise(); } - void Blob::ProcessBlobPart(const Napi::Value& blobPart) + Napi::Value Blob::Slice(const Napi::CallbackInfo& info) { + const auto start = NormalizeSliceIndex( + info.Length() > 0 && !info[0].IsUndefined() ? info[0].ToNumber().DoubleValue() : 0, + m_data->Size); + const auto end = NormalizeSliceIndex( + info.Length() > 1 && !info[1].IsUndefined() ? info[1].ToNumber().DoubleValue() : static_cast(m_data->Size), + m_data->Size); + const auto sliceEnd = std::max(start, end); + + auto sliceData = std::make_shared(); + size_t segmentStart{}; + for (const auto& segment : m_data->Segments) + { + const auto segmentEnd = segmentStart + segment.Length; + const auto overlapStart = std::max(start, segmentStart); + const auto overlapEnd = std::min(sliceEnd, segmentEnd); + if (overlapStart < overlapEnd) + { + sliceData->Append({segment.Bytes, segment.Offset + overlapStart - segmentStart, overlapEnd - overlapStart}); + } + segmentStart = segmentEnd; + if (segmentStart >= sliceEnd) + { + break; + } + } + + std::string contentType; + if (info.Length() > 2 && !info[2].IsUndefined()) + { + contentType = NormalizeType(info[2].ToString().Utf8Value()); + } + + const auto blobConstructor = Env().Global().Get("Blob").As(); + const auto result = blobConstructor.New({Napi::Array::New(Env())}); + auto resultBlob = Napi::ObjectWrap::Unwrap(result); + resultBlob->m_data = std::move(sliceData); + resultBlob->m_type = std::move(contentType); + return result; + } + + Napi::Value Blob::Stream(const Napi::CallbackInfo& info) + { + auto env = info.Env(); + const auto readableStreamValue = env.Global().Get("ReadableStream"); + if (!readableStreamValue.IsFunction()) + { + throw Napi::TypeError::New(env, "Blob.stream() requires ReadableStream to be installed."); + } + + auto state = std::make_shared(); + state->BlobData = m_data; + + auto source = Napi::Object::New(env); + source.Set("type", "bytes"); + source.Set("pull", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + auto callbackEnv = callbackInfo.Env(); + auto controller = callbackInfo[0].As(); + if (!state->BlobData || state->Position >= state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + return callbackEnv.Undefined(); + } + + constexpr size_t CHUNK_SIZE = 64 * 1024; + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + auto destination = static_cast(outputBuffer.Data()); + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + + if (state->Position == state->BlobData->Size) + { + controller.Get("close").As().Call(controller, {}); + state->BlobData.reset(); + } + + return callbackEnv.Undefined(); + })); + source.Set("cancel", Napi::Function::New(env, [state](const Napi::CallbackInfo& callbackInfo) -> Napi::Value { + state->BlobData.reset(); + return callbackInfo.Env().Undefined(); + })); + + return readableStreamValue.As().New({source}); + } + + bool Blob::AppendBlobPart(Storage& data, const Napi::Value& blobPart) + { + const std::byte* source{}; + size_t length{}; + bool isBufferSource{}; + if (blobPart.IsArrayBuffer()) { const auto buffer = blobPart.As(); - const auto begin = static_cast(buffer.Data()); - m_data = std::make_shared>(begin, begin + buffer.ByteLength()); + source = static_cast(buffer.Data()); + length = buffer.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsTypedArray() || blobPart.IsDataView()) + else if (blobPart.IsTypedArray()) { const auto array = blobPart.As(); const auto buffer = array.ArrayBuffer(); - const auto begin = static_cast(buffer.Data()) + array.ByteOffset(); - m_data = std::make_shared>(begin, begin + array.ByteLength()); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + array.ByteOffset(); + length = array.ByteLength(); + isBufferSource = true; + } + else if (blobPart.IsDataView()) + { + const auto view = blobPart.As(); + const auto buffer = view.ArrayBuffer(); + const auto bufferData = static_cast(buffer.Data()); + source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); + length = view.ByteLength(); + isBufferSource = true; } - else if (blobPart.IsString()) + else if (blobPart.IsObject()) { - const auto str = blobPart.As().Utf8Value(); - const auto begin = reinterpret_cast(str.data()); - m_data = std::make_shared>(begin, begin + str.length()); + const auto object = blobPart.As(); + const auto blobConstructor = Env().Global().Get("Blob").As(); + if (object.InstanceOf(blobConstructor)) + { + auto nativeBlob = object; + if (!object.Get("constructor").StrictEquals(blobConstructor)) + { + nativeBlob = object.Get("slice").As().Call(object, {Napi::Number::New(Env(), 0), object.Get("size")}).As(); + } + + const auto blob = Napi::ObjectWrap::Unwrap(nativeBlob); + data.Segments.reserve(data.Segments.size() + blob->m_data->Segments.size()); + for (const auto& segment : blob->m_data->Segments) + { + data.Append(segment); + } + return false; + } } - else + + if (isBufferSource) { - // Assume it's another Blob object. Blobs are immutable, so the buffer can be shared - // rather than copied. - const auto obj = blobPart.As(); - const auto blobObj = Napi::ObjectWrap::Unwrap(obj); - m_data = blobObj->m_data; + auto bytes = std::make_shared>(length); + if (length > 0) + { + std::memcpy(bytes->data(), source, length); + } + data.Append({std::move(bytes), 0, length}); + return false; } + + auto value = blobPart.ToString().Utf8Value(); + auto bytes = std::make_shared>(value.size()); + if (!value.empty()) + { + std::memcpy(bytes->data(), value.data(), value.size()); + } + data.Append({std::move(bytes), 0, value.size()}); + return !value.empty(); + } + + Napi::ArrayBuffer Blob::CreateArrayBuffer() const + { + auto arrayBuffer = Napi::ArrayBuffer::New(Env(), m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, static_cast(arrayBuffer.Data()), m_data->Size); + } + return arrayBuffer; + } + + const std::shared_ptr>& Blob::Data() const + { + if (!m_contiguous) + { + const auto& segments = m_data->Segments; + if (segments.size() == 1 && segments[0].Offset == 0 && segments[0].Length == segments[0].Bytes->size()) + { + m_contiguous = segments[0].Bytes; + } + else + { + auto bytes = std::make_shared>(m_data->Size); + if (m_data->Size > 0) + { + m_data->CopyTo(0, bytes->data(), m_data->Size); + } + m_contiguous = std::move(bytes); + } + } + return m_contiguous; + } + + std::string Blob::NormalizeType(std::string type) + { + for (auto& character : type) + { + const auto value = static_cast(character); + if (value < 0x20 || value > 0x7E) + { + return {}; + } + if (character >= 'A' && character <= 'Z') + { + character = static_cast(character - 'A' + 'a'); + } + } + return type; + } + + std::string Blob::NormalizeLineEndings(std::string value) + { +#ifdef _WIN32 + static constexpr auto nativeNewline = "\r\n"; +#else + static constexpr auto nativeNewline = "\n"; +#endif + size_t outputLength{}; + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + outputLength += std::char_traits::length(nativeNewline); + } + else if (value[index] == '\n') + { + outputLength += std::char_traits::length(nativeNewline); + } + else + { + ++outputLength; + } + } + + std::string result; + result.reserve(outputLength); + for (size_t index{}; index < value.size(); ++index) + { + if (value[index] == '\r') + { + if (index + 1 < value.size() && value[index + 1] == '\n') + { + ++index; + } + result.append(nativeNewline); + } + else if (value[index] == '\n') + { + result.append(nativeNewline); + } + else + { + result.push_back(value[index]); + } + } + return result; + } + + size_t Blob::NormalizeSliceIndex(double value, size_t size) + { + if (std::isnan(value)) + { + return 0; + } + + const auto magnitude = std::abs(value); + const auto lower = std::floor(magnitude); + const auto fraction = magnitude - lower; + auto rounded = lower; + if (fraction > 0.5 || (fraction == 0.5 && std::fmod(lower, 2.0) != 0.0)) + { + rounded += 1.0; + } + + if (value < 0) + { + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? 0 + : size - static_cast(rounded); + } + + return !std::isfinite(rounded) || rounded >= static_cast(size) + ? size + : static_cast(rounded); } } diff --git a/Polyfills/Blob/Source/Blob.h b/Polyfills/Blob/Source/Blob.h index 5d0147d0..1f061f97 100644 --- a/Polyfills/Blob/Source/Blob.h +++ b/Polyfills/Blob/Source/Blob.h @@ -6,6 +6,7 @@ #include #include #include +#include namespace Babylon::Polyfills::Internal { @@ -17,9 +18,11 @@ namespace Babylon::Polyfills::Internal explicit Blob(const Napi::CallbackInfo& info); // Synchronous accessors for internal cross-polyfill use (e.g. URL.createObjectURL). - // A Blob is immutable once constructed, so the bytes are held in a shared_ptr and can be - // shared with consumers rather than copied. Never null. - const std::shared_ptr>& Data() const { return m_data; } + // A Blob is immutable once constructed, so its bytes can be shared with consumers rather + // than copied. Storage is segmented (slices and multi-part Blobs share their parts' + // buffers), so Data() hands back the one underlying buffer when there is exactly one, and + // otherwise materializes a contiguous copy once and caches it. Never null. + const std::shared_ptr>& Data() const; const std::string& Type() const { return m_type; } private: @@ -28,10 +31,22 @@ namespace Babylon::Polyfills::Internal Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); + + struct Segment; + struct Storage; + struct StreamState; + + bool AppendBlobPart(Storage& data, const Napi::Value& blobPart); + Napi::ArrayBuffer CreateArrayBuffer() const; - void ProcessBlobPart(const Napi::Value& blobPart); + static std::string NormalizeType(std::string type); + static std::string NormalizeLineEndings(std::string value); + static size_t NormalizeSliceIndex(double value, size_t size); - std::shared_ptr> m_data{std::make_shared>()}; + std::shared_ptr m_data; + mutable std::shared_ptr> m_contiguous; std::string m_type; }; -} \ No newline at end of file +} diff --git a/Polyfills/File/Source/File.cpp b/Polyfills/File/Source/File.cpp index 75261e79..47c07169 100644 --- a/Polyfills/File/Source/File.cpp +++ b/Polyfills/File/Source/File.cpp @@ -46,6 +46,8 @@ namespace Babylon::Polyfills::Internal InstanceMethod("arrayBuffer", &File::ArrayBuffer), InstanceMethod("text", &File::Text), InstanceMethod("bytes", &File::Bytes), + InstanceMethod("slice", &File::Slice), + InstanceMethod("stream", &File::Stream), }); global.Set(JS_FILE_CONSTRUCTOR_NAME, func); @@ -55,12 +57,16 @@ namespace Babylon::Polyfills::Internal // a Blob subtype; BJS core (fileTools, Offline/database, // abstractEngine, thinNativeEngine) branches on `instanceof Blob` // and needs File inputs to satisfy that check. - auto setPrototypeOf = env.Global().Get("Object").As() - .Get("setPrototypeOf").As(); + auto setPrototypeOf = env.Global().Get("Object").As().Get("setPrototypeOf").As(); setPrototypeOf.Call({ func.Get("prototype"), blob.As().Get("prototype"), }); + + auto descriptor = Napi::Object::New(env); + descriptor.Set("configurable", true); + descriptor.Set("value", JS_FILE_CONSTRUCTOR_NAME); + global.Get("Object").As().Get("defineProperty").As().Call(global.Get("Object"), {func.Get("prototype"), Napi::Symbol::WellKnown(env, "toStringTag"), descriptor}); } File::File(const Napi::CallbackInfo& info) @@ -75,7 +81,7 @@ namespace Babylon::Polyfills::Internal { throw Napi::TypeError::New(env, "Failed to construct 'File': 2 arguments required, but only " + - std::to_string(info.Length()) + " present."); + std::to_string(info.Length()) + " present."); } Napi::Value parts = info[0]; @@ -114,21 +120,11 @@ namespace Babylon::Polyfills::Internal } } - Napi::Value partsArray; - if (parts.IsArray()) - { - partsArray = parts; - } - else - { - partsArray = Napi::Array::New(env, 0); - } - // Delegate byte-buffer construction to the native Blob polyfill so // we benefit from its existing BlobPart handling (ArrayBuffer, // typed array, string, Blob). auto blobCtor = env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).As(); - auto blobInstance = blobCtor.New({partsArray, blobOptions}); + auto blobInstance = blobCtor.New({parts, blobOptions}); m_blob = Napi::Persistent(blobInstance); } @@ -169,6 +165,29 @@ namespace Babylon::Polyfills::Internal auto blob = m_blob.Value(); return blob.Get("bytes").As().Call(blob, {}); } + + Napi::Value File::Slice(const Napi::CallbackInfo& info) + { + auto blob = m_blob.Value(); + const auto slice = blob.Get("slice").As(); + switch (info.Length()) + { + case 0: + return slice.Call(blob, {}); + case 1: + return slice.Call(blob, {info[0]}); + case 2: + return slice.Call(blob, {info[0], info[1]}); + default: + return slice.Call(blob, {info[0], info[1], info[2]}); + } + } + + Napi::Value File::Stream(const Napi::CallbackInfo&) + { + auto blob = m_blob.Value(); + return blob.Get("stream").As().Call(blob, {}); + } } namespace Babylon::Polyfills::File diff --git a/Polyfills/File/Source/File.h b/Polyfills/File/Source/File.h index 9d73edb2..49473666 100644 --- a/Polyfills/File/Source/File.h +++ b/Polyfills/File/Source/File.h @@ -22,6 +22,8 @@ namespace Babylon::Polyfills::Internal Napi::Value ArrayBuffer(const Napi::CallbackInfo& info); Napi::Value Text(const Napi::CallbackInfo& info); Napi::Value Bytes(const Napi::CallbackInfo& info); + Napi::Value Slice(const Napi::CallbackInfo& info); + Napi::Value Stream(const Napi::CallbackInfo& info); Napi::ObjectReference m_blob; std::string m_name; diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 6b153c59..122cc1b2 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1698,8 +1698,24 @@ describe("Web Streams", function () { }); describe("Blob", function () { + this.timeout(10000); + let emptyBlobs: Blob[], helloBlobs: Blob[], stringBlob: Blob, typedArrayBlob: Blob, arrayBufferBlob: Blob, blobBlob: Blob; + async function readStream(stream: ReadableStream, mode?: "byob"): Promise { + const reader: any = stream.getReader(mode === undefined ? undefined : { mode }); + const bytes: number[] = []; + while (true) { + const result = mode === "byob" + ? await reader.read(new Uint8Array(64)) + : await reader.read(); + if (result.done) { + return bytes; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + } + before(function () { emptyBlobs = [new Blob([]), new Blob([])]; stringBlob = new Blob(["Hello"]); @@ -1742,6 +1758,120 @@ describe("Blob", function () { expect(modelGltfJson.type).to.equal("model/gltf+json"); }); + // Focused ports from WPT FileAPI/blob/Blob-constructor.any.js. + it("accepts iterable parts and preserves their order", async function () { + const parts = { + *[Symbol.iterator]() { + yield "foo"; + yield new Uint8Array([98, 97, 114]); + yield new Blob(["baz"]); + } + }; + const blob = new Blob(parts as any); + expect(blob.size).to.equal(9); + expect(await blob.text()).to.equal("foobarbaz"); + }); + + it("uses an Array's overridden iterator", async function () { + const parts = ["ignored"]; + parts[Symbol.iterator] = function* () { + yield "custom"; + }; + + expect(await new Blob(parts).text()).to.equal("custom"); + }); + + it("closes an iterator when BlobPart conversion throws", function () { + let closed = false; + const badPart = { + toString() { + throw new Error("part conversion failed"); + } + }; + const parts = (function* () { + try { + yield badPart; + } finally { + closed = true; + } + })(); + + // QuickJS currently wraps an exception rethrown through a native + // constructor as its generic JS error type, so assert the observable + // iterator-close behavior separately from the adapter's error text. + expect(() => new Blob(parts as any)).to.throw(); + expect(closed).to.equal(true); + }); + + it("observes BlobPart array mutations during iteration", async function () { + const parts: any[] = [ + { + toString() { + parts.pop(); + return "PASS"; + } + }, + { + toString() { + throw new Error("removed part was converted"); + } + } + ]; + + expect(await new Blob(parts).text()).to.equal("PASS"); + }); + + it("converts parts before reading options in WebIDL order", function () { + const accesses: string[] = []; + const part = { + toString() { + accesses.push("part"); + return "data"; + } + }; + new Blob([part], { + get type() { + accesses.push("type"); + return "TEXT/PLAIN"; + }, + get endings() { + accesses.push("endings"); + return "transparent" as EndingType; + } + }); + + expect(accesses).to.deep.equal(["part", "endings", "type"]); + }); + + it("validates the endings enum and options dictionary", function () { + expect(() => new Blob([], { endings: "NATIVE" as EndingType })).to.throw(); + expect(() => new Blob([], { endings: "invalid" as EndingType })).to.throw(); + for (const value of [123, true, "abc"]) { + expect(() => new Blob([], value as any)).to.throw(); + } + expect(() => new Blob([], null as any)).not.to.throw(); + expect(() => new Blob([], undefined)).not.to.throw(); + }); + + it("exposes browser-compatible class tags", function () { + expect(String(new Blob())).to.equal("[object Blob]"); + expect(String(new File([], "empty.txt"))).to.equal("[object File]"); + }); + + it("rejects primitive parts containers", function () { + for (const value of [null, true, 7, "not a sequence"]) { + // Some Node-API adapters currently wrap a Napi::TypeError thrown + // by a constructor as their generic JS error type. + expect(() => new Blob(value as any)).to.throw(); + } + }); + + it("normalizes valid MIME types and clears invalid types", function () { + expect(new Blob([], { type: "TEXT/PLAIN" }).type).to.equal("text/plain"); + expect(new Blob([], { type: "te\x09xt/plain" }).type).to.equal(""); + expect(new Blob([], { type: "text/\x7fplain" }).type).to.equal(""); + }); + // -------------------------------- Blob.text() -------------------------------- it("returns empty string for empty blobs", async function () { for (const blob of emptyBlobs) { @@ -1763,6 +1893,11 @@ describe("Blob", function () { expect(text).to.equal("你好, 世界"); }); + it("replaces invalid UTF-8 bytes", async function () { + const invalid = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]); + expect(await new Blob([invalid]).text()).to.equal("\ufffd".repeat(invalid.length)); + }); + it("preserves line endings like default transparent mode", async function () { const lineEndingsBlob = new Blob(["Hello\nWorld"]); const text = await lineEndingsBlob.text(); @@ -1809,6 +1944,82 @@ describe("Blob", function () { } }); + + // Focused ports from WPT FileAPI/blob/Blob-slice.any.js. + it("slices across part boundaries and applies clamp rounding", async function () { + const blob = new Blob(["foo", new Blob(["bar"]), "baz"]); + expect(await blob.slice(2, 7).text()).to.equal("obarb"); + expect(await new Blob(["abcd"]).slice(1.5).text()).to.equal("cd"); + expect(await new Blob(["abcd"]).slice(2.5).text()).to.equal("cd"); + expect(await blob.slice(-3, undefined, "TEXT/PLAIN").text()).to.equal("baz"); + expect(blob.slice(-3, undefined, "TEXT/PLAIN").type).to.equal("text/plain"); + }); + + // Focused ports from WPT FileAPI/blob/Blob-stream.any.js. + it("streams binary data through default and BYOB readers", async function () { + const input = [8, 241, 48, 123, 151]; + const blob = new Blob([new Uint8Array(input)]); + expect(await readStream(blob.stream())).to.deep.equal(input); + expect(await readStream(blob.stream(), "byob")).to.deep.equal(input); + expect(await readStream(new Blob().stream())).to.deep.equal([]); + }); + + it("keeps independent stream cursors after the Blob reference is dropped", async function () { + let blob: Blob | null = new Blob(["PASS"]); + const first = blob.stream(); + const second = blob.stream(); + blob = null; + expect(await readStream(first)).to.deep.equal([80, 65, 83, 83]); + expect(await readStream(second)).to.deep.equal([80, 65, 83, 83]); + }); + + // Adapted from WebKit's fast/files/blob-stream-chunks.html. + it("chunks a large Blob and supports cancellation without retaining work", async function () { + const blob = new Blob([new Uint8Array(5 * 1024 * 1024)]); + const reader = blob.stream().getReader(); + const first = await reader.read(); + expect(first.done).to.equal(false); + expect(first.value!.byteLength).to.be.at.most(64 * 1024); + await reader.cancel(); + await reader.closed; + }); + + // Adapted from WebKit's blob-stream crash regression and exercises + // teardown of the C++ pull-state closures under repeated construction. + it("constructs and cancels many empty streams without crashing", async function () { + for (let index = 0; index < 1000; ++index) { + await new Blob().stream().cancel(); + } + }); + + // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. + it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + const pattern = new Uint8Array(256 * 1024); + for (let index = 0; index < pattern.length; ++index) { + pattern[index] = index % 256; + } + const pair = new Blob([pattern, pattern]); + const nested = new Blob([pair, pair, pair, pair, pair, pair]); + let position = 0; + + await nested.stream().pipeTo(new WritableStream({ + write(chunk: Uint8Array) { + for (const value of chunk) { + const expected = position % pattern.length % 256; + if (value !== expected) { + throw new Error(`Blob stream byte ${position}: expected ${expected}, received ${value}`); + } + ++position; + } + } + })); + expect(position).to.equal(pattern.length * 12); + }); + + it("uses a File's Blob bytes when composing parts", async function () { + const file = new File(["a", "b"], "letters.txt"); + expect(await new Blob(["<", file, ">"]).text()).to.equal(""); + }); }); describe("napi class prototype isolation (#172)", function () { @@ -2162,6 +2373,22 @@ describe("File", function () { expect(text).to.equal("你好, 世界"); }); + // Adapted from WebKit's fast/files/blob-stream-crash-2.html. + it("streams and slices multiple File parts through the Blob API", async function () { + const file = new File(["a", new Blob(), "b", new Blob(), "c", new Blob(), "d"], "letters.txt"); + const reader = file.stream().getReader(); + const bytes: number[] = []; + while (true) { + const result = await reader.read(); + if (result.done) { + break; + } + bytes.push(...Array.from(result.value as Uint8Array)); + } + expect(bytes).to.deep.equal([97, 98, 99, 100]); + expect(await file.slice(1, 3).text()).to.equal("bc"); + }); + // -------------------------------- Blob inheritance -------------------------------- it("is an instance of Blob (prototype chain wired up)", function () { // BJS core (fileTools, Offline/database, abstractEngine, From f16e5a7d5d89f30d519f8a0e490309f7379671bd Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 22:44:34 -0700 Subject: [PATCH 089/174] Add browser-compatible Headers and Response Replace the ad hoc buffered fetch response object with standard-shaped Headers and Response classes backed by ReadableStream bodies. Preserve host constructors, normalize and validate header values, enforce single-use bodies, and expose native responses with one transport-to-JavaScript copy. Reuse normalized header views between mutations, compact header storage in place, retain stream chunks only until consumption, and allocate a contiguous body result at most once when required. Add focused WPT, WebKit, Firefox, and Chromium regression coverage plus JavaScriptCore/QuickJS and initialization tests. --- Polyfills/Fetch/CMakeLists.txt | 17 +- Polyfills/Fetch/Readme.md | 29 +- Polyfills/Fetch/Source/Fetch.cpp | 241 +++------ Polyfills/Fetch/Source/FetchPolyfill.js | 604 +++++++++++++++++++++++ Polyfills/Fetch/Source/FetchScripts.h.in | 8 + Tests/UnitTests/Scripts/tests.ts | 242 +++++++++ Tests/UnitTests/Shared/Shared.cpp | 31 +- 7 files changed, 973 insertions(+), 199 deletions(-) create mode 100644 Polyfills/Fetch/Source/FetchPolyfill.js create mode 100644 Polyfills/Fetch/Source/FetchScripts.h.in diff --git a/Polyfills/Fetch/CMakeLists.txt b/Polyfills/Fetch/CMakeLists.txt index 62b46175..24346db0 100644 --- a/Polyfills/Fetch/CMakeLists.txt +++ b/Polyfills/Fetch/CMakeLists.txt @@ -1,12 +1,25 @@ +set(FETCH_POLYFILL_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Source/FetchPolyfill.js") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${FETCH_POLYFILL_FILE}") +file(READ "${FETCH_POLYFILL_FILE}" FETCH_POLYFILL_SOURCE) +configure_file( + "Source/FetchScripts.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/Generated/FetchScripts.h" + @ONLY) + set(SOURCES "Include/Babylon/Polyfills/Fetch.h" + "Readme.md" "Source/Fetch.h" - "Source/Fetch.cpp") + "Source/Fetch.cpp" + "Source/FetchPolyfill.js" + "Source/FetchScripts.h.in") add_library(Fetch ${SOURCES}) warnings_as_errors(Fetch) -target_include_directories(Fetch PUBLIC "Include") +target_include_directories(Fetch + PUBLIC "Include" + PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/Generated") target_link_libraries(Fetch PUBLIC JsRuntime diff --git a/Polyfills/Fetch/Readme.md b/Polyfills/Fetch/Readme.md index 00c41cfc..b3d21a4e 100644 --- a/Polyfills/Fetch/Readme.md +++ b/Polyfills/Fetch/Readme.md @@ -1,5 +1,7 @@ # Fetch -Minimal implementation of the [WHATWG `fetch()`](https://fetch.spec.whatwg.org/) API. Like `XMLHttpRequest`, it is implemented on top of the platform-specific transports in the `UrlLib` dependency, so network behavior (libcurl / WinHTTP / etc.) is identical between the two polyfills. +Implementation of the [WHATWG `fetch()`](https://fetch.spec.whatwg.org/) API. +Like `XMLHttpRequest`, it uses the platform-specific transport from `UrlLib`, so +network behavior is shared between the two polyfills. ```js const response = await fetch("https://example.com/data.json"); @@ -8,16 +10,24 @@ if (response.ok) { } ``` -## Response -`fetch()` returns a `Promise` that resolves to a `Response`-like object exposing: -* `ok`, `status`, `statusText`, `url`, `redirected`, `type`, `bodyUsed` -* `headers` with `get(name)`, `has(name)`, and `forEach(callback)` (header names are matched case-insensitively) -* `text()`, `arrayBuffer()`, `json()`, `blob()` (each returns a `Promise`) -* `clone()` +## Headers and Response +The module installs `Headers` and `Response` when the host does not already +provide them. Response bodies use a `ReadableStream` and follow the browser's +single-consumption behavior through `bodyUsed`. The supported body readers are +`arrayBuffer()`, `blob()`, `bytes()`, `json()`, and `text()`. -The response body is fully buffered before the promise resolves. The body accessors may therefore be called more than once (`bodyUsed` is always reported as `false`), which is a deliberate, lenient deviation from the spec's single-use semantics. +Initialize the Streams, Blob, TextEncoder, TextDecoder, and URL polyfills before +using body-bearing responses on engines that do not provide those globals. -`blob()` requires the `Blob` polyfill to be initialized; otherwise the returned promise rejects. +A completed native response is copied once into JavaScript-owned memory and +exposed as a byte stream. Body readers retain chunk references while consuming +a stream and allocate a contiguous result at most once when that result requires +one. Repeated header iteration reuses a mutation-versioned normalized view, and +header deletion and replacement compact the field list in place. + +The focused conformance tests are adapted from WPT `fetch/api/headers` and +`fetch/api/response`, plus WebKit, Firefox, and Chromium response-body +regressions. ## Local files Like `XMLHttpRequest`, `fetch()` supports loading local resources: @@ -60,4 +70,3 @@ The rejection's `stack` is captured synchronously at the `fetch()` call site (be is handed to a worker thread), so crash reports can attribute the failing call rather than an empty scheduler tick. (Engines that only materialize `.stack` when an error is thrown may omit the frames.) - diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index cf6c171e..5bbf6001 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -1,4 +1,5 @@ #include "Fetch.h" +#include "FetchScripts.h" #include #include @@ -14,22 +15,11 @@ #include #include #include -#include namespace Babylon::Polyfills::Internal { namespace { - // Buffered response payload shared between the Response object and any clones it produces. - struct ResponseData - { - int statusCode{}; - std::string statusText; - std::string url; - std::vector> headers; - std::vector body; - }; - // Shared state for honoring an AbortSignal passed via init.signal. Co-owned by the "abort" // listener (which sets the flag, captures the reason, and cancels the transport) and the // completion continuation (which reports the AbortError and tears the listener down). @@ -153,18 +143,6 @@ namespace Babylon::Polyfills::Internal throw std::runtime_error{"Unsupported fetch method: " + method + " (only GET and POST are supported)"}; } - std::optional FindHeader(const ResponseData& data, std::string_view name) - { - for (const auto& header : data.headers) - { - if (EqualsIgnoreCase(header.first, name)) - { - return header.second; - } - } - return std::nullopt; - } - void ApplyRequestHeaders(UrlLib::UrlRequest& request, const Napi::Value& headers) { if (headers.IsUndefined() || headers.IsNull()) @@ -172,166 +150,36 @@ namespace Babylon::Polyfills::Internal return; } - Napi::Env env = headers.Env(); - - // Array of [name, value] pairs. - if (headers.IsArray()) + const auto env = headers.Env(); + const auto headersConstructor = env.Global().Get("Headers"); + if (headersConstructor.IsUndefined() || headersConstructor.IsNull()) { - const auto array = headers.As(); - for (uint32_t i = 0; i < array.Length(); ++i) - { - const auto pair = array.Get(i); - if (pair.IsArray()) - { - const auto entry = pair.As(); - request.SetRequestHeader(entry.Get(0u).ToString().Utf8Value(), entry.Get(1u).ToString().Utf8Value()); - } - } - return; + throw Napi::TypeError::New(env, "fetch requires Headers to be installed."); } - if (headers.IsObject()) - { - const auto object = headers.As(); - - // Headers / Map instances expose forEach((value, key) => ...). - const auto forEach = object.Get("forEach"); - if (forEach.IsFunction()) + auto normalizedHeaders = headersConstructor.As().New({headers}); + const auto callback = Napi::Function::New(env, [&request](const Napi::CallbackInfo& info) { + if (info.Length() >= 2) { - const auto callback = Napi::Function::New(env, [&request](const Napi::CallbackInfo& info) { - if (info.Length() >= 2) - { - request.SetRequestHeader(info[1].ToString().Utf8Value(), info[0].ToString().Utf8Value()); - } - }); - forEach.As().Call(object, {callback}); - return; - } - - // Plain object of name/value properties. - const auto names = object.GetPropertyNames(); - for (uint32_t i = 0; i < names.Length(); ++i) - { - const auto key = names.Get(i); - request.SetRequestHeader(key.ToString().Utf8Value(), object.Get(key).ToString().Utf8Value()); - } - } - } - - Napi::Object BuildHeaders(Napi::Env env, const std::shared_ptr& data) - { - Napi::Object headers = Napi::Object::New(env); - - headers.Set("get", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto value = FindHeader(*data, info[0].ToString().Utf8Value()); - return value ? Napi::Value{Napi::String::New(env, *value)} : Napi::Value{env.Null()}; - }, "get")); - - headers.Set("has", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - return Napi::Boolean::New(info.Env(), FindHeader(*data, info[0].ToString().Utf8Value()).has_value()); - }, "has")); - - headers.Set("forEach", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto callback = info[0].As(); - const auto thisArg = info.Length() > 1 ? info[1] : env.Undefined(); - for (const auto& header : data->headers) - { - callback.Call(thisArg, {Napi::String::New(env, header.second), Napi::String::New(env, header.first)}); + request.SetRequestHeader(info[1].ToString().Utf8Value(), info[0].ToString().Utf8Value()); } - return env.Undefined(); - }, "forEach")); - - return headers; + }); + normalizedHeaders.Get("forEach").As().Call(normalizedHeaders, {callback}); } - Napi::Object BuildResponse(Napi::Env env, const std::shared_ptr& data) + void InitializeFetchClasses(Napi::Env env) { - Napi::Object response = Napi::Object::New(env); - - const bool ok = data->statusCode >= 200 && data->statusCode < 300; - response.Set("ok", Napi::Boolean::New(env, ok)); - response.Set("status", Napi::Number::New(env, data->statusCode)); - response.Set("statusText", Napi::String::New(env, data->statusText)); - response.Set("url", Napi::String::New(env, data->url)); - response.Set("redirected", Napi::Boolean::New(env, false)); - response.Set("type", Napi::String::New(env, "basic")); - response.Set("bodyUsed", Napi::Boolean::New(env, false)); - response.Set("headers", BuildHeaders(env, data)); - - response.Set("text", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - std::string text{reinterpret_cast(data->body.data()), data->body.size()}; - deferred.Resolve(Napi::String::New(env, text)); - return deferred.Promise(); - }, "text")); - - response.Set("arrayBuffer", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - const auto arrayBuffer = Napi::ArrayBuffer::New(env, data->body.size()); - if (!data->body.empty()) - { - std::memcpy(arrayBuffer.Data(), data->body.data(), data->body.size()); - } - deferred.Resolve(arrayBuffer); - return deferred.Promise(); - }, "arrayBuffer")); - - response.Set("json", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - std::string text{reinterpret_cast(data->body.data()), data->body.size()}; - const auto json = env.Global().Get("JSON").As(); - const auto parse = json.Get("parse").As(); - try - { - deferred.Resolve(parse.Call(json, {Napi::String::New(env, text)})); - } - catch (const Napi::Error& error) - { - deferred.Reject(error.Value()); - } - return deferred.Promise(); - }, "json")); - - response.Set("blob", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - Napi::Env env = info.Env(); - const auto deferred = Napi::Promise::Deferred::New(env); - - // Require the Blob polyfill to be installed. - const auto blobConstructor = env.Global().Get("Blob"); - if (!blobConstructor.IsFunction()) - { - deferred.Reject(Napi::Error::New(env, "fetch: Blob is not available in this environment").Value()); - return deferred.Promise(); - } - - const auto arrayBuffer = Napi::ArrayBuffer::New(env, data->body.size()); - if (!data->body.empty()) - { - std::memcpy(arrayBuffer.Data(), data->body.data(), data->body.size()); - } - const auto bytes = Napi::Uint8Array::New(env, data->body.size(), arrayBuffer, 0); - - Napi::Array parts = Napi::Array::New(env, 1); - parts.Set(0u, bytes); - - Napi::Object options = Napi::Object::New(env); - const auto contentType = FindHeader(*data, "content-type"); - options.Set("type", Napi::String::New(env, contentType.value_or(""))); - - deferred.Resolve(blobConstructor.As().New({parts, options})); - return deferred.Promise(); - }, "blob")); - - response.Set("clone", Napi::Function::New(env, [data](const Napi::CallbackInfo& info) -> Napi::Value { - return BuildResponse(info.Env(), data); - }, "clone")); - - return response; + auto global = env.Global(); + const auto exports = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js").As(); + if (global.Get("Headers").IsUndefined()) + { + global.Set("Headers", exports.Get("Headers")); + } + if (global.Get("Response").IsUndefined()) + { + global.Set("Response", exports.Get("Response")); + } + JsRuntime::NativeObject::GetFromJavaScript(env).Set("createFetchResponse", exports.Get("createFetchResponse")); } } @@ -340,6 +188,7 @@ namespace Babylon::Polyfills::Internal void Initialize(Napi::Env env) { static constexpr auto JS_FETCH_NAME = "fetch"; + InitializeFetchClasses(env); auto fetchFunction = Napi::Function::New(env, [](const Napi::CallbackInfo& info) -> Napi::Value { Napi::Env env = info.Env(); @@ -487,18 +336,41 @@ namespace Babylon::Polyfills::Internal return; } - auto data = std::make_shared(); - data->statusCode = status; - data->statusText = std::string{request->StatusText()}; - data->url = std::string{request->ResponseUrl()}; + const auto responseBuffer = request->ResponseBuffer(); + auto arrayBuffer = Napi::ArrayBuffer::New(env, responseBuffer.size()); + if (!responseBuffer.empty()) + { + std::memcpy(arrayBuffer.Data(), responseBuffer.data(), responseBuffer.size()); + } + const auto bytes = Napi::Uint8Array::New(env, responseBuffer.size(), arrayBuffer, 0); + + auto responseHeaders = Napi::Array::New(env, request->GetAllResponseHeaders().size()); + uint32_t headerIndex{}; for (const auto& header : request->GetAllResponseHeaders()) { - data->headers.emplace_back(header.first, header.second); + auto pair = Napi::Array::New(env, 2); + pair.Set(uint32_t{0}, Napi::String::New(env, header.first)); + pair.Set(uint32_t{1}, Napi::String::New(env, header.second)); + responseHeaders.Set(headerIndex++, pair); } - const auto responseBuffer = request->ResponseBuffer(); - data->body.assign(responseBuffer.begin(), responseBuffer.end()); - deferred.Resolve(BuildResponse(env, data)); + auto init = Napi::Object::New(env); + init.Set("headers", responseHeaders); + init.Set("status", Napi::Number::New(env, status)); + const auto statusText = request->StatusText(); + init.Set("statusText", Napi::String::New(env, statusText.data(), statusText.size())); + + const std::string responseUrl{request->ResponseUrl()}; + auto metadata = Napi::Object::New(env); + metadata.Set("redirected", Napi::Boolean::New(env, !responseUrl.empty() && responseUrl != url)); + metadata.Set("type", Napi::String::New(env, "basic")); + metadata.Set("url", Napi::String::New(env, responseUrl.empty() ? url : responseUrl)); + + const auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); + const auto createResponse = nativeObject.Get("createFetchResponse").As(); + deferred.Resolve(createResponse.Call( + nativeObject, + {env.Global().Get("Response"), bytes, init, metadata})); }) .then(*scheduler, arcana::cancellation::none(), [deferred, env, scheduler](const arcana::expected& result) { @@ -518,8 +390,7 @@ namespace Babylon::Polyfills::Internal deferred.Reject(Napi::Error::New(env, std::current_exception()).Value()); } - return deferred.Promise(); - }, JS_FETCH_NAME); + return deferred.Promise(); }, JS_FETCH_NAME); if (env.Global().Get(JS_FETCH_NAME).IsUndefined()) { diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js new file mode 100644 index 00000000..93f6811a --- /dev/null +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -0,0 +1,604 @@ +(function(global) { + "use strict"; + + var headerStates = new WeakMap(); + var responseStates = new WeakMap(); + var headerNamePattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; + var nullBodyStatuses = [204, 205, 304]; + + function requireHeaderState(value) { + var state = headerStates.get(value); + if (!state) { + throw new TypeError("Illegal invocation"); + } + return state; + } + + function requireResponseState(value) { + var state = responseStates.get(value); + if (!state) { + throw new TypeError("Illegal invocation"); + } + return state; + } + + function toByteString(value, description) { + var string = String(value); + for (var index = 0; index < string.length; ++index) { + if (string.charCodeAt(index) > 255) { + throw new TypeError(description + " is not a valid ByteString"); + } + } + return string; + } + + function normalizeHeaderName(value) { + var name = toByteString(value, "Header name"); + if (!headerNamePattern.test(name)) { + throw new TypeError("Invalid header name"); + } + return name.toLowerCase(); + } + + function normalizeHeaderValue(value) { + var normalized = toByteString(value, "Header value") + .replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, ""); + if (/[\0\r\n]/.test(normalized)) { + throw new TypeError("Invalid header value"); + } + return normalized; + } + + function isForbiddenResponseHeader(name) { + return name === "set-cookie" || name === "set-cookie2"; + } + + function appendHeader(state, name, value) { + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + state.list.push([name, value]); + state.version++; + } + + function removeHeader(state, name) { + var writeIndex = 0; + var removed = false; + for (var readIndex = 0; readIndex < state.list.length; ++readIndex) { + var entry = state.list[readIndex]; + if (entry[0] === name) { + removed = true; + } else { + state.list[writeIndex++] = entry; + } + } + state.list.length = writeIndex; + return removed; + } + + function fillHeaders(target, init) { + var state = requireHeaderState(target); + if (init === undefined) { + return; + } + if ((typeof init !== "object" && typeof init !== "function") || init === null) { + throw new TypeError("Headers initializer must be an object"); + } + + var iteratorMethod = init[Symbol.iterator]; + if (iteratorMethod !== undefined) { + if (typeof iteratorMethod !== "function") { + throw new TypeError("Headers initializer is not iterable"); + } + for (var entry of init) { + if ((typeof entry !== "object" && typeof entry !== "function") || entry === null) { + throw new TypeError("Each header pair must be iterable"); + } + var pair = Array.from(entry); + if (pair.length !== 2) { + throw new TypeError("Each header pair must contain exactly two items"); + } + appendHeader(state, normalizeHeaderName(pair[0]), normalizeHeaderValue(pair[1])); + } + return; + } + + for (var name of Object.keys(init)) { + appendHeader(state, normalizeHeaderName(name), normalizeHeaderValue(init[name])); + } + } + + function combinedHeaderEntries(state) { + if (state.cacheVersion === state.version) { + return state.cache; + } + var valuesByName = new Map(); + for (var entry of state.list) { + var values = valuesByName.get(entry[0]); + if (!values) { + values = []; + valuesByName.set(entry[0], values); + } + values.push(entry[1]); + } + + var result = []; + var names = Array.from(valuesByName.keys()).sort(); + for (var name of names) { + var values = valuesByName.get(name); + if (name === "set-cookie") { + for (var value of values) { + result.push([name, value]); + } + } else { + result.push([name, values.join(", ")]); + } + } + state.cache = result; + state.cacheVersion = state.version; + return state.cache; + } + + function* iterateHeaders(headers, kind) { + var index = 0; + while (true) { + var entries = combinedHeaderEntries(requireHeaderState(headers)); + if (index >= entries.length) { + return; + } + var entry = entries[index++]; + if (kind === "key") { + yield entry[0]; + } else if (kind === "value") { + yield entry[1]; + } else { + yield [entry[0], entry[1]]; + } + } + } + + class Headers { + constructor(init) { + headerStates.set(this, { + cache: [], + cacheVersion: -1, + guard: "none", + list: [], + version: 0 + }); + fillHeaders(this, init); + } + + append(name, value) { + var state = requireHeaderState(this); + appendHeader(state, normalizeHeaderName(name), normalizeHeaderValue(value)); + } + + delete(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + if (removeHeader(state, name)) { + state.version++; + } + } + + get(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + var value = null; + for (var entry of state.list) { + if (entry[0] === name) { + value = value === null ? entry[1] : value + ", " + entry[1]; + } + } + return value; + } + + getSetCookie() { + var state = requireHeaderState(this); + var values = []; + for (var entry of state.list) { + if (entry[0] === "set-cookie") { + values.push(entry[1]); + } + } + return values; + } + + has(name) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + return state.list.some(function(entry) { return entry[0] === name; }); + } + + set(name, value) { + var state = requireHeaderState(this); + name = normalizeHeaderName(name); + value = normalizeHeaderValue(value); + if (state.guard === "response" && isForbiddenResponseHeader(name)) { + return; + } + removeHeader(state, name); + state.list.push([name, value]); + state.version++; + } + + entries() { + requireHeaderState(this); + return iterateHeaders(this, "entry"); + } + + keys() { + requireHeaderState(this); + return iterateHeaders(this, "key"); + } + + values() { + requireHeaderState(this); + return iterateHeaders(this, "value"); + } + + forEach(callback, thisArg) { + requireHeaderState(this); + if (typeof callback !== "function") { + throw new TypeError("Headers.forEach callback must be a function"); + } + for (var entry of this) { + callback.call(thisArg, entry[1], entry[0], this); + } + } + + [Symbol.iterator]() { + return this.entries(); + } + } + + Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + configurable: true, + value: "Headers" + }); + + function createResponseHeaders(init) { + var headers = new Headers(init); + var state = requireHeaderState(headers); + state.guard = "response"; + var removedForbidden = removeHeader(state, "set-cookie"); + removedForbidden = removeHeader(state, "set-cookie2") || removedForbidden; + if (removedForbidden) { + state.version++; + } + return headers; + } + + function isReadableStream(value) { + return global.ReadableStream !== undefined && global.ReadableStream !== null && + value instanceof global.ReadableStream; + } + + function streamFromBytes(bytes) { + var chunk = bytes; + return new global.ReadableStream({ + type: "bytes", + pull: function(controller) { + if (chunk !== null) { + var value = chunk; + chunk = null; + controller.enqueue(value); + } + controller.close(); + }, + cancel: function() { + chunk = null; + } + }); + } + + function copyBufferSource(value) { + var source; + if (value instanceof ArrayBuffer) { + source = new Uint8Array(value); + } else { + source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength); + } + var copy = new Uint8Array(source.byteLength); + copy.set(source); + return copy; + } + + function extractBody(body) { + if (body === null || body === undefined) { + return { stream: null, contentType: null }; + } + if (isReadableStream(body)) { + if (body.locked || body._disturbed) { + throw new TypeError("Response body stream is already disturbed or locked"); + } + return { stream: body, contentType: null }; + } + if (global.Blob !== undefined && global.Blob !== null && body instanceof global.Blob) { + return { stream: body.stream(), contentType: body.type || null }; + } + if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) { + return { stream: streamFromBytes(copyBufferSource(body)), contentType: null }; + } + if (global.URLSearchParams !== undefined && global.URLSearchParams !== null && body instanceof global.URLSearchParams) { + return { + stream: streamFromBytes(new global.TextEncoder().encode(body.toString())), + contentType: "application/x-www-form-urlencoded;charset=UTF-8" + }; + } + if (global.FormData !== undefined && global.FormData !== null && body instanceof global.FormData) { + throw new TypeError("FormData response bodies are not supported by this runtime"); + } + + return { + stream: streamFromBytes(new global.TextEncoder().encode(String(body))), + contentType: "text/plain;charset=UTF-8" + }; + } + + function bodyIsUnusable(state) { + return state.used || (state.body !== null && (state.body.locked || state.body._disturbed)); + } + + async function readBodyChunks(state) { + if (state.body === null) { + return [[], 0]; + } + if (bodyIsUnusable(state)) { + throw new TypeError("Response body is already used"); + } + + state.used = true; + var chunks = []; + var total = 0; + var reader = state.body.getReader(); + while (true) { + var result = await reader.read(); + if (result.done) { + return [chunks, total]; + } + if (!(result.value instanceof Uint8Array)) { + throw new TypeError("Response body stream yielded a non-Uint8Array chunk"); + } + if (result.value.byteLength === 0) { + continue; + } + if (total > Number.MAX_SAFE_INTEGER - result.value.byteLength) { + throw new RangeError("Response body is too large"); + } + chunks.push(result.value); + total += result.value.byteLength; + } + } + + function joinChunks(chunksAndTotal) { + var chunks = chunksAndTotal[0]; + var total = chunksAndTotal[1]; + if (chunks.length === 0) { + return new Uint8Array(0); + } + if (chunks.length === 1) { + return chunks[0]; + } + + var bytes = new Uint8Array(total); + var offset = 0; + for (var chunk of chunks) { + bytes.set(chunk, offset); + offset += chunk.byteLength; + } + return bytes; + } + + async function consumeText(state) { + if (state.body === null) { + return ""; + } + if (bodyIsUnusable(state)) { + throw new TypeError("Response body is already used"); + } + + state.used = true; + var decoder = new global.TextDecoder(); + var pieces = []; + var reader = state.body.getReader(); + while (true) { + var result = await reader.read(); + if (result.done) { + pieces.push(decoder.decode()); + return pieces.join(""); + } + if (!(result.value instanceof Uint8Array)) { + throw new TypeError("Response body stream yielded a non-Uint8Array chunk"); + } + if (result.value.byteLength !== 0) { + pieces.push(decoder.decode(result.value, { stream: true })); + } + } + } + + function validateResponseInit(init) { + if (init === undefined || init === null) { + init = {}; + } else if (typeof init !== "object" && typeof init !== "function") { + throw new TypeError("Response init must be an object"); + } + + var status = init.status === undefined ? 200 : Math.trunc(Number(init.status)); + if (!Number.isFinite(status) || status < 200 || status > 599) { + throw new RangeError("Response status must be between 200 and 599"); + } + var statusText = init.statusText === undefined ? "" : + toByteString(init.statusText, "Response statusText"); + if (/[\r\n]/.test(statusText)) { + throw new TypeError("Invalid Response statusText"); + } + return { + headers: createResponseHeaders(init.headers), + status: status, + statusText: statusText + }; + } + + function initializeResponse(response, body, init, metadata) { + var normalizedInit = validateResponseInit(init); + var extracted = extractBody(body); + if (extracted.stream !== null && nullBodyStatuses.indexOf(normalizedInit.status) !== -1) { + throw new TypeError("Response with this status cannot have a body"); + } + if (extracted.contentType !== null && !normalizedInit.headers.has("content-type")) { + normalizedInit.headers.append("content-type", extracted.contentType); + } + + responseStates.set(response, { + body: extracted.stream, + headers: normalizedInit.headers, + redirected: metadata && metadata.redirected === true, + status: normalizedInit.status, + statusText: normalizedInit.statusText, + type: metadata && metadata.type ? String(metadata.type) : "default", + url: metadata && metadata.url ? String(metadata.url) : "", + used: false + }); + } + + class Response { + constructor(body, init) { + initializeResponse(this, body === undefined ? null : body, init, null); + } + + get body() { return requireResponseState(this).body; } + get bodyUsed() { + var state = requireResponseState(this); + return state.used || (state.body !== null && state.body._disturbed === true); + } + get headers() { return requireResponseState(this).headers; } + get ok() { + var status = requireResponseState(this).status; + return status >= 200 && status <= 299; + } + get redirected() { return requireResponseState(this).redirected; } + get status() { return requireResponseState(this).status; } + get statusText() { return requireResponseState(this).statusText; } + get type() { return requireResponseState(this).type; } + get url() { return requireResponseState(this).url; } + + async arrayBuffer() { + var bytes = joinChunks(await readBodyChunks(requireResponseState(this))); + if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) { + return bytes.buffer; + } + return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength); + } + + async blob() { + var state = requireResponseState(this); + var bytes = joinChunks(await readBodyChunks(state)); + return new global.Blob([bytes], { type: state.headers.get("content-type") || "" }); + } + + async bytes() { + return joinChunks(await readBodyChunks(requireResponseState(this))); + } + + clone() { + var state = requireResponseState(this); + if (bodyIsUnusable(state)) { + throw new TypeError("Cannot clone a used Response"); + } + + var cloneBody = null; + if (state.body !== null) { + var branches = state.body.tee(); + state.body = branches[0]; + cloneBody = branches[1]; + } + var clone = new Response(cloneBody, { + headers: state.headers, + status: state.status, + statusText: state.statusText + }); + var cloneState = requireResponseState(clone); + cloneState.redirected = state.redirected; + cloneState.type = state.type; + cloneState.url = state.url; + return clone; + } + + async json() { + return JSON.parse(await consumeText(requireResponseState(this))); + } + + async text() { + return consumeText(requireResponseState(this)); + } + + static error() { + var response = Object.create(Response.prototype); + responseStates.set(response, { + body: null, + headers: createResponseHeaders(), + redirected: false, + status: 0, + statusText: "", + type: "error", + url: "", + used: false + }); + return response; + } + + static json(data, init) { + var text = JSON.stringify(data); + if (text === undefined) { + throw new TypeError("Response.json data is not JSON serializable"); + } + var hasExplicitContentType = init !== undefined && init !== null && + new Headers(init.headers).has("content-type"); + var response = new Response(text, init); + if (!hasExplicitContentType) { + response.headers.set("content-type", "application/json"); + } + return response; + } + + static redirect(url, status) { + status = status === undefined ? 302 : Math.trunc(Number(status)); + if ([301, 302, 303, 307, 308].indexOf(status) === -1) { + throw new RangeError("Invalid redirect status"); + } + var location = global.URL !== undefined && global.URL !== null + ? new global.URL(String(url), global.location && global.location.href || undefined).toString() + : String(url); + return new Response(null, { status: status, headers: { location: location } }); + } + } + + Object.defineProperty(Response.prototype, Symbol.toStringTag, { + configurable: true, + value: "Response" + }); + + function createFetchResponse(ResponseConstructor, bytes, init, metadata) { + var status = init && init.status; + var body = nullBodyStatuses.indexOf(status) === -1 ? streamFromBytes(bytes) : null; + var response = new ResponseConstructor(body, init); + var state = responseStates.get(response); + if (state) { + state.redirected = metadata.redirected === true; + state.type = metadata.type || "basic"; + state.url = metadata.url || ""; + } + return response; + } + + return { + Headers: Headers, + Response: Response, + createFetchResponse: createFetchResponse + }; +})(globalThis) diff --git a/Polyfills/Fetch/Source/FetchScripts.h.in b/Polyfills/Fetch/Source/FetchScripts.h.in new file mode 100644 index 00000000..8cc0e511 --- /dev/null +++ b/Polyfills/Fetch/Source/FetchScripts.h.in @@ -0,0 +1,8 @@ +#pragma once + +namespace Babylon::Polyfills::Internal::FetchScripts +{ + inline constexpr char Polyfill[] = R"JSRHFETCH( +@FETCH_POLYFILL_SOURCE@ +)JSRHFETCH"; +} diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 122cc1b2..1eca74f0 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -302,11 +302,253 @@ describe("XMLHTTPRequest", function () { }); }); +describe("Headers", function () { + // Focused ports from WPT fetch/api/headers. + it("normalizes names and values and combines repeated fields", function () { + const headers = new Headers([ + ["X-Test", " first\t"], + ["x-test", "second"], + ["X-Other", "\r\n value \n"] + ]); + expect(headers.get("X-TEST")).to.equal("first, second"); + expect(headers.get("x-other")).to.equal("value"); + expect(Array.from(headers.keys())).to.deep.equal(["x-other", "x-test"]); + }); + + it("validates sequence shape and HTTP ByteStrings", function () { + expect(() => new Headers(null as any)).to.throw(); + expect(() => new Headers([["missing-value"]] as any)).to.throw(); + expect(() => new Headers([["too", "many", "values"]] as any)).to.throw(); + expect(() => new Headers([["invalid name", "value"]])).to.throw(); + expect(() => new Headers([["valid", "a\0b"]])).to.throw(); + expect(() => new Headers([["invalidĀ", "value"]])).to.throw(); + }); + + it("preserves Set-Cookie fields while combining other duplicates", function () { + const headers = new Headers([ + ["set-cookie", "a=1"], + ["x-value", "first"], + ["Set-Cookie", "b=2"], + ["X-Value", "second"] + ]); + expect(headers.getSetCookie()).to.deep.equal(["a=1", "b=2"]); + expect(Array.from(headers)).to.deep.equal([ + ["set-cookie", "a=1"], + ["set-cookie", "b=2"], + ["x-value", "first, second"] + ]); + }); + + it("keeps iteration live when headers are changed", function () { + const headers = new Headers({ bar: "0", baz: "1", foo: "2" }); + const seen: string[] = []; + for (const [name] of headers) { + seen.push(name); + headers.delete("foo"); + } + expect(seen).to.deep.equal(["bar", "baz"]); + }); + + it("copies an initializer and honors a custom iterator", function () { + const source = new Headers({ ignored: "value" }); + source[Symbol.iterator] = function* () { + yield ["custom", "value"]; + }; + const copy = new Headers(source); + source.set("custom", "changed"); + expect(Array.from(copy)).to.deep.equal([["custom", "value"]]); + }); +}); + +describe("Response", function () { + // Focused ports from WPT fetch/api/response. + it("exposes browser defaults and validates response metadata", function () { + const response = new Response(); + expect(String(response)).to.equal("[object Response]"); + expect(response.status).to.equal(200); + expect(response.statusText).to.equal(""); + expect(response.ok).to.equal(true); + expect(response.type).to.equal("default"); + expect(response.url).to.equal(""); + expect(response.body).to.equal(null); + expect(response.headers).to.equal(response.headers); + + expect(() => new Response("", { status: 199 })).to.throw(RangeError); + expect(() => new Response("", { status: 600 })).to.throw(RangeError); + expect(() => new Response("", { statusText: "bad\ntext" })).to.throw(TypeError); + expect(() => new Response("body", { status: 204 })).to.throw(TypeError); + }); + + it("streams strings and consumes a body only once", async function () { + const response = new Response("streamed text"); + expect(response.body).to.be.instanceOf(ReadableStream); + expect(response.bodyUsed).to.equal(false); + expect(await response.text()).to.equal("streamed text"); + expect(response.bodyUsed).to.equal(true); + + let rejected = false; + try { + await response.arrayBuffer(); + } catch (error) { + rejected = error instanceof TypeError; + } + expect(rejected).to.equal(true); + }); + + // Ported from WPT fetch/api/response/response-consume-empty.any.js. + it("consumes a null body as empty without disturbing it", async function () { + const textResponse = new Response(); + expect(await textResponse.text()).to.equal(""); + expect(textResponse.bodyUsed).to.equal(false); + + const bufferResponse = new Response(); + expect((await bufferResponse.arrayBuffer()).byteLength).to.equal(0); + expect(bufferResponse.bodyUsed).to.equal(false); + + const bytesResponse = new Response(); + expect((await bytesResponse.bytes()).byteLength).to.equal(0); + expect(bytesResponse.bodyUsed).to.equal(false); + + const blobResponse = new Response(); + expect((await blobResponse.blob()).size).to.equal(0); + expect(blobResponse.bodyUsed).to.equal(false); + + const jsonResponse = new Response(); + let jsonRejected = false; + try { + await jsonResponse.json(); + } catch { + jsonRejected = true; + } + expect(jsonRejected).to.equal(true); + expect(jsonResponse.bodyUsed).to.equal(false); + }); + + it("snapshots mutable BufferSource input once", async function () { + const input = new Uint8Array([80, 65, 83, 83]); + const response = new Response(input); + input.fill(0); + expect(await response.text()).to.equal("PASS"); + }); + + // Adapted from WebKit LayoutTests/fetch/body-init.html. + it("stringifies integer and object bodies", async function () { + expect(await new Response(1 as any).text()).to.equal("1"); + expect(await new Response({} as any).text()).to.equal("[object Object]"); + }); + + it("sets inferred content types without replacing explicit headers", async function () { + const text = new Response("text"); + expect(text.headers.get("content-type")).to.equal("text/plain;charset=UTF-8"); + + const blob = new Response(new Blob(["blob"], { type: "application/example" })); + expect(blob.headers.get("content-type")).to.equal("application/example"); + + const explicit = new Response("text", { headers: { "content-type": "text/custom" } }); + expect(explicit.headers.get("content-type")).to.equal("text/custom"); + }); + + it("clones stream branches for independent consumption", async function () { + const response = new Response("clone body", { + headers: { "x-test": "value" }, + status: 201, + statusText: "Created" + }); + const clone = response.clone(); + expect(clone.status).to.equal(201); + expect(clone.headers.get("x-test")).to.equal("value"); + expect(await response.text()).to.equal("clone body"); + expect(await clone.text()).to.equal("clone body"); + }); + + it("tracks direct stream reads and rejects invalid body chunks", async function () { + const direct = new Response("body"); + const reader = direct.body!.getReader(); + expect(direct.bodyUsed).to.equal(false); + await reader.read(); + expect(direct.bodyUsed).to.equal(true); + + const invalid = new Response(new ReadableStream({ + start(controller) { + controller.enqueue("not bytes"); + controller.close(); + } + }) as any); + let rejected = false; + try { + await invalid.bytes(); + } catch (error) { + rejected = error instanceof TypeError; + } + expect(rejected).to.equal(true); + }); + + // Adapted from Firefox dom/fetch/tests/crashtests/1939295.html. The + // unresolved read must remain safe through runtime teardown. + it("does not crash while consuming an open empty stream", function () { + const pending = new Response(new ReadableStream()).text(); + expect(pending).to.be.instanceOf(Promise); + }); + + // Adapted from WebKit's imported many-empty-chunks-crash.html. + it("consumes many empty chunks without retaining growing byte buffers", async function () { + const response = new Response(new ReadableStream({ + start(controller) { + for (let index = 0; index < 40000; ++index) { + controller.enqueue(new Uint8Array()); + } + controller.close(); + } + })); + expect((await response.arrayBuffer()).byteLength).to.equal(0); + }); + + // Bounded adaptation of Chromium's call-extra-crash-is-disturbed.html. + // QuickJS terminates before a JS-defined getter can run after a real + // native stack overflow, so retain the deep-call regression portably. + it("reads bodyUsed from a deep call stack without recursion", function () { + const response = new Response(new ReadableStream()); + function readAtDepth(depth: number): boolean { + return depth === 0 ? response.bodyUsed : readAtDepth(depth - 1); + } + expect(readAtDepth(128)).to.equal(false); + }); + + it("provides error, redirect, and JSON factories", async function () { + const error = Response.error(); + expect(error.type).to.equal("error"); + expect(error.status).to.equal(0); + + const redirect = Response.redirect("https://example.com/path", 307); + expect(redirect.status).to.equal(307); + expect(redirect.headers.get("location")).to.equal("https://example.com/path"); + + const json = Response.json({ value: 42 }); + expect(json.headers.get("content-type")).to.equal("application/json"); + expect(await json.json()).to.deep.equal({ value: 42 }); + }); + + it("filters forbidden response Set-Cookie fields", function () { + const response = new Response(null, { + headers: { + "set-cookie": "secret=value", + "set-cookie2": "legacy=value" + } + }); + response.headers.append("Set-Cookie", "other=value"); + expect(response.headers.getSetCookie()).to.deep.equal([]); + expect(response.headers.has("set-cookie2")).to.equal(false); + }); +}); + describe("fetch", function () { this.timeout(30000); it("should resolve with ok=true and status=200 for a resource that exists", async function () { const response = await fetch("https://github.com/"); + expect(response).to.be.instanceOf(Response); + expect(response.headers).to.be.instanceOf(Headers); + expect(response.body).to.be.instanceOf(ReadableStream); expect(response.ok).to.equal(true); expect(response.status).to.equal(200); }); diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index b71218bd..3b78d2fb 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -86,12 +86,12 @@ TEST(JavaScript, All) Babylon::Polyfills::URL::Initialize(env); Babylon::Polyfills::WebSocket::Initialize(env); Babylon::Polyfills::XMLHttpRequest::Initialize(env); - Babylon::Polyfills::Fetch::Initialize(env); + Babylon::Polyfills::Streams::Initialize(env); Babylon::Polyfills::Blob::Initialize(env); Babylon::Polyfills::File::Initialize(env); Babylon::Polyfills::TextDecoder::Initialize(env); Babylon::Polyfills::TextEncoder::Initialize(env); - Babylon::Polyfills::Streams::Initialize(env); + Babylon::Polyfills::Fetch::Initialize(env); auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { @@ -192,6 +192,33 @@ TEST(Streams, PreservesHostConstructorsAndIsIdempotent) done.get_future().get(); } +TEST(Fetch, PreservesHostClassesAndIsIdempotent) +{ + Babylon::AppRuntime runtime{}; + std::promise done; + + runtime.Dispatch([&done](Napi::Env env) { + auto global = env.Global(); + const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); + const auto hostResponse = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostResponse"); + global.Set("Headers", hostHeaders); + global.Set("Response", hostResponse); + + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); + + const auto installedFetch = global.Get("fetch"); + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); + EXPECT_TRUE(global.Get("fetch").StrictEquals(installedFetch)); + done.set_value(); + }); + + done.get_future().get(); +} + TEST(Console, Log) { Babylon::AppRuntime runtime{}; From 4b2961d813eea3a69eef288fd287ea9bb622c18d Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 23:28:31 -0700 Subject: [PATCH 090/174] Handle empty Response byte bodies Close byte streams for zero-length BufferSource bodies without enqueueing an invalid empty chunk. Preserve the non-null body and bodyUsed semantics, and add focused regression coverage alongside the WPT empty-response cases. --- Polyfills/Fetch/Source/FetchPolyfill.js | 4 +++- Tests/UnitTests/Scripts/tests.ts | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js index 93f6811a..e41ee182 100644 --- a/Polyfills/Fetch/Source/FetchPolyfill.js +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -286,7 +286,9 @@ if (chunk !== null) { var value = chunk; chunk = null; - controller.enqueue(value); + if (value.byteLength !== 0) { + controller.enqueue(value); + } } controller.close(); }, diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 1eca74f0..17a99a6d 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -424,6 +424,16 @@ describe("Response", function () { expect(jsonResponse.bodyUsed).to.equal(false); }); + // Byte streams reject zero-length enqueues. An empty BufferSource still + // represents a non-null body, but its stream must close without a chunk. + it("consumes an empty BufferSource without enqueueing an empty byte chunk", async function () { + const response = new Response(new Uint8Array(0)); + expect(response.body).to.be.instanceOf(ReadableStream); + expect(response.bodyUsed).to.equal(false); + expect(new Uint8Array(await response.arrayBuffer())).to.eql(new Uint8Array(0)); + expect(response.bodyUsed).to.equal(true); + }); + it("snapshots mutable BufferSource input once", async function () { const input = new Uint8Array([80, 65, 83, 83]); const response = new Response(input); From 476cc2b5120620bf7dfdafb6eedf8390007ae7a8 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 18:01:34 -0700 Subject: [PATCH 091/174] Support data URLs in the fetch polyfill Resolve percent-encoded and base64 data URLs without entering the network transport. Use a validating WHATWG-style forgiving-base64 decoder, strip URL fragments from payloads, and preserve response metadata through the standard Response path. Decode into pre-sized native storage and copy the completed body once into JavaScript-owned memory. Cover representative WPT data URL and forgiving-base64 vectors, plus Chromium whitespace cases. --- Polyfills/Fetch/Source/Fetch.cpp | 317 +++++++++++++++++++++++++++---- Tests/UnitTests/Scripts/tests.ts | 65 +++++++ 2 files changed, 350 insertions(+), 32 deletions(-) diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index 5bbf6001..520abb65 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -12,9 +12,11 @@ #include #include #include +#include #include #include #include +#include namespace Babylon::Polyfills::Internal { @@ -53,6 +55,195 @@ namespace Babylon::Polyfills::Internal }); } + struct DataUrlResponse + { + std::string contentType; + std::string url; + std::vector body; + }; + + bool IsAsciiWhitespace(uint8_t value) + { + return value == 0x09 || value == 0x0A || value == 0x0C || value == 0x0D || value == 0x20; + } + + void TrimAsciiWhitespace(std::string& value) + { + const auto first = std::find_if_not(value.begin(), value.end(), [](unsigned char character) { + return IsAsciiWhitespace(character); + }); + const auto last = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char character) { + return IsAsciiWhitespace(character); + }).base(); + value = first < last ? std::string{first, last} : std::string{}; + } + + int HexDigitValue(char value) + { + if (value >= '0' && value <= '9') + { + return value - '0'; + } + if (value >= 'a' && value <= 'f') + { + return value - 'a' + 10; + } + if (value >= 'A' && value <= 'F') + { + return value - 'A' + 10; + } + return -1; + } + + std::vector PercentDecode(std::string_view value) + { + std::vector decoded; + decoded.reserve(value.size()); + for (size_t index = 0; index < value.size(); ++index) + { + if (value[index] == '%' && index + 2 < value.size()) + { + const int high = HexDigitValue(value[index + 1]); + const int low = HexDigitValue(value[index + 2]); + if (high >= 0 && low >= 0) + { + decoded.push_back(static_cast((high << 4) | low)); + index += 2; + continue; + } + } + decoded.push_back(static_cast(value[index])); + } + return decoded; + } + + int Base64DigitValue(uint8_t value) + { + if (value >= 'A' && value <= 'Z') + { + return value - 'A'; + } + if (value >= 'a' && value <= 'z') + { + return value - 'a' + 26; + } + if (value >= '0' && value <= '9') + { + return value - '0' + 52; + } + if (value == '+') + { + return 62; + } + if (value == '/') + { + return 63; + } + return -1; + } + + std::vector ForgivingBase64Decode(const std::vector& input) + { + size_t digitCount{}; + size_t paddingCount{}; + bool sawPadding{}; + for (const auto value : input) + { + if (IsAsciiWhitespace(value)) + { + continue; + } + if (value == '=') + { + sawPadding = true; + ++paddingCount; + continue; + } + if (sawPadding || Base64DigitValue(value) < 0) + { + throw std::runtime_error{"fetch: invalid base64 data URL"}; + } + ++digitCount; + } + + const auto encodedCount = digitCount + paddingCount; + if ((paddingCount > 0 && (encodedCount % 4 != 0 || paddingCount > 2)) || digitCount % 4 == 1) + { + throw std::runtime_error{"fetch: invalid base64 data URL"}; + } + + std::vector decoded; + decoded.reserve(digitCount * 6 / 8); + uint32_t accumulator{}; + size_t availableBits{}; + for (const auto value : input) + { + if (IsAsciiWhitespace(value) || value == '=') + { + continue; + } + accumulator = (accumulator << 6) | static_cast(Base64DigitValue(value)); + availableBits += 6; + if (availableBits >= 8) + { + availableBits -= 8; + decoded.push_back(static_cast(accumulator >> availableBits)); + accumulator &= (uint32_t{1} << availableBits) - 1; + } + } + return decoded; + } + + std::optional ParseDataUrl(std::string_view url) + { + if (url.size() < 5 || !EqualsIgnoreCase(url.substr(0, 4), "data") || url[4] != ':') + { + return std::nullopt; + } + + const auto comma = url.find(',', 5); + if (comma == std::string_view::npos) + { + throw std::runtime_error{"fetch: malformed data URL"}; + } + + std::string mediaType{url.substr(5, comma - 5)}; + TrimAsciiWhitespace(mediaType); + bool base64 = false; + if (const auto semicolon = mediaType.rfind(';'); semicolon != std::string::npos) + { + std::string finalParameter{mediaType.substr(semicolon + 1)}; + TrimAsciiWhitespace(finalParameter); + if (EqualsIgnoreCase(finalParameter, "base64")) + { + mediaType.resize(semicolon); + TrimAsciiWhitespace(mediaType); + base64 = true; + } + } + if (mediaType.empty()) + { + mediaType = "text/plain;charset=US-ASCII"; + } + else if (mediaType.front() == ';') + { + mediaType.insert(0, "text/plain"); + } + + const auto fragment = url.find('#', comma + 1); + const auto payload = url.substr(comma + 1, fragment == std::string_view::npos ? std::string_view::npos : fragment - comma - 1); + auto decodedPayload = PercentDecode(payload); + if (base64) + { + decodedPayload = ForgivingBase64Decode(decodedPayload); + } + + return DataUrlResponse{ + std::move(mediaType), + std::string{url.substr(0, fragment)}, + std::move(decodedPayload)}; + } + // Stable message used for every transport-failure rejection. Browsers and Node both keep // this constant (the variable detail rides on `cause`) so crash-report grouping stays // intact; we follow Node/undici's "fetch failed" spelling. @@ -181,6 +372,49 @@ namespace Babylon::Polyfills::Internal } JsRuntime::NativeObject::GetFromJavaScript(env).Set("createFetchResponse", exports.Get("createFetchResponse")); } + + template + Napi::Value CreateFetchResponse( + Napi::Env env, + const void* body, + size_t bodySize, + const THeaders& headers, + int status, + std::string_view statusText, + std::string_view url, + bool redirected) + { + auto arrayBuffer = Napi::ArrayBuffer::New(env, bodySize); + if (bodySize > 0) + { + std::memcpy(arrayBuffer.Data(), body, bodySize); + } + const auto bytes = Napi::Uint8Array::New(env, bodySize, arrayBuffer, 0); + + auto responseHeaders = Napi::Array::New(env, headers.size()); + uint32_t headerIndex{}; + for (const auto& header : headers) + { + auto pair = Napi::Array::New(env, 2); + pair.Set(uint32_t{0}, Napi::String::New(env, header.first)); + pair.Set(uint32_t{1}, Napi::String::New(env, header.second)); + responseHeaders.Set(headerIndex++, pair); + } + + auto init = Napi::Object::New(env); + init.Set("headers", responseHeaders); + init.Set("status", Napi::Number::New(env, status)); + init.Set("statusText", Napi::String::New(env, statusText.data(), statusText.size())); + + auto metadata = Napi::Object::New(env); + metadata.Set("redirected", Napi::Boolean::New(env, redirected)); + metadata.Set("type", Napi::String::New(env, "basic")); + metadata.Set("url", Napi::String::New(env, url.data(), url.size())); + + const auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); + const auto createResponse = nativeObject.Get("createFetchResponse").As(); + return createResponse.Call(nativeObject, {env.Global().Get("Response"), bytes, init, metadata}); + } } namespace Fetch @@ -246,6 +480,47 @@ namespace Babylon::Polyfills::Internal signal = init.Get("signal"); } + if (signal.IsObject()) + { + const auto signalObject = signal.As(); + if (signalObject.Get("aborted").ToBoolean().Value()) + { + deferred.Reject(GetAbortReason(env, signalObject)); + return deferred.Promise(); + } + } + + std::optional dataUrl; + try + { + dataUrl = ParseDataUrl(url); + } + catch (const std::runtime_error& error) + { + deferred.Reject(Napi::TypeError::New(env, error.what()).Value()); + return deferred.Promise(); + } + + if (dataUrl) + { + if (method != UrlLib::UrlMethod::Get || body.has_value()) + { + throw std::runtime_error{"fetch: data URLs only support GET requests"}; + } + const std::vector> responseHeaders{ + {"content-type", dataUrl->contentType}}; + deferred.Resolve(CreateFetchResponse( + env, + dataUrl->body.data(), + dataUrl->body.size(), + responseHeaders, + 200, + "OK", + dataUrl->url, + false)); + return deferred.Promise(); + } + auto request = std::make_shared(); request->Open(method, url); request->ResponseType(UrlLib::UrlResponseType::Buffer); @@ -337,40 +612,18 @@ namespace Babylon::Polyfills::Internal } const auto responseBuffer = request->ResponseBuffer(); - auto arrayBuffer = Napi::ArrayBuffer::New(env, responseBuffer.size()); - if (!responseBuffer.empty()) - { - std::memcpy(arrayBuffer.Data(), responseBuffer.data(), responseBuffer.size()); - } - const auto bytes = Napi::Uint8Array::New(env, responseBuffer.size(), arrayBuffer, 0); - - auto responseHeaders = Napi::Array::New(env, request->GetAllResponseHeaders().size()); - uint32_t headerIndex{}; - for (const auto& header : request->GetAllResponseHeaders()) - { - auto pair = Napi::Array::New(env, 2); - pair.Set(uint32_t{0}, Napi::String::New(env, header.first)); - pair.Set(uint32_t{1}, Napi::String::New(env, header.second)); - responseHeaders.Set(headerIndex++, pair); - } - - auto init = Napi::Object::New(env); - init.Set("headers", responseHeaders); - init.Set("status", Napi::Number::New(env, status)); const auto statusText = request->StatusText(); - init.Set("statusText", Napi::String::New(env, statusText.data(), statusText.size())); - const std::string responseUrl{request->ResponseUrl()}; - auto metadata = Napi::Object::New(env); - metadata.Set("redirected", Napi::Boolean::New(env, !responseUrl.empty() && responseUrl != url)); - metadata.Set("type", Napi::String::New(env, "basic")); - metadata.Set("url", Napi::String::New(env, responseUrl.empty() ? url : responseUrl)); - - const auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); - const auto createResponse = nativeObject.Get("createFetchResponse").As(); - deferred.Resolve(createResponse.Call( - nativeObject, - {env.Global().Get("Response"), bytes, init, metadata})); + const std::string_view finalUrl = responseUrl.empty() ? std::string_view{url} : std::string_view{responseUrl}; + deferred.Resolve(CreateFetchResponse( + env, + responseBuffer.data(), + responseBuffer.size(), + request->GetAllResponseHeaders(), + status, + statusText, + finalUrl, + !responseUrl.empty() && responseUrl != url)); }) .then(*scheduler, arcana::cancellation::none(), [deferred, env, scheduler](const arcana::expected& result) { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 17a99a6d..28073017 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -581,6 +581,71 @@ describe("fetch", function () { expect(await response.text()).to.equal("var symlink_target_js = true;"); }); + it("should resolve percent-encoded data URLs locally", async function () { + const url = "data:text/plain;charset=utf-8,hello%20native%20fetch%21"; + const response = await fetch(url); + expect(response.ok).to.equal(true); + expect(response.status).to.equal(200); + expect(response.url).to.equal(url); + expect(response.headers.get("content-type")).to.equal("text/plain;charset=utf-8"); + expect(await response.text()).to.equal("hello native fetch!"); + }); + + it("should decode base64 data URLs without using the network transport", async function () { + const response = await fetch("data:application/octet-stream;base64,AAEC/w=="); + const clone = response.clone(); + expect(new Uint8Array(await response.arrayBuffer())).to.eql(new Uint8Array([0, 1, 2, 255])); + const blob = await clone.blob(); + expect(blob.type).to.equal("application/octet-stream"); + expect(new Uint8Array(await blob.arrayBuffer())).to.eql(new Uint8Array([0, 1, 2, 255])); + }); + + // Adapted from WPT fetch/data-urls/processing.any.js and resources/data-urls.json. + const dataUrlCases: Array<[string, string, number[]]> = [ + ["data:,", "text/plain;charset=US-ASCII", []], + ["data:,%FF", "text/plain;charset=US-ASCII", [255]], + ["data:text/plain,X", "text/plain", [88]], + ["data:,X#fragment", "text/plain;charset=US-ASCII", [88]], + ["data:;BASe64,WA", "text/plain;charset=US-ASCII", [88]], + ["data: ;charset=x ; base64,W%20A", "text/plain;charset=x", [88]] + ]; + + for (const [url, expectedType, expectedBody] of dataUrlCases) { + it(`should process WPT data URL case ${JSON.stringify(url)}`, async function () { + const response = await fetch(url); + expect(response.headers.get("content-type")).to.equal(expectedType); + expect(Array.from(new Uint8Array(await response.arrayBuffer()))).to.eql(expectedBody); + }); + } + + // Adapted from WPT's forgiving-base64 vectors and Chromium's DataURL tests. + const base64Cases: Array<[string, number[]]> = [ + ["abcd", [105, 183, 29]], + ["ab%09%0A%0C%0D%20cd", [105, 183, 29]], + ["ab==", [105]], + ["/A", [252]], + ["YR", [97]] + ]; + + for (const [encoded, expectedBody] of base64Cases) { + it(`should forgiving-base64 decode ${JSON.stringify(encoded)}`, async function () { + const response = await fetch(`data:application/octet-stream;base64,${encoded}`); + expect(Array.from(new Uint8Array(await response.arrayBuffer()))).to.eql(expectedBody); + }); + } + + for (const encoded of ["a", "ab===", "ab%0Bcd", "=a", "a=b"]) { + it(`should reject invalid WPT base64 case ${JSON.stringify(encoded)}`, async function () { + let error: unknown; + try { + await fetch(`data:application/octet-stream;base64,${encoded}`); + } catch (caught) { + error = caught; + } + expect(error).to.be.instanceOf(TypeError); + }); + } + it("arrayBuffer() should return the body as bytes", async function () { const response = await fetch("app:///Scripts/symlink_target.js"); const expected = new Uint8Array("var symlink_target_js = true;".split("").map(x => x.charCodeAt(0))); From e04a95f5cf98e0ea672f4424fc3aacfb690d9600 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Tue, 21 Jul 2026 23:57:04 -0700 Subject: [PATCH 092/174] Avoid intermediate data URL decode buffers Feed percent-decoded bytes directly into validating and decoding passes for Base64 data URLs. Allocate the final native payload at its exact size, avoiding the previous percent-decoded staging vector and any vector growth before the single JavaScript ownership copy. --- Polyfills/Fetch/Source/Fetch.cpp | 48 +++++++++++++++++--------------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index 520abb65..c573c7e6 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -95,10 +95,9 @@ namespace Babylon::Polyfills::Internal return -1; } - std::vector PercentDecode(std::string_view value) + template + void ForEachPercentDecodedByte(std::string_view value, TCallback&& callback) { - std::vector decoded; - decoded.reserve(value.size()); for (size_t index = 0; index < value.size(); ++index) { if (value[index] == '%' && index + 2 < value.size()) @@ -107,13 +106,22 @@ namespace Babylon::Polyfills::Internal const int low = HexDigitValue(value[index + 2]); if (high >= 0 && low >= 0) { - decoded.push_back(static_cast((high << 4) | low)); + callback(static_cast((high << 4) | low)); index += 2; continue; } } - decoded.push_back(static_cast(value[index])); + callback(static_cast(value[index])); } + } + + std::vector PercentDecode(std::string_view value) + { + std::vector decoded; + decoded.reserve(value.size()); + ForEachPercentDecodedByte(value, [&decoded](uint8_t byte) { + decoded.push_back(byte); + }); return decoded; } @@ -142,29 +150,28 @@ namespace Babylon::Polyfills::Internal return -1; } - std::vector ForgivingBase64Decode(const std::vector& input) + std::vector ForgivingBase64Decode(std::string_view input) { size_t digitCount{}; size_t paddingCount{}; bool sawPadding{}; - for (const auto value : input) - { + ForEachPercentDecodedByte(input, [&](uint8_t value) { if (IsAsciiWhitespace(value)) { - continue; + return; } if (value == '=') { sawPadding = true; ++paddingCount; - continue; + return; } if (sawPadding || Base64DigitValue(value) < 0) { throw std::runtime_error{"fetch: invalid base64 data URL"}; } ++digitCount; - } + }); const auto encodedCount = digitCount + paddingCount; if ((paddingCount > 0 && (encodedCount % 4 != 0 || paddingCount > 2)) || digitCount % 4 == 1) @@ -172,25 +179,24 @@ namespace Babylon::Polyfills::Internal throw std::runtime_error{"fetch: invalid base64 data URL"}; } - std::vector decoded; - decoded.reserve(digitCount * 6 / 8); + std::vector decoded(digitCount / 4 * 3 + digitCount % 4 * 3 / 4); + size_t outputIndex{}; uint32_t accumulator{}; size_t availableBits{}; - for (const auto value : input) - { + ForEachPercentDecodedByte(input, [&](uint8_t value) { if (IsAsciiWhitespace(value) || value == '=') { - continue; + return; } accumulator = (accumulator << 6) | static_cast(Base64DigitValue(value)); availableBits += 6; if (availableBits >= 8) { availableBits -= 8; - decoded.push_back(static_cast(accumulator >> availableBits)); + decoded[outputIndex++] = static_cast(accumulator >> availableBits); accumulator &= (uint32_t{1} << availableBits) - 1; } - } + }); return decoded; } @@ -232,11 +238,7 @@ namespace Babylon::Polyfills::Internal const auto fragment = url.find('#', comma + 1); const auto payload = url.substr(comma + 1, fragment == std::string_view::npos ? std::string_view::npos : fragment - comma - 1); - auto decodedPayload = PercentDecode(payload); - if (base64) - { - decodedPayload = ForgivingBase64Decode(decodedPayload); - } + auto decodedPayload = base64 ? ForgivingBase64Decode(payload) : PercentDecode(payload); return DataUrlResponse{ std::move(mediaType), From a823b2ffe2117ec73b1c8333cbedaf799f588d2c Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:26:50 -0700 Subject: [PATCH 093/174] Keep Streams implementations internally consistent Replace a partial or null host Streams surface as a complete constructor suite so stream products retain compatible instanceof relationships. Preserve a complete suite on repeated initialization.\n\nHarden the native initialization test so N-API failures complete the test promise instead of hanging, and cover partial host replacement plus null handling and cross-constructor compatibility. --- Polyfills/Streams/Source/Streams.cpp | 8 ++---- Tests/UnitTests/Shared/Shared.cpp | 42 +++++++++++++++++++++------- 2 files changed, 35 insertions(+), 15 deletions(-) diff --git a/Polyfills/Streams/Source/Streams.cpp b/Polyfills/Streams/Source/Streams.cpp index 4552ed07..e742344f 100644 --- a/Polyfills/Streams/Source/Streams.cpp +++ b/Polyfills/Streams/Source/Streams.cpp @@ -31,7 +31,8 @@ namespace Babylon::Polyfills::Streams bool needsPonyfill{}; for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) + const auto constructor = global.Get(name.data()); + if (constructor.IsUndefined() || constructor.IsNull()) { needsPonyfill = true; break; @@ -46,10 +47,7 @@ namespace Babylon::Polyfills::Streams const auto exports = Napi::Eval(env, Internal::StreamsScripts::Ponyfill.data(), "jsruntimehost://web-streams-polyfill.js").As(); for (const auto name : constructorNames) { - if (global.Get(name.data()).IsUndefined()) - { - global.Set(name.data(), exports.Get(name.data())); - } + global.Set(name.data(), exports.Get(name.data())); } } } diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 3b78d2fb..e60e7b70 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -168,28 +168,50 @@ TEST(Scheduling, IntervalSurvivesThrowingCallback) EXPECT_EQ(unhandledErrorCount.load(), 2); } -TEST(Streams, PreservesHostConstructorsAndIsIdempotent) +TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; - runtime.Dispatch([&done](Napi::Env env) { + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostReadableStream = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostReadableStream"); global.Set("ReadableStream", hostReadableStream); + global.Set("TransformStream", env.Null()); Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); - EXPECT_TRUE(global.Get("TransformStream").IsFunction()); - + const auto installedReadableStream = global.Get("ReadableStream"); const auto installedTransformStream = global.Get("TransformStream"); + EXPECT_FALSE(installedReadableStream.StrictEquals(hostReadableStream)); + if (!installedReadableStream.IsFunction() || !installedTransformStream.IsFunction()) + { + complete("Streams::Initialize did not install a complete constructor suite."); + return; + } + + const auto transform = installedTransformStream.As().New({}); + EXPECT_TRUE(transform.Get("readable").As().InstanceOf(installedReadableStream.As())); + Babylon::Polyfills::Streams::Initialize(env); - EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(hostReadableStream)); + EXPECT_TRUE(global.Get("ReadableStream").StrictEquals(installedReadableStream)); EXPECT_TRUE(global.Get("TransformStream").StrictEquals(installedTransformStream)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Fetch, PreservesHostClassesAndIsIdempotent) From e29e752de91fee590962e224904d898945b653de Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:29:36 -0700 Subject: [PATCH 094/174] Write Blob BYOB reads into caller buffers Use ReadableByteStreamController.byobRequest views directly and respond with the produced byte count instead of allocating and enqueueing a 64 KiB intermediate chunk. Keep the existing bounded allocation path for default readers.\n\nAdd WPT-derived coverage for small offset BYOB views that cross immutable Blob segment boundaries. --- Polyfills/Blob/Source/Blob.cpp | 69 +++++++++++++++++++++----------- Tests/UnitTests/Scripts/tests.ts | 27 +++++++++++++ 2 files changed, 73 insertions(+), 23 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index bed99cb6..635bb7e1 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -310,33 +310,56 @@ namespace Babylon::Polyfills::Internal } constexpr size_t CHUNK_SIZE = 64 * 1024; - const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); - auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); - auto destination = static_cast(outputBuffer.Data()); - auto segmentIndex = state->SegmentIndex; - auto segmentOffset = state->SegmentOffset; - size_t remaining = outputLength; - - while (remaining > 0) + const auto copyInto = [&state](std::byte* destination, size_t outputLength) { + auto segmentIndex = state->SegmentIndex; + auto segmentOffset = state->SegmentOffset; + size_t remaining = outputLength; + + while (remaining > 0) + { + const auto& segment = state->BlobData->Segments[segmentIndex]; + const auto copyLength = std::min(segment.Length - segmentOffset, remaining); + std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); + destination += copyLength; + remaining -= copyLength; + segmentOffset += copyLength; + if (segmentOffset == segment.Length) + { + ++segmentIndex; + segmentOffset = 0; + } + } + + state->Position += outputLength; + state->SegmentIndex = segmentIndex; + state->SegmentOffset = segmentOffset; + }; + + const auto byobRequestValue = controller.Get("byobRequest"); + if (!byobRequestValue.IsUndefined() && !byobRequestValue.IsNull()) { - const auto& segment = state->BlobData->Segments[segmentIndex]; - const auto copyLength = std::min(segment.Length - segmentOffset, remaining); - std::memcpy(destination, segment.Bytes->data() + segment.Offset + segmentOffset, copyLength); - destination += copyLength; - remaining -= copyLength; - segmentOffset += copyLength; - if (segmentOffset == segment.Length) + const auto byobRequest = byobRequestValue.As(); + const auto viewValue = byobRequest.Get("view"); + if (!viewValue.IsTypedArray()) { - ++segmentIndex; - segmentOffset = 0; + throw Napi::TypeError::New(callbackEnv, "Blob.stream() received an invalid BYOB request view."); } - } - auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); - controller.Get("enqueue").As().Call(controller, {output}); - state->Position += outputLength; - state->SegmentIndex = segmentIndex; - state->SegmentOffset = segmentOffset; + const auto view = viewValue.As(); + const auto outputLength = std::min({CHUNK_SIZE, view.ByteLength(), state->BlobData->Size - state->Position}); + const auto outputBuffer = view.ArrayBuffer(); + auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); + copyInto(destination, outputLength); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); + } + else + { + const auto outputLength = std::min(CHUNK_SIZE, state->BlobData->Size - state->Position); + auto outputBuffer = Napi::ArrayBuffer::New(callbackEnv, outputLength); + copyInto(static_cast(outputBuffer.Data()), outputLength); + auto output = Napi::Uint8Array::New(callbackEnv, outputLength, outputBuffer, 0); + controller.Get("enqueue").As().Call(controller, {output}); + } if (state->Position == state->BlobData->Size) { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 28073017..7b9ca0dc 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -2281,6 +2281,33 @@ describe("Blob", function () { expect(await readStream(new Blob().stream())).to.deep.equal([]); }); + // Adapted from WPT streams/readable-byte-streams/general.any.js BYOB + // coverage. Small, offset views exercise the caller-owned output path. + it("fills bounded BYOB views across Blob segment boundaries", async function () { + const input = new Uint8Array(97); + for (let index = 0; index < input.length; ++index) { + input[index] = (index * 31) & 0xff; + } + + const blob = new Blob([input.subarray(0, 11), input.subarray(11, 53), input.subarray(53)]); + const reader = blob.stream().getReader({ mode: "byob" }); + const output: number[] = []; + const requestSizes = [1, 3, 7, 16]; + let requestIndex = 0; + while (true) { + const requestSize = requestSizes[requestIndex++ % requestSizes.length]; + const request = new Uint8Array(new ArrayBuffer(requestSize + 4), 2, requestSize); + const result = await reader.read(request); + if (result.done) { + break; + } + expect(result.value!.byteLength).to.be.at.most(requestSize); + output.push(...Array.from(result.value!)); + } + + expect(output).to.deep.equal(Array.from(input)); + }); + it("keeps independent stream cursors after the Blob reference is dropped", async function () { let blob: Blob | null = new Blob(["PASS"]); const first = blob.stream(); From 006a18d6e3b44c0e33ddb25f515049e5c2c6b88f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 22 Jul 2026 00:39:52 -0700 Subject: [PATCH 095/174] Track Response body disturbance through stream operations Observe standard ReadableStream consumption paths with weak per-stream state instead of depending on web-streams-polyfill's private _disturbed field. Instrument stream readers and piping once during Fetch initialization, preserve stream identity, and cache the initialized Fetch implementation so repeated initialization does not stack wrappers or replace its internal state. Treat Headers and Response as an implementation pair when either host global is missing or null. Harden native initialization tests against unhandled N-API failures and add WPT-derived coverage for reads, cancellation, piping, and streams disturbed before Response construction. --- Polyfills/Fetch/Source/Fetch.cpp | 17 ++-- Polyfills/Fetch/Source/FetchPolyfill.js | 104 +++++++++++++++++++++++- Tests/UnitTests/Scripts/tests.ts | 60 +++++++++++++- Tests/UnitTests/Shared/Shared.cpp | 71 ++++++++++++++-- 4 files changed, 237 insertions(+), 15 deletions(-) diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index c573c7e6..a7dd3bd2 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -250,6 +250,7 @@ namespace Babylon::Polyfills::Internal // this constant (the variable detail rides on `cause`) so crash-report grouping stays // intact; we follow Node/undici's "fetch failed" spelling. constexpr const char* FETCH_FAILED_MESSAGE = "fetch failed"; + constexpr const char* JS_FETCH_POLYFILL_EXPORTS_NAME = "fetchPolyfillExports"; // Snapshot the JS call-site stack synchronously, inside fetch(), before SendAsync() hands // the request to a worker thread. The transport-failure rejection is otherwise built in a @@ -363,16 +364,22 @@ namespace Babylon::Polyfills::Internal void InitializeFetchClasses(Napi::Env env) { auto global = env.Global(); - const auto exports = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js").As(); - if (global.Get("Headers").IsUndefined()) + auto nativeObject = JsRuntime::NativeObject::GetFromJavaScript(env); + auto exportsValue = nativeObject.Get(JS_FETCH_POLYFILL_EXPORTS_NAME); + if (exportsValue.IsUndefined() || exportsValue.IsNull()) { - global.Set("Headers", exports.Get("Headers")); + exportsValue = Napi::Eval(env, FetchScripts::Polyfill, "jsruntimehost://fetch-polyfill.js"); + nativeObject.Set(JS_FETCH_POLYFILL_EXPORTS_NAME, exportsValue); } - if (global.Get("Response").IsUndefined()) + const auto exports = exportsValue.As(); + const auto headers = global.Get("Headers"); + const auto response = global.Get("Response"); + if (headers.IsUndefined() || headers.IsNull() || response.IsUndefined() || response.IsNull()) { + global.Set("Headers", exports.Get("Headers")); global.Set("Response", exports.Get("Response")); } - JsRuntime::NativeObject::GetFromJavaScript(env).Set("createFetchResponse", exports.Get("createFetchResponse")); + nativeObject.Set("createFetchResponse", exports.Get("createFetchResponse")); } template diff --git a/Polyfills/Fetch/Source/FetchPolyfill.js b/Polyfills/Fetch/Source/FetchPolyfill.js index e41ee182..4435d1ef 100644 --- a/Polyfills/Fetch/Source/FetchPolyfill.js +++ b/Polyfills/Fetch/Source/FetchPolyfill.js @@ -3,9 +3,105 @@ var headerStates = new WeakMap(); var responseStates = new WeakMap(); + var streamTrackers = new WeakMap(); + var readerTrackers = new WeakMap(); + var iteratorTrackers = new WeakMap(); var headerNamePattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; var nullBodyStatuses = [204, 205, 304]; + function wrapMethod(target, name, createWrapper) { + var descriptor = Object.getOwnPropertyDescriptor(target, name); + var original = descriptor ? descriptor.value : target[name]; + if (typeof original !== "function") { + return; + } + if (!descriptor) { + descriptor = { + configurable: true, + enumerable: false, + writable: true + }; + } + descriptor.value = createWrapper(original); + Object.defineProperty(target, name, descriptor); + } + + function trackStream(stream) { + var tracker = streamTrackers.get(stream); + if (!tracker) { + tracker = { disturbed: false }; + streamTrackers.set(stream, tracker); + } + return tracker; + } + + function trackReader(reader, tracker) { + if (readerTrackers.has(reader)) { + return reader; + } + readerTrackers.set(reader, tracker); + for (var name of ["read", "cancel"]) { + wrapMethod(reader, name, function(original) { + return function() { + tracker.disturbed = true; + return original.apply(this, arguments); + }; + }); + } + return reader; + } + + function trackIterator(iterator, tracker) { + if (iteratorTrackers.has(iterator)) { + return iterator; + } + iteratorTrackers.set(iterator, tracker); + for (var name of ["next", "return", "throw"]) { + wrapMethod(iterator, name, function(original) { + return function() { + tracker.disturbed = true; + return original.apply(this, arguments); + }; + }); + } + return iterator; + } + + function instrumentReadableStreams() { + if (global.ReadableStream === undefined || global.ReadableStream === null) { + return; + } + var prototype = global.ReadableStream.prototype; + wrapMethod(prototype, "getReader", function(original) { + return function() { + return trackReader(original.apply(this, arguments), trackStream(this)); + }; + }); + for (var name of ["cancel", "pipeTo", "pipeThrough", "tee"]) { + wrapMethod(prototype, name, function(original) { + return function() { + var result = original.apply(this, arguments); + trackStream(this).disturbed = true; + return result; + }; + }); + } + wrapMethod(prototype, "values", function(original) { + return function() { + return trackIterator(original.apply(this, arguments), trackStream(this)); + }; + }); + if (typeof Symbol.asyncIterator === "symbol") { + wrapMethod(prototype, Symbol.asyncIterator, function(original) { + return function() { + return trackIterator(original.apply(this, arguments), trackStream(this)); + }; + }); + } + } + + instrumentReadableStreams(); + function requireHeaderState(value) { var state = headerStates.get(value); if (!state) { @@ -315,7 +411,7 @@ return { stream: null, contentType: null }; } if (isReadableStream(body)) { - if (body.locked || body._disturbed) { + if (body.locked || trackStream(body).disturbed) { throw new TypeError("Response body stream is already disturbed or locked"); } return { stream: body, contentType: null }; @@ -343,7 +439,7 @@ } function bodyIsUnusable(state) { - return state.used || (state.body !== null && (state.body.locked || state.body._disturbed)); + return state.used || (state.body !== null && (state.body.locked || state.bodyTracker.disturbed)); } async function readBodyChunks(state) { @@ -458,6 +554,7 @@ responseStates.set(response, { body: extracted.stream, + bodyTracker: extracted.stream === null ? null : trackStream(extracted.stream), headers: normalizedInit.headers, redirected: metadata && metadata.redirected === true, status: normalizedInit.status, @@ -476,7 +573,7 @@ get body() { return requireResponseState(this).body; } get bodyUsed() { var state = requireResponseState(this); - return state.used || (state.body !== null && state.body._disturbed === true); + return state.used || (state.body !== null && state.bodyTracker.disturbed); } get headers() { return requireResponseState(this).headers; } get ok() { @@ -517,6 +614,7 @@ if (state.body !== null) { var branches = state.body.tee(); state.body = branches[0]; + state.bodyTracker = trackStream(state.body); cloneBody = branches[1]; } var clone = new Response(cloneBody, { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 7b9ca0dc..aab3b8c7 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -471,8 +471,23 @@ describe("Response", function () { expect(await clone.text()).to.equal("clone body"); }); + function withoutPrivateDisturbedState(stream: ReadableStream): ReadableStream { + Object.defineProperty(stream, "_disturbed", { + configurable: true, + get() { return undefined; }, + set() {} + }); + return stream; + } + it("tracks direct stream reads and rejects invalid body chunks", async function () { - const direct = new Response("body"); + const directStream = withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.enqueue(new TextEncoder().encode("body")); + controller.close(); + } + })); + const direct = new Response(directStream); const reader = direct.body!.getReader(); expect(direct.bodyUsed).to.equal(false); await reader.read(); @@ -493,6 +508,49 @@ describe("Response", function () { expect(rejected).to.equal(true); }); + it("rejects a host-shaped stream disturbed before Response construction", async function () { + const stream = withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.enqueue(new Uint8Array([1])); + controller.close(); + } + })); + const reader = stream.getReader(); + await reader.read(); + reader.releaseLock(); + + expect(() => new Response(stream)).to.throw(TypeError); + }); + + // Focused ports from WPT response-stream-disturbed-6.any.js and + // response-stream-disturbed-by-pipe.any.js. These must not depend on a + // private field supplied by one particular Streams implementation. + it("tracks cancellation and piping through standard stream methods", async function () { + const cancelled = new Response(withoutPrivateDisturbedState(new ReadableStream())); + const cancelledReader = cancelled.body!.getReader(); + expect(cancelled.bodyUsed).to.equal(false); + await cancelledReader.cancel(); + expect(cancelled.bodyUsed).to.equal(true); + + const piped = new Response(withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.close(); + } + }))); + const pipePromise = piped.body!.pipeTo(new WritableStream({}, { highWaterMark: 0 })); + expect(piped.bodyUsed).to.equal(true); + await pipePromise; + + const pipedThrough = new Response(withoutPrivateDisturbedState(new ReadableStream({ + start(controller) { + controller.close(); + } + }))); + const output = pipedThrough.body!.pipeThrough(new TransformStream()); + expect(pipedThrough.bodyUsed).to.equal(true); + await output.cancel(); + }); + // Adapted from Firefox dom/fetch/tests/crashtests/1939295.html. The // unresolved read must remain safe through runtime teardown. it("does not crash while consuming an open empty stream", function () { diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index e60e7b70..b646144f 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -214,12 +214,24 @@ TEST(Streams, ReplacesPartialHostSuiteAndIsIdempotent) EXPECT_TRUE(error.empty()) << error; } -TEST(Fetch, PreservesHostClassesAndIsIdempotent) +TEST(Fetch, PreservesCompleteHostClassesAndIsIdempotent) { - Babylon::AppRuntime runtime{}; - std::promise done; + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; - runtime.Dispatch([&done](Napi::Env env) { + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { auto global = env.Global(); const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); const auto hostResponse = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostResponse"); @@ -235,10 +247,57 @@ TEST(Fetch, PreservesHostClassesAndIsIdempotent) EXPECT_TRUE(global.Get("Headers").StrictEquals(hostHeaders)); EXPECT_TRUE(global.Get("Response").StrictEquals(hostResponse)); EXPECT_TRUE(global.Get("fetch").StrictEquals(installedFetch)); - done.set_value(); + complete({}); }); - done.get_future().get(); + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; +} + +TEST(Fetch, ReplacesPartialOrNullHostClassesAsACompletePair) +{ + std::promise done; + std::atomic_bool completed{}; + const auto complete = [&done, &completed](std::string result) { + if (!completed.exchange(true)) + { + done.set_value(std::move(result)); + } + }; + + Babylon::AppRuntime::Options options{}; + options.UnhandledExceptionHandler = [&complete](const Napi::Error& error) { + complete(Napi::GetErrorString(error)); + }; + Babylon::AppRuntime runtime{options}; + + runtime.Dispatch([&complete](Napi::Env env) { + auto global = env.Global(); + const auto hostHeaders = Napi::Function::New(env, [](const Napi::CallbackInfo&) {}, "HostHeaders"); + global.Set("Headers", hostHeaders); + global.Set("Response", env.Null()); + + Babylon::Polyfills::Fetch::Initialize(env); + const auto installedHeaders = global.Get("Headers"); + const auto installedResponse = global.Get("Response"); + EXPECT_FALSE(installedHeaders.StrictEquals(hostHeaders)); + if (!installedHeaders.IsFunction() || !installedResponse.IsFunction()) + { + complete("Fetch::Initialize did not install a complete Headers/Response pair."); + return; + } + + const auto response = installedResponse.As().New({}); + EXPECT_TRUE(response.Get("headers").As().InstanceOf(installedHeaders.As())); + + Babylon::Polyfills::Fetch::Initialize(env); + EXPECT_TRUE(global.Get("Headers").StrictEquals(installedHeaders)); + EXPECT_TRUE(global.Get("Response").StrictEquals(installedResponse)); + complete({}); + }); + + const auto error = done.get_future().get(); + EXPECT_TRUE(error.empty()) << error; } TEST(Console, Log) From 517b29808f912adbd4ed27ff61ab83b27a7cc7cc Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 02:15:02 -0700 Subject: [PATCH 096/174] Preserve Streams bundle bytes across source splits --- Polyfills/Streams/Source/StreamsScripts.h.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 9bf7f5bf..126a23f7 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -9,9 +9,10 @@ namespace Babylon::Polyfills::Internal::StreamsScripts (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@ -)JSRHSTREAM"; +@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; + // Keep the split transparent: inserting whitespace here can divide an + // identifier or string literal when the vendored bundle is regenerated. inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ return module.exports; })() From 9b273a4339df3585582e72559c7861e6c134fedc Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:56:11 -0500 Subject: [PATCH 097/174] Streams: emit the embedded bundle as <=16 KB literals; link Streams into the Android test host MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535; the 71 KB bundle was emitted as two 60,000/11,188-byte raw strings, so every Windows and UWP job failed at "Build Solution". CMake now emits consecutive parts of at most 16,000 bytes, abutting with no separator (the split stays byte-transparent), and a variadic consteval Join reassembles them into the same std::array as before. The desktop UnitTests target links Streams for the Shared.cpp coverage but the Android UnitTestsJNI host did not, so the Android build failed on the include. --- Polyfills/Streams/CMakeLists.txt | 26 ++++++++++++- Polyfills/Streams/Source/StreamsScripts.h.in | 37 ++++++++++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 3 +- 3 files changed, 46 insertions(+), 20 deletions(-) diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt index 6c00ed81..6a756ccc 100644 --- a/Polyfills/Streams/CMakeLists.txt +++ b/Polyfills/Streams/CMakeLists.txt @@ -3,8 +3,30 @@ set(WEB_STREAMS_POLYFILL_FILE set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${WEB_STREAMS_POLYFILL_FILE}") file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +# MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535, so +# the bundle is emitted as consecutive raw-string parts of at most 16,000 bytes and joined back +# into one array at compile time. Parts abut with no separator so the split stays byte-transparent +# (a separator could land inside an identifier or string literal when the bundle is regenerated). +string(LENGTH "${WEB_STREAMS_POLYFILL_SOURCE}" _streams_length) +set(_streams_part_size 16000) +set(_streams_offset 0) +set(_streams_index 0) +set(WEB_STREAMS_POLYFILL_PARTS "") +set(WEB_STREAMS_POLYFILL_PART_NAMES "") +while(_streams_offset LESS _streams_length) + math(EXPR _streams_index "${_streams_index} + 1") + math(EXPR _streams_remaining "${_streams_length} - ${_streams_offset}") + if(_streams_remaining LESS _streams_part_size) + set(_streams_take ${_streams_remaining}) + else() + set(_streams_take ${_streams_part_size}) + endif() + string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" ${_streams_offset} ${_streams_take} _streams_part) + string(APPEND WEB_STREAMS_POLYFILL_PARTS + " inline constexpr char PonyfillPart${_streams_index}[] = R\"JSRHSTREAM(${_streams_part})JSRHSTREAM\";\n") + string(APPEND WEB_STREAMS_POLYFILL_PART_NAMES ", PonyfillPart${_streams_index}") + math(EXPR _streams_offset "${_streams_offset} + ${_streams_take}") +endwhile() configure_file( "Source/StreamsScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 126a23f7..6b145ef5 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -5,33 +5,36 @@ namespace Babylon::Polyfills::Internal::StreamsScripts { - inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( + // The vendored bundle is split by CMake into PonyfillPart1..N raw-string literals of at most + // 16,000 bytes each (MSVC C2026) and joined below. The prologue and epilogue wrap it as a + // CommonJS module so its exports can be read back. Nothing is inserted between parts: a + // separator could divide an identifier or string literal when the bundle is regenerated. + inline constexpr char PonyfillPrologue[] = R"JSRHSTREAM( (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; +)JSRHSTREAM"; - // Keep the split transparent: inserting whitespace here can divide an - // identifier or string literal when the vendored bundle is regenerated. - inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ +@WEB_STREAMS_POLYFILL_PARTS@ + inline constexpr char PonyfillEpilogue[] = R"JSRHSTREAM( return module.exports; })() )JSRHSTREAM"; - template - consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + template + consteval auto Join(const char (&... parts)[Sizes]) { - std::array result{}; - for (std::size_t index{}; index < Part1Size - 1; ++index) - { - result[index] = part1[index]; - } - for (std::size_t index{}; index < Part2Size; ++index) - { - result[Part1Size - 1 + index] = part2[index]; - } + std::array result{}; + std::size_t offset{}; + auto append = [&](const char* part, std::size_t size) { + for (std::size_t index{}; index + 1 < size; ++index) + { + result[offset++] = part[index]; + } + }; + (append(parts, Sizes), ...); return result; } - inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); + inline constexpr auto Ponyfill = Join(PonyfillPrologue@WEB_STREAMS_POLYFILL_PART_NAMES@, PonyfillEpilogue); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..844fa056 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -55,4 +55,5 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE Streams) \ No newline at end of file From 1e7557b6b8db45485e2520e6248cd51bf4f000f5 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:56:11 -0500 Subject: [PATCH 098/174] Streams: emit the embedded bundle as <=16 KB literals; link Streams into the Android test host MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535; the 71 KB bundle was emitted as two 60,000/11,188-byte raw strings, so every Windows and UWP job failed at "Build Solution". CMake now emits consecutive parts of at most 16,000 bytes, abutting with no separator (the split stays byte-transparent), and a variadic consteval Join reassembles them into the same std::array as before. The desktop UnitTests target links Streams for the Shared.cpp coverage but the Android UnitTestsJNI host did not, so the Android build failed on the include. --- Polyfills/Streams/CMakeLists.txt | 26 ++++++++++++- Polyfills/Streams/Source/StreamsScripts.h.in | 37 ++++++++++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 3 +- 3 files changed, 46 insertions(+), 20 deletions(-) diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt index 6c00ed81..6a756ccc 100644 --- a/Polyfills/Streams/CMakeLists.txt +++ b/Polyfills/Streams/CMakeLists.txt @@ -3,8 +3,30 @@ set(WEB_STREAMS_POLYFILL_FILE set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${WEB_STREAMS_POLYFILL_FILE}") file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +# MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535, so +# the bundle is emitted as consecutive raw-string parts of at most 16,000 bytes and joined back +# into one array at compile time. Parts abut with no separator so the split stays byte-transparent +# (a separator could land inside an identifier or string literal when the bundle is regenerated). +string(LENGTH "${WEB_STREAMS_POLYFILL_SOURCE}" _streams_length) +set(_streams_part_size 16000) +set(_streams_offset 0) +set(_streams_index 0) +set(WEB_STREAMS_POLYFILL_PARTS "") +set(WEB_STREAMS_POLYFILL_PART_NAMES "") +while(_streams_offset LESS _streams_length) + math(EXPR _streams_index "${_streams_index} + 1") + math(EXPR _streams_remaining "${_streams_length} - ${_streams_offset}") + if(_streams_remaining LESS _streams_part_size) + set(_streams_take ${_streams_remaining}) + else() + set(_streams_take ${_streams_part_size}) + endif() + string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" ${_streams_offset} ${_streams_take} _streams_part) + string(APPEND WEB_STREAMS_POLYFILL_PARTS + " inline constexpr char PonyfillPart${_streams_index}[] = R\"JSRHSTREAM(${_streams_part})JSRHSTREAM\";\n") + string(APPEND WEB_STREAMS_POLYFILL_PART_NAMES ", PonyfillPart${_streams_index}") + math(EXPR _streams_offset "${_streams_offset} + ${_streams_take}") +endwhile() configure_file( "Source/StreamsScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 126a23f7..6b145ef5 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -5,33 +5,36 @@ namespace Babylon::Polyfills::Internal::StreamsScripts { - inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( + // The vendored bundle is split by CMake into PonyfillPart1..N raw-string literals of at most + // 16,000 bytes each (MSVC C2026) and joined below. The prologue and epilogue wrap it as a + // CommonJS module so its exports can be read back. Nothing is inserted between parts: a + // separator could divide an identifier or string literal when the bundle is regenerated. + inline constexpr char PonyfillPrologue[] = R"JSRHSTREAM( (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; +)JSRHSTREAM"; - // Keep the split transparent: inserting whitespace here can divide an - // identifier or string literal when the vendored bundle is regenerated. - inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ +@WEB_STREAMS_POLYFILL_PARTS@ + inline constexpr char PonyfillEpilogue[] = R"JSRHSTREAM( return module.exports; })() )JSRHSTREAM"; - template - consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + template + consteval auto Join(const char (&... parts)[Sizes]) { - std::array result{}; - for (std::size_t index{}; index < Part1Size - 1; ++index) - { - result[index] = part1[index]; - } - for (std::size_t index{}; index < Part2Size; ++index) - { - result[Part1Size - 1 + index] = part2[index]; - } + std::array result{}; + std::size_t offset{}; + auto append = [&](const char* part, std::size_t size) { + for (std::size_t index{}; index + 1 < size; ++index) + { + result[offset++] = part[index]; + } + }; + (append(parts, Sizes), ...); return result; } - inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); + inline constexpr auto Ponyfill = Join(PonyfillPrologue@WEB_STREAMS_POLYFILL_PART_NAMES@, PonyfillEpilogue); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..844fa056 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -55,4 +55,5 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE Streams) \ No newline at end of file From d3d7592e252ed246a1fe61c9b5d2a29a8fe25a41 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:56:11 -0500 Subject: [PATCH 099/174] Streams: emit the embedded bundle as <=16 KB literals; link Streams into the Android test host MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535; the 71 KB bundle was emitted as two 60,000/11,188-byte raw strings, so every Windows and UWP job failed at "Build Solution". CMake now emits consecutive parts of at most 16,000 bytes, abutting with no separator (the split stays byte-transparent), and a variadic consteval Join reassembles them into the same std::array as before. The desktop UnitTests target links Streams for the Shared.cpp coverage but the Android UnitTestsJNI host did not, so the Android build failed on the include. --- Polyfills/Streams/CMakeLists.txt | 26 ++++++++++++- Polyfills/Streams/Source/StreamsScripts.h.in | 37 ++++++++++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 3 +- 3 files changed, 46 insertions(+), 20 deletions(-) diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt index 6c00ed81..6a756ccc 100644 --- a/Polyfills/Streams/CMakeLists.txt +++ b/Polyfills/Streams/CMakeLists.txt @@ -3,8 +3,30 @@ set(WEB_STREAMS_POLYFILL_FILE set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${WEB_STREAMS_POLYFILL_FILE}") file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +# MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535, so +# the bundle is emitted as consecutive raw-string parts of at most 16,000 bytes and joined back +# into one array at compile time. Parts abut with no separator so the split stays byte-transparent +# (a separator could land inside an identifier or string literal when the bundle is regenerated). +string(LENGTH "${WEB_STREAMS_POLYFILL_SOURCE}" _streams_length) +set(_streams_part_size 16000) +set(_streams_offset 0) +set(_streams_index 0) +set(WEB_STREAMS_POLYFILL_PARTS "") +set(WEB_STREAMS_POLYFILL_PART_NAMES "") +while(_streams_offset LESS _streams_length) + math(EXPR _streams_index "${_streams_index} + 1") + math(EXPR _streams_remaining "${_streams_length} - ${_streams_offset}") + if(_streams_remaining LESS _streams_part_size) + set(_streams_take ${_streams_remaining}) + else() + set(_streams_take ${_streams_part_size}) + endif() + string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" ${_streams_offset} ${_streams_take} _streams_part) + string(APPEND WEB_STREAMS_POLYFILL_PARTS + " inline constexpr char PonyfillPart${_streams_index}[] = R\"JSRHSTREAM(${_streams_part})JSRHSTREAM\";\n") + string(APPEND WEB_STREAMS_POLYFILL_PART_NAMES ", PonyfillPart${_streams_index}") + math(EXPR _streams_offset "${_streams_offset} + ${_streams_take}") +endwhile() configure_file( "Source/StreamsScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 126a23f7..6b145ef5 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -5,33 +5,36 @@ namespace Babylon::Polyfills::Internal::StreamsScripts { - inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( + // The vendored bundle is split by CMake into PonyfillPart1..N raw-string literals of at most + // 16,000 bytes each (MSVC C2026) and joined below. The prologue and epilogue wrap it as a + // CommonJS module so its exports can be read back. Nothing is inserted between parts: a + // separator could divide an identifier or string literal when the bundle is regenerated. + inline constexpr char PonyfillPrologue[] = R"JSRHSTREAM( (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; +)JSRHSTREAM"; - // Keep the split transparent: inserting whitespace here can divide an - // identifier or string literal when the vendored bundle is regenerated. - inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ +@WEB_STREAMS_POLYFILL_PARTS@ + inline constexpr char PonyfillEpilogue[] = R"JSRHSTREAM( return module.exports; })() )JSRHSTREAM"; - template - consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + template + consteval auto Join(const char (&... parts)[Sizes]) { - std::array result{}; - for (std::size_t index{}; index < Part1Size - 1; ++index) - { - result[index] = part1[index]; - } - for (std::size_t index{}; index < Part2Size; ++index) - { - result[Part1Size - 1 + index] = part2[index]; - } + std::array result{}; + std::size_t offset{}; + auto append = [&](const char* part, std::size_t size) { + for (std::size_t index{}; index + 1 < size; ++index) + { + result[offset++] = part[index]; + } + }; + (append(parts, Sizes), ...); return result; } - inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); + inline constexpr auto Ponyfill = Join(PonyfillPrologue@WEB_STREAMS_POLYFILL_PART_NAMES@, PonyfillEpilogue); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..844fa056 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -55,4 +55,5 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE Streams) \ No newline at end of file From 4709fac14de505b6cd24f5f7d2f50f785c1f56e9 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:56:11 -0500 Subject: [PATCH 100/174] Streams: emit the embedded bundle as <=16 KB literals; link Streams into the Android test host MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535; the 71 KB bundle was emitted as two 60,000/11,188-byte raw strings, so every Windows and UWP job failed at "Build Solution". CMake now emits consecutive parts of at most 16,000 bytes, abutting with no separator (the split stays byte-transparent), and a variadic consteval Join reassembles them into the same std::array as before. The desktop UnitTests target links Streams for the Shared.cpp coverage but the Android UnitTestsJNI host did not, so the Android build failed on the include. --- Polyfills/Streams/CMakeLists.txt | 26 ++++++++++++- Polyfills/Streams/Source/StreamsScripts.h.in | 37 ++++++++++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 3 +- 3 files changed, 46 insertions(+), 20 deletions(-) diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt index 6c00ed81..6a756ccc 100644 --- a/Polyfills/Streams/CMakeLists.txt +++ b/Polyfills/Streams/CMakeLists.txt @@ -3,8 +3,30 @@ set(WEB_STREAMS_POLYFILL_FILE set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${WEB_STREAMS_POLYFILL_FILE}") file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +# MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535, so +# the bundle is emitted as consecutive raw-string parts of at most 16,000 bytes and joined back +# into one array at compile time. Parts abut with no separator so the split stays byte-transparent +# (a separator could land inside an identifier or string literal when the bundle is regenerated). +string(LENGTH "${WEB_STREAMS_POLYFILL_SOURCE}" _streams_length) +set(_streams_part_size 16000) +set(_streams_offset 0) +set(_streams_index 0) +set(WEB_STREAMS_POLYFILL_PARTS "") +set(WEB_STREAMS_POLYFILL_PART_NAMES "") +while(_streams_offset LESS _streams_length) + math(EXPR _streams_index "${_streams_index} + 1") + math(EXPR _streams_remaining "${_streams_length} - ${_streams_offset}") + if(_streams_remaining LESS _streams_part_size) + set(_streams_take ${_streams_remaining}) + else() + set(_streams_take ${_streams_part_size}) + endif() + string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" ${_streams_offset} ${_streams_take} _streams_part) + string(APPEND WEB_STREAMS_POLYFILL_PARTS + " inline constexpr char PonyfillPart${_streams_index}[] = R\"JSRHSTREAM(${_streams_part})JSRHSTREAM\";\n") + string(APPEND WEB_STREAMS_POLYFILL_PART_NAMES ", PonyfillPart${_streams_index}") + math(EXPR _streams_offset "${_streams_offset} + ${_streams_take}") +endwhile() configure_file( "Source/StreamsScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 126a23f7..6b145ef5 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -5,33 +5,36 @@ namespace Babylon::Polyfills::Internal::StreamsScripts { - inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( + // The vendored bundle is split by CMake into PonyfillPart1..N raw-string literals of at most + // 16,000 bytes each (MSVC C2026) and joined below. The prologue and epilogue wrap it as a + // CommonJS module so its exports can be read back. Nothing is inserted between parts: a + // separator could divide an identifier or string literal when the bundle is regenerated. + inline constexpr char PonyfillPrologue[] = R"JSRHSTREAM( (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; +)JSRHSTREAM"; - // Keep the split transparent: inserting whitespace here can divide an - // identifier or string literal when the vendored bundle is regenerated. - inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ +@WEB_STREAMS_POLYFILL_PARTS@ + inline constexpr char PonyfillEpilogue[] = R"JSRHSTREAM( return module.exports; })() )JSRHSTREAM"; - template - consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + template + consteval auto Join(const char (&... parts)[Sizes]) { - std::array result{}; - for (std::size_t index{}; index < Part1Size - 1; ++index) - { - result[index] = part1[index]; - } - for (std::size_t index{}; index < Part2Size; ++index) - { - result[Part1Size - 1 + index] = part2[index]; - } + std::array result{}; + std::size_t offset{}; + auto append = [&](const char* part, std::size_t size) { + for (std::size_t index{}; index + 1 < size; ++index) + { + result[offset++] = part[index]; + } + }; + (append(parts, Sizes), ...); return result; } - inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); + inline constexpr auto Ponyfill = Join(PonyfillPrologue@WEB_STREAMS_POLYFILL_PART_NAMES@, PonyfillEpilogue); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..844fa056 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -55,4 +55,5 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE Streams) \ No newline at end of file From 242dccf09f3afbdcbc6b9a030bcc56165d921d3f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:56:11 -0500 Subject: [PATCH 101/174] Streams: emit the embedded bundle as <=16 KB literals; link Streams into the Android test host MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535; the 71 KB bundle was emitted as two 60,000/11,188-byte raw strings, so every Windows and UWP job failed at "Build Solution". CMake now emits consecutive parts of at most 16,000 bytes, abutting with no separator (the split stays byte-transparent), and a variadic consteval Join reassembles them into the same std::array as before. The desktop UnitTests target links Streams for the Shared.cpp coverage but the Android UnitTestsJNI host did not, so the Android build failed on the include. --- Polyfills/Streams/CMakeLists.txt | 26 ++++++++++++- Polyfills/Streams/Source/StreamsScripts.h.in | 37 ++++++++++--------- .../Android/app/src/main/cpp/CMakeLists.txt | 3 +- 3 files changed, 46 insertions(+), 20 deletions(-) diff --git a/Polyfills/Streams/CMakeLists.txt b/Polyfills/Streams/CMakeLists.txt index 6c00ed81..6a756ccc 100644 --- a/Polyfills/Streams/CMakeLists.txt +++ b/Polyfills/Streams/CMakeLists.txt @@ -3,8 +3,30 @@ set(WEB_STREAMS_POLYFILL_FILE set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${WEB_STREAMS_POLYFILL_FILE}") file(READ "${WEB_STREAMS_POLYFILL_FILE}" WEB_STREAMS_POLYFILL_SOURCE) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 0 60000 WEB_STREAMS_POLYFILL_SOURCE_1) -string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" 60000 -1 WEB_STREAMS_POLYFILL_SOURCE_2) +# MSVC caps a single string literal at 16,380 bytes (C2026) and a concatenated one at 65,535, so +# the bundle is emitted as consecutive raw-string parts of at most 16,000 bytes and joined back +# into one array at compile time. Parts abut with no separator so the split stays byte-transparent +# (a separator could land inside an identifier or string literal when the bundle is regenerated). +string(LENGTH "${WEB_STREAMS_POLYFILL_SOURCE}" _streams_length) +set(_streams_part_size 16000) +set(_streams_offset 0) +set(_streams_index 0) +set(WEB_STREAMS_POLYFILL_PARTS "") +set(WEB_STREAMS_POLYFILL_PART_NAMES "") +while(_streams_offset LESS _streams_length) + math(EXPR _streams_index "${_streams_index} + 1") + math(EXPR _streams_remaining "${_streams_length} - ${_streams_offset}") + if(_streams_remaining LESS _streams_part_size) + set(_streams_take ${_streams_remaining}) + else() + set(_streams_take ${_streams_part_size}) + endif() + string(SUBSTRING "${WEB_STREAMS_POLYFILL_SOURCE}" ${_streams_offset} ${_streams_take} _streams_part) + string(APPEND WEB_STREAMS_POLYFILL_PARTS + " inline constexpr char PonyfillPart${_streams_index}[] = R\"JSRHSTREAM(${_streams_part})JSRHSTREAM\";\n") + string(APPEND WEB_STREAMS_POLYFILL_PART_NAMES ", PonyfillPart${_streams_index}") + math(EXPR _streams_offset "${_streams_offset} + ${_streams_take}") +endwhile() configure_file( "Source/StreamsScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/StreamsScripts.h" diff --git a/Polyfills/Streams/Source/StreamsScripts.h.in b/Polyfills/Streams/Source/StreamsScripts.h.in index 126a23f7..6b145ef5 100644 --- a/Polyfills/Streams/Source/StreamsScripts.h.in +++ b/Polyfills/Streams/Source/StreamsScripts.h.in @@ -5,33 +5,36 @@ namespace Babylon::Polyfills::Internal::StreamsScripts { - inline constexpr char PonyfillPart1[] = R"JSRHSTREAM( + // The vendored bundle is split by CMake into PonyfillPart1..N raw-string literals of at most + // 16,000 bytes each (MSVC C2026) and joined below. The prologue and epilogue wrap it as a + // CommonJS module so its exports can be read back. Nothing is inserted between parts: a + // separator could divide an identifier or string literal when the bundle is regenerated. + inline constexpr char PonyfillPrologue[] = R"JSRHSTREAM( (function() { var exports = {}; var module = { exports: exports }; -@WEB_STREAMS_POLYFILL_SOURCE_1@)JSRHSTREAM"; +)JSRHSTREAM"; - // Keep the split transparent: inserting whitespace here can divide an - // identifier or string literal when the vendored bundle is regenerated. - inline constexpr char PonyfillPart2[] = R"JSRHSTREAM(@WEB_STREAMS_POLYFILL_SOURCE_2@ +@WEB_STREAMS_POLYFILL_PARTS@ + inline constexpr char PonyfillEpilogue[] = R"JSRHSTREAM( return module.exports; })() )JSRHSTREAM"; - template - consteval auto Join(const char (&part1)[Part1Size], const char (&part2)[Part2Size]) + template + consteval auto Join(const char (&... parts)[Sizes]) { - std::array result{}; - for (std::size_t index{}; index < Part1Size - 1; ++index) - { - result[index] = part1[index]; - } - for (std::size_t index{}; index < Part2Size; ++index) - { - result[Part1Size - 1 + index] = part2[index]; - } + std::array result{}; + std::size_t offset{}; + auto append = [&](const char* part, std::size_t size) { + for (std::size_t index{}; index + 1 < size; ++index) + { + result[offset++] = part[index]; + } + }; + (append(parts, Sizes), ...); return result; } - inline constexpr auto Ponyfill = Join(PonyfillPart1, PonyfillPart2); + inline constexpr auto Ponyfill = Join(PonyfillPrologue@WEB_STREAMS_POLYFILL_PART_NAMES@, PonyfillEpilogue); } diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..844fa056 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -55,4 +55,5 @@ target_link_libraries(UnitTestsJNI PRIVATE File PRIVATE TextDecoder PRIVATE TextEncoder - PRIVATE Performance) + PRIVATE Performance + PRIVATE Streams) \ No newline at end of file From 1d88a3e0ca09e9761e748b4efefede78ac35459f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 02:59:03 -0500 Subject: [PATCH 102/174] Tests/Android: link Compression into the test host for the Shared.cpp coverage --- Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 844fa056..78e2cafb 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -56,4 +56,5 @@ target_link_libraries(UnitTestsJNI PRIVATE TextDecoder PRIVATE TextEncoder PRIVATE Performance - PRIVATE Streams) \ No newline at end of file + PRIVATE Streams + PRIVATE Compression) \ No newline at end of file From 5d4affa43931fb33fdc17fa5ede552225fe8f6f9 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 103/174] Blob: cast the BYOB respond() length to double (MSVC C4244 as error) --- Polyfills/Blob/Source/Blob.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 635bb7e1..f0a30797 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -350,7 +350,7 @@ namespace Babylon::Polyfills::Internal const auto outputBuffer = view.ArrayBuffer(); auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); copyInto(destination, outputLength); - byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, static_cast(outputLength))}); } else { From df025b341c76fb687d07894954b1c44c4c043896 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 104/174] Blob: cast the BYOB respond() length to double (MSVC C4244 as error) --- Polyfills/Blob/Source/Blob.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 635bb7e1..f0a30797 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -350,7 +350,7 @@ namespace Babylon::Polyfills::Internal const auto outputBuffer = view.ArrayBuffer(); auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); copyInto(destination, outputLength); - byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, outputLength)}); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(callbackEnv, static_cast(outputLength))}); } else { From 317dbda77a63e326c927d36332925de7f1d9701f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 105/174] Fetch: emit the embedded polyfill as adjacent <=16 KB literals (MSVC C2026) --- Polyfills/Fetch/CMakeLists.txt | 18 ++++++++++++++++++ Polyfills/Fetch/Source/FetchScripts.h.in | 8 +++++--- 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/Polyfills/Fetch/CMakeLists.txt b/Polyfills/Fetch/CMakeLists.txt index 24346db0..0fa13e35 100644 --- a/Polyfills/Fetch/CMakeLists.txt +++ b/Polyfills/Fetch/CMakeLists.txt @@ -1,6 +1,24 @@ set(FETCH_POLYFILL_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Source/FetchPolyfill.js") set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${FETCH_POLYFILL_FILE}") file(READ "${FETCH_POLYFILL_FILE}" FETCH_POLYFILL_SOURCE) + +# MSVC caps a single string literal at 16,380 bytes (C2026), so the bundle is emitted as adjacent +# raw-string literals of at most 16,000 bytes, which the compiler concatenates back into one array. +# Parts abut with no separator so the split stays byte-transparent. +string(LENGTH "${FETCH_POLYFILL_SOURCE}" _fetch_length) +set(_fetch_offset 0) +set(FETCH_POLYFILL_LITERALS "") +while(_fetch_offset LESS _fetch_length) + math(EXPR _fetch_remaining "${_fetch_length} - ${_fetch_offset}") + if(_fetch_remaining LESS 16000) + set(_fetch_take ${_fetch_remaining}) + else() + set(_fetch_take 16000) + endif() + string(SUBSTRING "${FETCH_POLYFILL_SOURCE}" ${_fetch_offset} ${_fetch_take} _fetch_part) + string(APPEND FETCH_POLYFILL_LITERALS " R\"JSRHFETCH(${_fetch_part})JSRHFETCH\"\n") + math(EXPR _fetch_offset "${_fetch_offset} + ${_fetch_take}") +endwhile() configure_file( "Source/FetchScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/FetchScripts.h" diff --git a/Polyfills/Fetch/Source/FetchScripts.h.in b/Polyfills/Fetch/Source/FetchScripts.h.in index 8cc0e511..13defcf3 100644 --- a/Polyfills/Fetch/Source/FetchScripts.h.in +++ b/Polyfills/Fetch/Source/FetchScripts.h.in @@ -2,7 +2,9 @@ namespace Babylon::Polyfills::Internal::FetchScripts { - inline constexpr char Polyfill[] = R"JSRHFETCH( -@FETCH_POLYFILL_SOURCE@ -)JSRHFETCH"; + // CMake splits the bundle into adjacent raw-string literals of at most 16,000 bytes (MSVC C2026) + // and the compiler concatenates them back; nothing is inserted between parts. + inline constexpr char Polyfill[] = + "\n" +@FETCH_POLYFILL_LITERALS@ "\n"; } From 160557a2c004ebfb0a12a3695d77109de1659ff4 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 106/174] Fetch: emit the embedded polyfill as adjacent <=16 KB literals (MSVC C2026) --- Polyfills/Fetch/CMakeLists.txt | 18 ++++++++++++++++++ Polyfills/Fetch/Source/FetchScripts.h.in | 8 +++++--- 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/Polyfills/Fetch/CMakeLists.txt b/Polyfills/Fetch/CMakeLists.txt index 24346db0..0fa13e35 100644 --- a/Polyfills/Fetch/CMakeLists.txt +++ b/Polyfills/Fetch/CMakeLists.txt @@ -1,6 +1,24 @@ set(FETCH_POLYFILL_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Source/FetchPolyfill.js") set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${FETCH_POLYFILL_FILE}") file(READ "${FETCH_POLYFILL_FILE}" FETCH_POLYFILL_SOURCE) + +# MSVC caps a single string literal at 16,380 bytes (C2026), so the bundle is emitted as adjacent +# raw-string literals of at most 16,000 bytes, which the compiler concatenates back into one array. +# Parts abut with no separator so the split stays byte-transparent. +string(LENGTH "${FETCH_POLYFILL_SOURCE}" _fetch_length) +set(_fetch_offset 0) +set(FETCH_POLYFILL_LITERALS "") +while(_fetch_offset LESS _fetch_length) + math(EXPR _fetch_remaining "${_fetch_length} - ${_fetch_offset}") + if(_fetch_remaining LESS 16000) + set(_fetch_take ${_fetch_remaining}) + else() + set(_fetch_take 16000) + endif() + string(SUBSTRING "${FETCH_POLYFILL_SOURCE}" ${_fetch_offset} ${_fetch_take} _fetch_part) + string(APPEND FETCH_POLYFILL_LITERALS " R\"JSRHFETCH(${_fetch_part})JSRHFETCH\"\n") + math(EXPR _fetch_offset "${_fetch_offset} + ${_fetch_take}") +endwhile() configure_file( "Source/FetchScripts.h.in" "${CMAKE_CURRENT_BINARY_DIR}/Generated/FetchScripts.h" diff --git a/Polyfills/Fetch/Source/FetchScripts.h.in b/Polyfills/Fetch/Source/FetchScripts.h.in index 8cc0e511..13defcf3 100644 --- a/Polyfills/Fetch/Source/FetchScripts.h.in +++ b/Polyfills/Fetch/Source/FetchScripts.h.in @@ -2,7 +2,9 @@ namespace Babylon::Polyfills::Internal::FetchScripts { - inline constexpr char Polyfill[] = R"JSRHFETCH( -@FETCH_POLYFILL_SOURCE@ -)JSRHFETCH"; + // CMake splits the bundle into adjacent raw-string literals of at most 16,000 bytes (MSVC C2026) + // and the compiler concatenates them back; nothing is inserted between parts. + inline constexpr char Polyfill[] = + "\n" +@FETCH_POLYFILL_LITERALS@ "\n"; } From b8c4ab303aa7d492362201b0fbff15022c0d174c Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 107/174] Blob: cast the BYOB respond() length to double (MSVC C4244 as error) --- Polyfills/Blob/Source/Blob.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 22dd3cc2..04b60a13 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -135,7 +135,7 @@ namespace Babylon::Polyfills::Internal const auto outputBuffer = view.ArrayBuffer(); auto destination = static_cast(outputBuffer.Data()) + view.ByteOffset(); copyInto(destination, outputLength); - byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(env, outputLength)}); + byobRequest.Get("respond").As().Call(byobRequest, {Napi::Number::New(env, static_cast(outputLength))}); } else { From b39786229093817df451efe1aac4138bd42af8bf Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 05:14:45 -0500 Subject: [PATCH 108/174] Compression: throw through the Napi wrapper and link zlib by name The JSI backend implements no C napi_* entry points, so the raw napi_throw_type_error failed to compile there (C3861). Napi::TypeError::ThrowAsJavaScriptException sets the pending exception without throwing C++, preserving the reentrancy rationale, and exists on every backend. On Apple, find_library(z) captured the device SDK's libz.tbd at configure time; the simulator link rejected it ("missing required architecture x86_64"). Linking "z" by name lets the linker resolve it against the active SDK. --- Polyfills/Compression/CMakeLists.txt | 8 +++++--- Polyfills/Compression/Source/Compression.cpp | 10 ++++++---- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/Polyfills/Compression/CMakeLists.txt b/Polyfills/Compression/CMakeLists.txt index d049f155..381c8a50 100644 --- a/Polyfills/Compression/CMakeLists.txt +++ b/Polyfills/Compression/CMakeLists.txt @@ -1,9 +1,11 @@ if(APPLE) # FindZLIB exposes the SDK's usr/include as an explicit system include on # recent Xcode versions. That breaks libc++'s include_next ordering. The - # header and library are both SDK-provided, so only add the link library. - find_library(JSRUNTIMEHOST_COMPRESSION_ZLIB_LIBRARY NAMES z REQUIRED) - set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET "${JSRUNTIMEHOST_COMPRESSION_ZLIB_LIBRARY}") + # header and library are both SDK-provided, so only add the link library -- + # by name, not via find_library: a configure-time path points into the + # device SDK, which the simulator link then rejects (libz.tbd "missing + # required architecture"). "-lz" resolves against whichever SDK is active. + set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET z) elseif(TARGET ZLIB::ZLIB) set(JSRUNTIMEHOST_COMPRESSION_ZLIB_TARGET ZLIB::ZLIB) elseif(TARGET zlibstatic) diff --git a/Polyfills/Compression/Source/Compression.cpp b/Polyfills/Compression/Source/Compression.cpp index aab2ab10..7eefbff9 100644 --- a/Polyfills/Compression/Source/Compression.cpp +++ b/Polyfills/Compression/Source/Compression.cpp @@ -309,10 +309,12 @@ namespace Babylon::Polyfills::Internal m_closed = true; ReleasePendingStorage(); // This error is reported after EnqueuePending has called - // back into JavaScript. Setting the pending exception - // directly avoids a second C++ exception conversion in - // Node-API backends with reentrant callback contexts. - static_cast(napi_throw_type_error(env, nullptr, failure.c_str())); + // back into JavaScript. ThrowAsJavaScriptException only sets + // the pending exception (it never throws C++), which avoids a + // second C++ exception conversion in Node-API backends with + // reentrant callback contexts -- and unlike the raw C API it + // also exists on the JSI backend, which implements no napi_*. + Napi::TypeError::New(Napi::Env{env}, failure).ThrowAsJavaScriptException(); return false; } From c52e3eeeb8c64611d9dcf941511121e78dd846e8 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:19:02 -0500 Subject: [PATCH 109/174] Blob: read DataView parts through JS properties (JSI's Napi::DataView stub breaks the UWP build) --- Polyfills/Blob/Source/Blob.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index f0a30797..0d2b91a5 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -401,11 +401,15 @@ namespace Babylon::Polyfills::Internal } else if (blobPart.IsDataView()) { - const auto view = blobPart.As(); - const auto buffer = view.ArrayBuffer(); + // Read the view through its JS properties rather than Napi::DataView: the JSI + // backend's DataView wrapper is an unimplemented stub, and merely instantiating it + // fails the UWP build (its `throw "TODO"` leaves unreachable code, C4702 as error). + const auto view = blobPart.As(); + const auto buffer = view.Get("buffer").As(); const auto bufferData = static_cast(buffer.Data()); - source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); - length = view.ByteLength(); + const auto byteOffset = static_cast(view.Get("byteOffset").As().Int64Value()); + source = bufferData == nullptr ? nullptr : bufferData + byteOffset; + length = static_cast(view.Get("byteLength").As().Int64Value()); isBufferSource = true; } else if (blobPart.IsObject()) From ec9bacbe5b89bf7f3bb4d0c2aa97770d628600b8 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:19:02 -0500 Subject: [PATCH 110/174] Blob: read DataView parts through JS properties (JSI's Napi::DataView stub breaks the UWP build) --- Polyfills/Blob/Source/Blob.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index f0a30797..0d2b91a5 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -401,11 +401,15 @@ namespace Babylon::Polyfills::Internal } else if (blobPart.IsDataView()) { - const auto view = blobPart.As(); - const auto buffer = view.ArrayBuffer(); + // Read the view through its JS properties rather than Napi::DataView: the JSI + // backend's DataView wrapper is an unimplemented stub, and merely instantiating it + // fails the UWP build (its `throw "TODO"` leaves unreachable code, C4702 as error). + const auto view = blobPart.As(); + const auto buffer = view.Get("buffer").As(); const auto bufferData = static_cast(buffer.Data()); - source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); - length = view.ByteLength(); + const auto byteOffset = static_cast(view.Get("byteOffset").As().Int64Value()); + source = bufferData == nullptr ? nullptr : bufferData + byteOffset; + length = static_cast(view.Get("byteLength").As().Int64Value()); isBufferSource = true; } else if (blobPart.IsObject()) From c4a7a636378598eb0ba6d753156003acee808f4b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:19:02 -0500 Subject: [PATCH 111/174] CI: suppress WebKitGTK-internal LeakSanitizer reports on the Linux sanitizer job The ASan/UBSan job failed on a 24-byte "direct leak" allocated inside libjavascriptcoregtk (WTF::BitVector::resizeOutOfLine under JSObjectMake -> JSObject::setPrototypeDirect), reached from napi reference creation. It is JavaScriptCore's own global bookkeeping, never freed at exit, and surfaces for whichever caller happens to trigger the growth -- the Blob stream work already documented the same artifact. Mirrors the existing tsan_suppressions.txt wiring. --- .github/lsan_suppressions.txt | 7 +++++++ .github/workflows/build-linux.yml | 1 + 2 files changed, 8 insertions(+) create mode 100644 .github/lsan_suppressions.txt diff --git a/.github/lsan_suppressions.txt b/.github/lsan_suppressions.txt new file mode 100644 index 00000000..e6074781 --- /dev/null +++ b/.github/lsan_suppressions.txt @@ -0,0 +1,7 @@ +# LeakSanitizer suppressions for the Linux sanitizer job. +# +# WebKitGTK's JavaScriptCore grows global bookkeeping (e.g. WTF::BitVector under +# JSObjectMake -> JSObject::setPrototypeDirect on a Structure transition) that it never +# frees at exit, and LSan reports it as a direct leak attributed to whichever caller +# happened to trigger the growth -- here napi reference creation. Not our allocation. +leak:libjavascriptcoregtk diff --git a/.github/workflows/build-linux.yml b/.github/workflows/build-linux.yml index 3357bf59..aed45f76 100644 --- a/.github/workflows/build-linux.yml +++ b/.github/workflows/build-linux.yml @@ -57,6 +57,7 @@ jobs: run: ./UnitTests env: TSAN_OPTIONS: ${{ inputs.enable-thread-sanitizer && format('suppressions={0}/.github/tsan_suppressions.txt', github.workspace) || '' }} + LSAN_OPTIONS: ${{ inputs.enable-sanitizers && format('suppressions={0}/.github/lsan_suppressions.txt', github.workspace) || '' }} # JSC's concurrent GC on Linux uses SIGUSR1 + sem_wait to suspend mutator # threads at safepoints. TSan's signal interception delays SIGUSR1 delivery # indefinitely, deadlocking the Collector Thread's sem_wait. Disabling the From f898cec4b831476bf4a39ec23b9e988b607acbdf Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:19:02 -0500 Subject: [PATCH 112/174] Blob: read DataView parts through JS properties (JSI's Napi::DataView stub breaks the UWP build) --- Polyfills/Blob/Source/Blob.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 04b60a13..ff816ffb 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -444,11 +444,15 @@ namespace Babylon::Polyfills::Internal } else if (blobPart.IsDataView()) { - const auto view = blobPart.As(); - const auto buffer = view.ArrayBuffer(); + // Read the view through its JS properties rather than Napi::DataView: the JSI + // backend's DataView wrapper is an unimplemented stub, and merely instantiating it + // fails the UWP build (its `throw "TODO"` leaves unreachable code, C4702 as error). + const auto view = blobPart.As(); + const auto buffer = view.Get("buffer").As(); const auto bufferData = static_cast(buffer.Data()); - source = bufferData == nullptr ? nullptr : bufferData + view.ByteOffset(); - length = view.ByteLength(); + const auto byteOffset = static_cast(view.Get("byteOffset").As().Int64Value()); + source = bufferData == nullptr ? nullptr : bufferData + byteOffset; + length = static_cast(view.Get("byteLength").As().Int64Value()); isBufferSource = true; } else if (blobPart.IsObject()) From 8163ab885a56b25e40943e8756ca0e65f71bf92f Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:19:03 -0500 Subject: [PATCH 113/174] CI: suppress WebKitGTK-internal LeakSanitizer reports on the Linux sanitizer job The ASan/UBSan job failed on a 24-byte "direct leak" allocated inside libjavascriptcoregtk (WTF::BitVector::resizeOutOfLine under JSObjectMake -> JSObject::setPrototypeDirect), reached from napi reference creation. It is JavaScriptCore's own global bookkeeping, never freed at exit, and surfaces for whichever caller happens to trigger the growth -- the Blob stream work already documented the same artifact. Mirrors the existing tsan_suppressions.txt wiring. --- .github/lsan_suppressions.txt | 7 +++++++ .github/workflows/build-linux.yml | 1 + 2 files changed, 8 insertions(+) create mode 100644 .github/lsan_suppressions.txt diff --git a/.github/lsan_suppressions.txt b/.github/lsan_suppressions.txt new file mode 100644 index 00000000..e6074781 --- /dev/null +++ b/.github/lsan_suppressions.txt @@ -0,0 +1,7 @@ +# LeakSanitizer suppressions for the Linux sanitizer job. +# +# WebKitGTK's JavaScriptCore grows global bookkeeping (e.g. WTF::BitVector under +# JSObjectMake -> JSObject::setPrototypeDirect on a Structure transition) that it never +# frees at exit, and LSan reports it as a direct leak attributed to whichever caller +# happened to trigger the growth -- here napi reference creation. Not our allocation. +leak:libjavascriptcoregtk diff --git a/.github/workflows/build-linux.yml b/.github/workflows/build-linux.yml index 3357bf59..aed45f76 100644 --- a/.github/workflows/build-linux.yml +++ b/.github/workflows/build-linux.yml @@ -57,6 +57,7 @@ jobs: run: ./UnitTests env: TSAN_OPTIONS: ${{ inputs.enable-thread-sanitizer && format('suppressions={0}/.github/tsan_suppressions.txt', github.workspace) || '' }} + LSAN_OPTIONS: ${{ inputs.enable-sanitizers && format('suppressions={0}/.github/lsan_suppressions.txt', github.workspace) || '' }} # JSC's concurrent GC on Linux uses SIGUSR1 + sem_wait to suspend mutator # threads at safepoints. TSan's signal interception delays SIGUSR1 delivery # indefinitely, deadlocking the Collector Thread's sem_wait. Disabling the From d667e488c2bd7ba95c012129e7663d08dea9d695 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:42:47 -0500 Subject: [PATCH 114/174] Tests: give the heavy Blob/Response stream tests a 60 s budget (timed out on iOS simulator / Hermes) --- Tests/UnitTests/Scripts/tests.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index aab3b8c7..39b1e8c5 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -560,6 +560,9 @@ describe("Response", function () { // Adapted from WebKit's imported many-empty-chunks-crash.html. it("consumes many empty chunks without retaining growing byte buffers", async function () { + // 40k-chunk / nested-part workloads run through the Streams polyfill's per-chunk promise + // machinery; on the iOS simulator and Hermes that straddles mocha's default budget. + this.timeout(60000); const response = new Response(new ReadableStream({ start(controller) { for (let index = 0; index < 40000; ++index) { @@ -2396,6 +2399,9 @@ describe("Blob", function () { // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + // 40k-chunk / nested-part workloads run through the Streams polyfill's per-chunk promise + // machinery; on the iOS simulator and Hermes that straddles mocha's default budget. + this.timeout(60000); const pattern = new Uint8Array(256 * 1024); for (let index = 0; index < pattern.length; ++index) { pattern[index] = index % 256; From bcf20e6e65824d382e5b30e66c9ee2c694047b78 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:42:47 -0500 Subject: [PATCH 115/174] Tests: give the heavy Blob/Response stream tests a 60 s budget (timed out on iOS simulator / Hermes) --- Tests/UnitTests/Scripts/tests.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index ffab392b..32ef4ff9 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -560,6 +560,9 @@ describe("Response", function () { // Adapted from WebKit's imported many-empty-chunks-crash.html. it("consumes many empty chunks without retaining growing byte buffers", async function () { + // 40k-chunk / nested-part workloads run through the Streams polyfill's per-chunk promise + // machinery; on the iOS simulator and Hermes that straddles mocha's default budget. + this.timeout(60000); const response = new Response(new ReadableStream({ start(controller) { for (let index = 0; index < 40000; ++index) { @@ -2331,6 +2334,9 @@ describe("Blob", function () { // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + // 40k-chunk / nested-part workloads run through the Streams polyfill's per-chunk promise + // machinery; on the iOS simulator and Hermes that straddles mocha's default budget. + this.timeout(60000); const pattern = new Uint8Array(256 * 1024); for (let index = 0; index < pattern.length; ++index) { pattern[index] = index % 256; From 10994509e0f9f2efec6def9ee22062d3fc838e96 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 07:42:47 -0500 Subject: [PATCH 116/174] Tests: give the heavy Blob/Response stream tests a 60 s budget (timed out on iOS simulator / Hermes) --- Tests/UnitTests/Scripts/tests.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 458bd4ea..995d0cb3 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -2021,6 +2021,9 @@ describe("Blob", function () { // Scaled port of Firefox's dom/streams/test/xpcshell/large-pipeto.js. it("pipes nested shared Blob parts without corrupting chunk boundaries", async function () { + // 40k-chunk / nested-part workloads run through the Streams polyfill's per-chunk promise + // machinery; on the iOS simulator and Hermes that straddles mocha's default budget. + this.timeout(60000); const pattern = new Uint8Array(256 * 1024); for (let index = 0; index < pattern.length; ++index) { pattern[index] = index % 256; From bb817d011a69a176752eb8637ff969a0ed579c11 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 13:35:06 -0500 Subject: [PATCH 117/174] QuickJS: bound the JS stack to the thread's real stack; Chakra: define globalThis QuickJS guards JS recursion against stack_top - JS_DEFAULT_STACK_SIZE, which is 1 MiB in quickjs-ng -- also the default size of a non-main thread on Android and Windows. On those threads the check sits below the guard page, so deep recursion faults before QuickJS can raise "InternalError: stack overflow": Android_QuickJS died with SIGSEGV (one frame repeated 150+ deep) in the Fetch polyfill's 40k-chunk Response test, while the 8 MiB-stacked desktop QuickJS jobs were fine. Derive the limit from the running thread (pthread_getattr_np / GetCurrentThreadStackLimits) minus a margin for native frames. The Windows 10 Chakra predates ES2020 and has no `globalThis`; every Fetch test failed there with "ReferenceError: 'globalThis' is not defined". Define it on the global object at env attach, as a plain writable configurable property. --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 55 +++++++++++++++++++ Core/Node-API/Source/env_chakra.cc | 13 +++++ 2 files changed, 68 insertions(+) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 10505fea..d9ab764c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -18,8 +18,62 @@ #pragma warning(pop) #endif +#if !defined(_WIN32) +#include +#endif +#if defined(_WIN32) +#include +#endif + +#include +#include +#include + namespace Babylon { + namespace + { + // QuickJS guards against JS recursion by comparing the C stack pointer against + // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in + // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, + // so on those threads the limit sits below the real guard page: deep recursion faults + // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit + // from the thread that actually runs the runtime instead, keeping a margin for the native + // frames QuickJS and the host add between the check and the guard page. + size_t JavaScriptStackLimit() + { + constexpr size_t Margin{256 * 1024}; + constexpr size_t Fallback{512 * 1024}; + size_t threadStack{}; +#if defined(_WIN32) + ULONG_PTR low{}; + ULONG_PTR high{}; + GetCurrentThreadStackLimits(&low, &high); + threadStack = static_cast(high - low); +#elif defined(__APPLE__) + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. + threadStack = pthread_get_stacksize_np(pthread_self()); +#else + pthread_attr_t attributes; + if (pthread_getattr_np(pthread_self(), &attributes) == 0) + { + void* base{}; + size_t size{}; + if (pthread_attr_getstack(&attributes, &base, &size) == 0) + { + threadStack = size; + } + pthread_attr_destroy(&attributes); + } +#endif + if (threadStack <= Margin) + { + return Fallback; + } + return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + } + } + void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { // Create the runtime. @@ -28,6 +82,7 @@ namespace Babylon { throw std::runtime_error{"Failed to create QuickJS runtime"}; } + JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); // Create the context. JSContext* context = JS_NewContext(runtime); diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 0c0be91c..641467df 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -23,6 +23,19 @@ namespace Napi JsValueRef global; ThrowIfFailed(JsGetGlobalObject(&global)); JsPropertyIdRef propertyId; + + // The Windows 10 Chakra predates ES2020 and has no `globalThis`; scripts written against + // browsers (and the polyfills in this repo) reference it. Define it as a plain, writable, + // configurable property of the global object, exactly as the spec describes. + ThrowIfFailed(JsGetPropertyIdFromName(L"globalThis", &propertyId)); + JsValueRef existingGlobalThis; + ThrowIfFailed(JsGetProperty(global, propertyId, &existingGlobalThis)); + JsValueType existingType; + ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); + if (existingType == JsUndefined) + { + ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; ThrowIfFailed(JsGetProperty(global, propertyId, &object)); From 30eebd219b1466c980c022e8245c26e37c4e53c6 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 13:35:06 -0500 Subject: [PATCH 118/174] QuickJS: bound the JS stack to the thread's real stack; Chakra: define globalThis QuickJS guards JS recursion against stack_top - JS_DEFAULT_STACK_SIZE, which is 1 MiB in quickjs-ng -- also the default size of a non-main thread on Android and Windows. On those threads the check sits below the guard page, so deep recursion faults before QuickJS can raise "InternalError: stack overflow": Android_QuickJS died with SIGSEGV (one frame repeated 150+ deep) in the Fetch polyfill's 40k-chunk Response test, while the 8 MiB-stacked desktop QuickJS jobs were fine. Derive the limit from the running thread (pthread_getattr_np / GetCurrentThreadStackLimits) minus a margin for native frames. The Windows 10 Chakra predates ES2020 and has no `globalThis`; every Fetch test failed there with "ReferenceError: 'globalThis' is not defined". Define it on the global object at env attach, as a plain writable configurable property. --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 55 +++++++++++++++++++ Core/Node-API/Source/env_chakra.cc | 13 +++++ 2 files changed, 68 insertions(+) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 10505fea..d9ab764c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -18,8 +18,62 @@ #pragma warning(pop) #endif +#if !defined(_WIN32) +#include +#endif +#if defined(_WIN32) +#include +#endif + +#include +#include +#include + namespace Babylon { + namespace + { + // QuickJS guards against JS recursion by comparing the C stack pointer against + // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in + // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, + // so on those threads the limit sits below the real guard page: deep recursion faults + // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit + // from the thread that actually runs the runtime instead, keeping a margin for the native + // frames QuickJS and the host add between the check and the guard page. + size_t JavaScriptStackLimit() + { + constexpr size_t Margin{256 * 1024}; + constexpr size_t Fallback{512 * 1024}; + size_t threadStack{}; +#if defined(_WIN32) + ULONG_PTR low{}; + ULONG_PTR high{}; + GetCurrentThreadStackLimits(&low, &high); + threadStack = static_cast(high - low); +#elif defined(__APPLE__) + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. + threadStack = pthread_get_stacksize_np(pthread_self()); +#else + pthread_attr_t attributes; + if (pthread_getattr_np(pthread_self(), &attributes) == 0) + { + void* base{}; + size_t size{}; + if (pthread_attr_getstack(&attributes, &base, &size) == 0) + { + threadStack = size; + } + pthread_attr_destroy(&attributes); + } +#endif + if (threadStack <= Margin) + { + return Fallback; + } + return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + } + } + void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { // Create the runtime. @@ -28,6 +82,7 @@ namespace Babylon { throw std::runtime_error{"Failed to create QuickJS runtime"}; } + JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); // Create the context. JSContext* context = JS_NewContext(runtime); diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 0c0be91c..641467df 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -23,6 +23,19 @@ namespace Napi JsValueRef global; ThrowIfFailed(JsGetGlobalObject(&global)); JsPropertyIdRef propertyId; + + // The Windows 10 Chakra predates ES2020 and has no `globalThis`; scripts written against + // browsers (and the polyfills in this repo) reference it. Define it as a plain, writable, + // configurable property of the global object, exactly as the spec describes. + ThrowIfFailed(JsGetPropertyIdFromName(L"globalThis", &propertyId)); + JsValueRef existingGlobalThis; + ThrowIfFailed(JsGetProperty(global, propertyId, &existingGlobalThis)); + JsValueType existingType; + ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); + if (existingType == JsUndefined) + { + ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; ThrowIfFailed(JsGetProperty(global, propertyId, &object)); From 810a092cd3330639958d8f0718d6e05409656244 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 13:35:06 -0500 Subject: [PATCH 119/174] QuickJS: bound the JS stack to the thread's real stack; Chakra: define globalThis QuickJS guards JS recursion against stack_top - JS_DEFAULT_STACK_SIZE, which is 1 MiB in quickjs-ng -- also the default size of a non-main thread on Android and Windows. On those threads the check sits below the guard page, so deep recursion faults before QuickJS can raise "InternalError: stack overflow": Android_QuickJS died with SIGSEGV (one frame repeated 150+ deep) in the Fetch polyfill's 40k-chunk Response test, while the 8 MiB-stacked desktop QuickJS jobs were fine. Derive the limit from the running thread (pthread_getattr_np / GetCurrentThreadStackLimits) minus a margin for native frames. The Windows 10 Chakra predates ES2020 and has no `globalThis`; every Fetch test failed there with "ReferenceError: 'globalThis' is not defined". Define it on the global object at env attach, as a plain writable configurable property. --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 55 +++++++++++++++++++ Core/Node-API/Source/env_chakra.cc | 13 +++++ 2 files changed, 68 insertions(+) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 10505fea..d9ab764c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -18,8 +18,62 @@ #pragma warning(pop) #endif +#if !defined(_WIN32) +#include +#endif +#if defined(_WIN32) +#include +#endif + +#include +#include +#include + namespace Babylon { + namespace + { + // QuickJS guards against JS recursion by comparing the C stack pointer against + // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in + // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, + // so on those threads the limit sits below the real guard page: deep recursion faults + // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit + // from the thread that actually runs the runtime instead, keeping a margin for the native + // frames QuickJS and the host add between the check and the guard page. + size_t JavaScriptStackLimit() + { + constexpr size_t Margin{256 * 1024}; + constexpr size_t Fallback{512 * 1024}; + size_t threadStack{}; +#if defined(_WIN32) + ULONG_PTR low{}; + ULONG_PTR high{}; + GetCurrentThreadStackLimits(&low, &high); + threadStack = static_cast(high - low); +#elif defined(__APPLE__) + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. + threadStack = pthread_get_stacksize_np(pthread_self()); +#else + pthread_attr_t attributes; + if (pthread_getattr_np(pthread_self(), &attributes) == 0) + { + void* base{}; + size_t size{}; + if (pthread_attr_getstack(&attributes, &base, &size) == 0) + { + threadStack = size; + } + pthread_attr_destroy(&attributes); + } +#endif + if (threadStack <= Margin) + { + return Fallback; + } + return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + } + } + void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { // Create the runtime. @@ -28,6 +82,7 @@ namespace Babylon { throw std::runtime_error{"Failed to create QuickJS runtime"}; } + JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); // Create the context. JSContext* context = JS_NewContext(runtime); diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 0c0be91c..641467df 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -23,6 +23,19 @@ namespace Napi JsValueRef global; ThrowIfFailed(JsGetGlobalObject(&global)); JsPropertyIdRef propertyId; + + // The Windows 10 Chakra predates ES2020 and has no `globalThis`; scripts written against + // browsers (and the polyfills in this repo) reference it. Define it as a plain, writable, + // configurable property of the global object, exactly as the spec describes. + ThrowIfFailed(JsGetPropertyIdFromName(L"globalThis", &propertyId)); + JsValueRef existingGlobalThis; + ThrowIfFailed(JsGetProperty(global, propertyId, &existingGlobalThis)); + JsValueType existingType; + ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); + if (existingType == JsUndefined) + { + ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; ThrowIfFailed(JsGetProperty(global, propertyId, &object)); From fef8cb97602e2d214d680aeedf9be29babbb376e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:01:49 -0500 Subject: [PATCH 120/174] Address review: define _GNU_SOURCE before system headers, bound the fallback stack limit by the thread's own size, define globalThis non-enumerable via JsDefineProperty --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 15 +++++++++++--- Core/Node-API/Source/env_chakra.cc | 20 ++++++++++++++++++- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index d9ab764c..b1828b7f 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,3 +1,8 @@ +// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, +// but this translation unit should not depend on the language dialect for a system declaration. +#if defined(__linux__) && !defined(_GNU_SOURCE) +#define _GNU_SOURCE +#endif #include "AppRuntime.h" #include @@ -43,7 +48,7 @@ namespace Babylon size_t JavaScriptStackLimit() { constexpr size_t Margin{256 * 1024}; - constexpr size_t Fallback{512 * 1024}; + constexpr size_t Fallback{256 * 1024}; size_t threadStack{}; #if defined(_WIN32) ULONG_PTR low{}; @@ -66,9 +71,13 @@ namespace Babylon pthread_attr_destroy(&attributes); } #endif - if (threadStack <= Margin) + if (threadStack == 0) + { + return Fallback; // unknown: conservative, well under any plausible thread + } + if (threadStack <= 2 * Margin) { - return Fallback; + return threadStack / 2; // a known small stack must not get a limit larger than itself } return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 641467df..1351525e 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -34,7 +34,25 @@ namespace Napi ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); if (existingType == JsUndefined) { - ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + // { value: globalThis, writable: true, enumerable: false, configurable: true } -- the + // spec's own data property; plain assignment would make it enumerable. + JsValueRef descriptor; + ThrowIfFailed(JsCreateObject(&descriptor)); + JsValueRef trueValue; + ThrowIfFailed(JsGetTrueValue(&trueValue)); + JsValueRef falseValue; + ThrowIfFailed(JsGetFalseValue(&falseValue)); + JsPropertyIdRef descriptorPropertyId; + ThrowIfFailed(JsGetPropertyIdFromName(L"value", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, global, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"writable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"enumerable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, falseValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"configurable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + bool defined; + ThrowIfFailed(JsDefineProperty(global, propertyId, descriptor, &defined)); } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; From 5cd790d5f628e1eb13057a1006260e91dc8a3dfb Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:09:10 -0500 Subject: [PATCH 121/174] QuickJS: keep from defining min/max (Win32 QuickJS build) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b1828b7f..621f6310 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -27,6 +27,9 @@ #include #endif #if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX // would otherwise define min/max macros that break std::min below +#endif #include #endif @@ -79,7 +82,7 @@ namespace Babylon { return threadStack / 2; // a known small stack must not get a limit larger than itself } - return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From d1ca32e239b60f5b71e20e0656f673c10fa711ba Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:11:56 -0500 Subject: [PATCH 122/174] QuickJS: measure the JS stack budget from the current stack pointer to the thread's base (the nominal size under-budgeted the Android runtime thread: depth-128 recursion hit the limit) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 32 ++++++++++++------- 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 621f6310..b2757f0c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -48,41 +48,49 @@ namespace Babylon // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit // from the thread that actually runs the runtime instead, keeping a margin for the native // frames QuickJS and the host add between the check and the guard page. + // Bytes of C stack below the current frame, measured from the actual stack pointer to the + // thread's stack base, minus a margin for the native frames QuickJS and the host add between + // the check and the guard page. Measuring from the current position (rather than trusting + // the nominal size) also absorbs whatever the host already consumed above this call. size_t JavaScriptStackLimit() { - constexpr size_t Margin{256 * 1024}; + constexpr size_t Margin{96 * 1024}; constexpr size_t Fallback{256 * 1024}; - size_t threadStack{}; + volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) + const auto here = reinterpret_cast(&marker); + uintptr_t base{}; #if defined(_WIN32) ULONG_PTR low{}; ULONG_PTR high{}; GetCurrentThreadStackLimits(&low, &high); - threadStack = static_cast(high - low); + base = static_cast(low); #elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. - threadStack = pthread_get_stacksize_np(pthread_self()); + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. + const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); + base = top - pthread_get_stacksize_np(pthread_self()); #else pthread_attr_t attributes; if (pthread_getattr_np(pthread_self(), &attributes) == 0) { - void* base{}; + void* address{}; size_t size{}; - if (pthread_attr_getstack(&attributes, &base, &size) == 0) + if (pthread_attr_getstack(&attributes, &address, &size) == 0) { - threadStack = size; + base = reinterpret_cast(address); } pthread_attr_destroy(&attributes); } #endif - if (threadStack == 0) + if (base == 0 || here <= base) { return Fallback; // unknown: conservative, well under any plausible thread } - if (threadStack <= 2 * Margin) + const size_t usable = here - base; + if (usable <= 2 * Margin) { - return threadStack / 2; // a known small stack must not get a limit larger than itself + return usable / 2; // a known small stack must not get a limit larger than itself } - return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From f30a41c6303d7ff3fc6d51590a8e10152b00da93 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 13:57:14 -0500 Subject: [PATCH 123/174] Resolve data: URLs for every UrlLib consumer via a registered scheme resolver #212 decoded data: URLs inside the fetch polyfill only, so XMLHttpRequest -- the path Babylon.js' asset and texture loaders take -- and every other UrlLib consumer still treated them as network failures (#67). The WHATWG data: URL processor is lifted out of Fetch.cpp into Polyfills/URL (a URLInternal seam, like BlobInternal) and registered with UrlLib::UrlRequest::RegisterSchemeResolver("data", ...) next to blob:, exactly the shape #207 established. A malformed data: URL is a network error per spec, which UrlLib expresses as `handled == false`. fetch keeps its synchronous fast path on the shared decoder. Tests cover XMLHttpRequest text / base64 arraybuffer / malformed, a data: -> Blob -> object URL round trip, and a base64 gzip data: URL piped through DecompressionStream (skipped where the compression polyfill is not present). --- Polyfills/Fetch/CMakeLists.txt | 3 +- Polyfills/Fetch/Source/Fetch.cpp | 194 +---------------- Polyfills/URL/CMakeLists.txt | 9 + .../Babylon/Polyfills/DataUrl.h | 25 +++ Polyfills/URL/Source/DataUrl.cpp | 206 ++++++++++++++++++ Polyfills/URL/Source/URL.cpp | 39 ++++ Tests/UnitTests/Scripts/tests.ts | 60 +++++ 7 files changed, 344 insertions(+), 192 deletions(-) create mode 100644 Polyfills/URL/InternalInclude/Babylon/Polyfills/DataUrl.h create mode 100644 Polyfills/URL/Source/DataUrl.cpp diff --git a/Polyfills/Fetch/CMakeLists.txt b/Polyfills/Fetch/CMakeLists.txt index 0fa13e35..79d9fd8c 100644 --- a/Polyfills/Fetch/CMakeLists.txt +++ b/Polyfills/Fetch/CMakeLists.txt @@ -42,7 +42,8 @@ target_include_directories(Fetch target_link_libraries(Fetch PUBLIC JsRuntime PRIVATE arcana - PRIVATE UrlLib) + PRIVATE UrlLib + PRIVATE URLInternal) set_property(TARGET Fetch PROPERTY FOLDER Polyfills) source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Fetch/Source/Fetch.cpp b/Polyfills/Fetch/Source/Fetch.cpp index a7dd3bd2..f89215be 100644 --- a/Polyfills/Fetch/Source/Fetch.cpp +++ b/Polyfills/Fetch/Source/Fetch.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include @@ -20,6 +21,7 @@ namespace Babylon::Polyfills::Internal { + using DataUrlResponse = Babylon::Polyfills::DataUrl::Response; namespace { // Shared state for honoring an AbortSignal passed via init.signal. Co-owned by the "abort" @@ -55,196 +57,6 @@ namespace Babylon::Polyfills::Internal }); } - struct DataUrlResponse - { - std::string contentType; - std::string url; - std::vector body; - }; - - bool IsAsciiWhitespace(uint8_t value) - { - return value == 0x09 || value == 0x0A || value == 0x0C || value == 0x0D || value == 0x20; - } - - void TrimAsciiWhitespace(std::string& value) - { - const auto first = std::find_if_not(value.begin(), value.end(), [](unsigned char character) { - return IsAsciiWhitespace(character); - }); - const auto last = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char character) { - return IsAsciiWhitespace(character); - }).base(); - value = first < last ? std::string{first, last} : std::string{}; - } - - int HexDigitValue(char value) - { - if (value >= '0' && value <= '9') - { - return value - '0'; - } - if (value >= 'a' && value <= 'f') - { - return value - 'a' + 10; - } - if (value >= 'A' && value <= 'F') - { - return value - 'A' + 10; - } - return -1; - } - - template - void ForEachPercentDecodedByte(std::string_view value, TCallback&& callback) - { - for (size_t index = 0; index < value.size(); ++index) - { - if (value[index] == '%' && index + 2 < value.size()) - { - const int high = HexDigitValue(value[index + 1]); - const int low = HexDigitValue(value[index + 2]); - if (high >= 0 && low >= 0) - { - callback(static_cast((high << 4) | low)); - index += 2; - continue; - } - } - callback(static_cast(value[index])); - } - } - - std::vector PercentDecode(std::string_view value) - { - std::vector decoded; - decoded.reserve(value.size()); - ForEachPercentDecodedByte(value, [&decoded](uint8_t byte) { - decoded.push_back(byte); - }); - return decoded; - } - - int Base64DigitValue(uint8_t value) - { - if (value >= 'A' && value <= 'Z') - { - return value - 'A'; - } - if (value >= 'a' && value <= 'z') - { - return value - 'a' + 26; - } - if (value >= '0' && value <= '9') - { - return value - '0' + 52; - } - if (value == '+') - { - return 62; - } - if (value == '/') - { - return 63; - } - return -1; - } - - std::vector ForgivingBase64Decode(std::string_view input) - { - size_t digitCount{}; - size_t paddingCount{}; - bool sawPadding{}; - ForEachPercentDecodedByte(input, [&](uint8_t value) { - if (IsAsciiWhitespace(value)) - { - return; - } - if (value == '=') - { - sawPadding = true; - ++paddingCount; - return; - } - if (sawPadding || Base64DigitValue(value) < 0) - { - throw std::runtime_error{"fetch: invalid base64 data URL"}; - } - ++digitCount; - }); - - const auto encodedCount = digitCount + paddingCount; - if ((paddingCount > 0 && (encodedCount % 4 != 0 || paddingCount > 2)) || digitCount % 4 == 1) - { - throw std::runtime_error{"fetch: invalid base64 data URL"}; - } - - std::vector decoded(digitCount / 4 * 3 + digitCount % 4 * 3 / 4); - size_t outputIndex{}; - uint32_t accumulator{}; - size_t availableBits{}; - ForEachPercentDecodedByte(input, [&](uint8_t value) { - if (IsAsciiWhitespace(value) || value == '=') - { - return; - } - accumulator = (accumulator << 6) | static_cast(Base64DigitValue(value)); - availableBits += 6; - if (availableBits >= 8) - { - availableBits -= 8; - decoded[outputIndex++] = static_cast(accumulator >> availableBits); - accumulator &= (uint32_t{1} << availableBits) - 1; - } - }); - return decoded; - } - - std::optional ParseDataUrl(std::string_view url) - { - if (url.size() < 5 || !EqualsIgnoreCase(url.substr(0, 4), "data") || url[4] != ':') - { - return std::nullopt; - } - - const auto comma = url.find(',', 5); - if (comma == std::string_view::npos) - { - throw std::runtime_error{"fetch: malformed data URL"}; - } - - std::string mediaType{url.substr(5, comma - 5)}; - TrimAsciiWhitespace(mediaType); - bool base64 = false; - if (const auto semicolon = mediaType.rfind(';'); semicolon != std::string::npos) - { - std::string finalParameter{mediaType.substr(semicolon + 1)}; - TrimAsciiWhitespace(finalParameter); - if (EqualsIgnoreCase(finalParameter, "base64")) - { - mediaType.resize(semicolon); - TrimAsciiWhitespace(mediaType); - base64 = true; - } - } - if (mediaType.empty()) - { - mediaType = "text/plain;charset=US-ASCII"; - } - else if (mediaType.front() == ';') - { - mediaType.insert(0, "text/plain"); - } - - const auto fragment = url.find('#', comma + 1); - const auto payload = url.substr(comma + 1, fragment == std::string_view::npos ? std::string_view::npos : fragment - comma - 1); - auto decodedPayload = base64 ? ForgivingBase64Decode(payload) : PercentDecode(payload); - - return DataUrlResponse{ - std::move(mediaType), - std::string{url.substr(0, fragment)}, - std::move(decodedPayload)}; - } // Stable message used for every transport-failure rejection. Browsers and Node both keep // this constant (the variable detail rides on `cause`) so crash-report grouping stays @@ -502,7 +314,7 @@ namespace Babylon::Polyfills::Internal std::optional dataUrl; try { - dataUrl = ParseDataUrl(url); + dataUrl = Babylon::Polyfills::DataUrl::Parse(url); } catch (const std::runtime_error& error) { diff --git a/Polyfills/URL/CMakeLists.txt b/Polyfills/URL/CMakeLists.txt index 54026df6..0f701ffc 100644 --- a/Polyfills/URL/CMakeLists.txt +++ b/Polyfills/URL/CMakeLists.txt @@ -1,6 +1,8 @@ set(SOURCES ${SOURCES} "Include/Babylon/Polyfills/URL.h" + "InternalInclude/Babylon/Polyfills/DataUrl.h" + "Source/DataUrl.cpp" "Source/URL.cpp" "Source/URL.h" "Source/URLSearchParams.cpp" @@ -9,6 +11,7 @@ set(SOURCES add_library(URL ${SOURCES}) target_include_directories(URL PUBLIC "Include") +target_include_directories(URL PRIVATE "InternalInclude") target_link_libraries(URL PRIVATE BlobInternal @@ -17,3 +20,9 @@ target_link_libraries(URL set_property(TARGET URL PROPERTY FOLDER Polyfills) source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) + +# Seam for other polyfills in this repo that need the data: URL decoder (the fetch polyfill keeps its +# synchronous fast path on it). Not part of the public "Include" directory, like BlobInternal. +add_library(URLInternal INTERFACE) +target_include_directories(URLInternal INTERFACE "InternalInclude") +target_link_libraries(URLInternal INTERFACE URL) diff --git a/Polyfills/URL/InternalInclude/Babylon/Polyfills/DataUrl.h b/Polyfills/URL/InternalInclude/Babylon/Polyfills/DataUrl.h new file mode 100644 index 00000000..1129a35e --- /dev/null +++ b/Polyfills/URL/InternalInclude/Babylon/Polyfills/DataUrl.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include +#include +#include +#include +#include + +namespace Babylon::Polyfills::DataUrl +{ + // A decoded data: URL (RFC 2397 as processed by the WHATWG Fetch "data: URL processor"). + struct Response + { + std::string contentType; + std::string url; + std::vector body; + }; + + // Returns nullopt when `url` is not a data: URL. Throws std::runtime_error when it is one but + // is malformed (invalid forgiving-base64, etc.), so callers can surface a TypeError / network + // error as their contract requires. + std::optional BABYLON_API Parse(std::string_view url); +} diff --git a/Polyfills/URL/Source/DataUrl.cpp b/Polyfills/URL/Source/DataUrl.cpp new file mode 100644 index 00000000..0af40241 --- /dev/null +++ b/Polyfills/URL/Source/DataUrl.cpp @@ -0,0 +1,206 @@ +// Lifted from the fetch polyfill so every UrlLib consumer (XMLHttpRequest, texture and asset +// loaders, fetch) shares one data: URL decoder; see Polyfills/URL/Source/URL.cpp for the scheme +// resolver that registers it. +#include + +#include +#include +#include +#include + +namespace Babylon::Polyfills::DataUrl +{ + namespace + { + bool EqualsIgnoreCase(std::string_view a, std::string_view b) + { + return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](unsigned char l, unsigned char r) { + return std::tolower(l) == std::tolower(r); + }); + } + + bool IsAsciiWhitespace(uint8_t value) + { + return value == 0x09 || value == 0x0A || value == 0x0C || value == 0x0D || value == 0x20; + } + + void TrimAsciiWhitespace(std::string& value) + { + const auto first = std::find_if_not(value.begin(), value.end(), [](unsigned char character) { + return IsAsciiWhitespace(character); + }); + const auto last = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char character) { + return IsAsciiWhitespace(character); + }).base(); + value = first < last ? std::string{first, last} : std::string{}; + } + + int HexDigitValue(char value) + { + if (value >= '0' && value <= '9') + { + return value - '0'; + } + if (value >= 'a' && value <= 'f') + { + return value - 'a' + 10; + } + if (value >= 'A' && value <= 'F') + { + return value - 'A' + 10; + } + return -1; + } + + template + void ForEachPercentDecodedByte(std::string_view value, TCallback&& callback) + { + for (size_t index = 0; index < value.size(); ++index) + { + if (value[index] == '%' && index + 2 < value.size()) + { + const int high = HexDigitValue(value[index + 1]); + const int low = HexDigitValue(value[index + 2]); + if (high >= 0 && low >= 0) + { + callback(static_cast((high << 4) | low)); + index += 2; + continue; + } + } + callback(static_cast(value[index])); + } + } + + std::vector PercentDecode(std::string_view value) + { + std::vector decoded; + decoded.reserve(value.size()); + ForEachPercentDecodedByte(value, [&decoded](uint8_t byte) { + decoded.push_back(byte); + }); + return decoded; + } + + int Base64DigitValue(uint8_t value) + { + if (value >= 'A' && value <= 'Z') + { + return value - 'A'; + } + if (value >= 'a' && value <= 'z') + { + return value - 'a' + 26; + } + if (value >= '0' && value <= '9') + { + return value - '0' + 52; + } + if (value == '+') + { + return 62; + } + if (value == '/') + { + return 63; + } + return -1; + } + + std::vector ForgivingBase64Decode(std::string_view input) + { + size_t digitCount{}; + size_t paddingCount{}; + bool sawPadding{}; + ForEachPercentDecodedByte(input, [&](uint8_t value) { + if (IsAsciiWhitespace(value)) + { + return; + } + if (value == '=') + { + sawPadding = true; + ++paddingCount; + return; + } + if (sawPadding || Base64DigitValue(value) < 0) + { + throw std::runtime_error{"fetch: invalid base64 data URL"}; + } + ++digitCount; + }); + + const auto encodedCount = digitCount + paddingCount; + if ((paddingCount > 0 && (encodedCount % 4 != 0 || paddingCount > 2)) || digitCount % 4 == 1) + { + throw std::runtime_error{"fetch: invalid base64 data URL"}; + } + + std::vector decoded(digitCount / 4 * 3 + digitCount % 4 * 3 / 4); + size_t outputIndex{}; + uint32_t accumulator{}; + size_t availableBits{}; + ForEachPercentDecodedByte(input, [&](uint8_t value) { + if (IsAsciiWhitespace(value) || value == '=') + { + return; + } + accumulator = (accumulator << 6) | static_cast(Base64DigitValue(value)); + availableBits += 6; + if (availableBits >= 8) + { + availableBits -= 8; + decoded[outputIndex++] = static_cast(accumulator >> availableBits); + accumulator &= (uint32_t{1} << availableBits) - 1; + } + }); + return decoded; + } + } + + std::optional Parse(std::string_view url) + { + if (url.size() < 5 || !EqualsIgnoreCase(url.substr(0, 4), "data") || url[4] != ':') + { + return std::nullopt; + } + + const auto comma = url.find(',', 5); + if (comma == std::string_view::npos) + { + throw std::runtime_error{"fetch: malformed data URL"}; + } + + std::string mediaType{url.substr(5, comma - 5)}; + TrimAsciiWhitespace(mediaType); + bool base64 = false; + if (const auto semicolon = mediaType.rfind(';'); semicolon != std::string::npos) + { + std::string finalParameter{mediaType.substr(semicolon + 1)}; + TrimAsciiWhitespace(finalParameter); + if (EqualsIgnoreCase(finalParameter, "base64")) + { + mediaType.resize(semicolon); + TrimAsciiWhitespace(mediaType); + base64 = true; + } + } + if (mediaType.empty()) + { + mediaType = "text/plain;charset=US-ASCII"; + } + else if (mediaType.front() == ';') + { + mediaType.insert(0, "text/plain"); + } + + const auto fragment = url.find('#', comma + 1); + const auto payload = url.substr(comma + 1, fragment == std::string_view::npos ? std::string_view::npos : fragment - comma - 1); + auto decodedPayload = base64 ? ForgivingBase64Decode(payload) : PercentDecode(payload); + + return Response{ + std::move(mediaType), + std::string{url.substr(0, fragment)}, + std::move(decodedPayload)}; + } +} diff --git a/Polyfills/URL/Source/URL.cpp b/Polyfills/URL/Source/URL.cpp index 3d2b9d7d..8a3c969e 100644 --- a/Polyfills/URL/Source/URL.cpp +++ b/Polyfills/URL/Source/URL.cpp @@ -1,8 +1,11 @@ #include "URL.h" #include #include +#include #include +#include #include +#include #include #include #include @@ -65,6 +68,41 @@ namespace // minted by URL.createObjectURL uniformly through the transport layer, instead of each polyfill // re-implementing the store lookup. A revoked (or never-registered) URL reports handled=false, // which UrlLib surfaces as a status-0 network error -- matching browser behavior. + // data: URLs are standard (RFC 2397; WHATWG Fetch "data: URL processor"), so resolve them for + // every UrlLib consumer -- XMLHttpRequest, image/texture/asset loaders, fetch -- rather than + // only inside the fetch polyfill (#67). A malformed data: URL is a network error per spec, which + // UrlLib expresses as `handled == false`. + void EnsureDataSchemeResolverRegistered() + { + static std::once_flag onceFlag; + std::call_once(onceFlag, [] { + UrlLib::UrlRequest::RegisterSchemeResolver("data", [](const std::string& url) { + UrlLib::UrlSchemeResolverResult result; + std::optional parsed; + try + { + parsed = Babylon::Polyfills::DataUrl::Parse(url); + } + catch (const std::runtime_error&) + { + return result; + } + if (!parsed) + { + return result; + } + result.handled = true; + result.statusCode = UrlLib::UrlStatusCode::Ok; + result.statusText = "OK"; + result.contentType = std::move(parsed->contentType); + auto bytes = std::make_shared>(parsed->body.size()); + std::transform(parsed->body.begin(), parsed->body.end(), bytes->begin(), [](uint8_t value) { return static_cast(value); }); + result.body = std::move(bytes); + return result; + }); + }); + } + void EnsureBlobSchemeResolverRegistered() { static std::once_flag onceFlag; @@ -461,6 +499,7 @@ namespace Babylon::Polyfills::Internal void URL::Initialize(Napi::Env env) { EnsureBlobSchemeResolverRegistered(); + EnsureDataSchemeResolverRegistered(); if (env.Global().Get(JS_URL_CONSTRUCTOR_NAME).IsUndefined()) { diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 39b1e8c5..0296aa3b 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -661,6 +661,66 @@ describe("fetch", function () { expect(new Uint8Array(await blob.arrayBuffer())).to.eql(new Uint8Array([0, 1, 2, 255])); }); + // The data: scheme is resolved by UrlLib for every consumer, not only fetch (#67): XMLHttpRequest + // is the path Babylon.js' asset and texture loaders take. + it("resolves data: URLs through XMLHttpRequest for asset-style loads", async function () { + const xhr = await new Promise((resolve) => { + const req = new XMLHttpRequest(); + req.open("GET", "data:text/plain;charset=utf-8,hello%20world"); + req.addEventListener("loadend", () => resolve(req)); + req.send(); + }); + expect(xhr.status).to.equal(200); + expect(xhr.responseText).to.equal("hello world"); + expect((xhr.getResponseHeader("content-type") || "").toLowerCase()).to.contain("text/plain"); + }); + + it("decodes base64 data: URLs into an ArrayBuffer through XMLHttpRequest", async function () { + const xhr = await new Promise((resolve) => { + const req = new XMLHttpRequest(); + req.responseType = "arraybuffer"; + req.open("GET", "data:application/octet-stream;base64,AQID"); + req.addEventListener("loadend", () => resolve(req)); + req.send(); + }); + expect(xhr.status).to.equal(200); + expect(Array.from(new Uint8Array(xhr.response))).to.deep.equal([1, 2, 3]); + }); + + it("surfaces a malformed data: URL as a network error", async function () { + const xhr = await new Promise((resolve) => { + const req = new XMLHttpRequest(); + req.open("GET", "data:text/plain;base64,@@@"); + req.addEventListener("loadend", () => resolve(req)); + req.send(); + }); + expect(xhr.status).to.equal(0); + }); + + it("round-trips a data: URL through Blob and an object URL", async function () { + const response = await fetch("data:application/octet-stream;base64,AQID"); + const blob = await response.blob(); + expect(blob.size).to.equal(3); + expect(blob.type).to.equal("application/octet-stream"); + const objectUrl = URL.createObjectURL(blob); + try { + const again = await fetch(objectUrl); + expect(Array.from(new Uint8Array(await again.arrayBuffer()))).to.deep.equal([1, 2, 3]); + } finally { + URL.revokeObjectURL(objectUrl); + } + }); + + it("streams a base64 gzip data: URL through DecompressionStream", async function () { + if (typeof DecompressionStream !== "function") { + this.skip(); // the compression polyfill is optional + } + // gzip.compress(b"hello gzip", mtime=0) + const response = await fetch("data:application/gzip;base64,H4sIAAAAAAAC/8tIzcnJV0ivyiwAABlq0t8KAAAA"); + const decompressed = response.body.pipeThrough(new DecompressionStream("gzip")); + expect(await new Response(decompressed).text()).to.equal("hello gzip"); + }); + // Adapted from WPT fetch/data-urls/processing.any.js and resources/data-urls.json. const dataUrlCases: Array<[string, string, number[]]> = [ ["data:,", "text/plain;charset=US-ASCII", []], From 707479d5633cb1db97a6782e4def07529ef3bf89 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:01:49 -0500 Subject: [PATCH 124/174] Address review: define _GNU_SOURCE before system headers, bound the fallback stack limit by the thread's own size, define globalThis non-enumerable via JsDefineProperty (cherry picked from commit fef8cb97602e2d214d680aeedf9be29babbb376e) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 15 +++++++++++--- Core/Node-API/Source/env_chakra.cc | 20 ++++++++++++++++++- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index d9ab764c..b1828b7f 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,3 +1,8 @@ +// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, +// but this translation unit should not depend on the language dialect for a system declaration. +#if defined(__linux__) && !defined(_GNU_SOURCE) +#define _GNU_SOURCE +#endif #include "AppRuntime.h" #include @@ -43,7 +48,7 @@ namespace Babylon size_t JavaScriptStackLimit() { constexpr size_t Margin{256 * 1024}; - constexpr size_t Fallback{512 * 1024}; + constexpr size_t Fallback{256 * 1024}; size_t threadStack{}; #if defined(_WIN32) ULONG_PTR low{}; @@ -66,9 +71,13 @@ namespace Babylon pthread_attr_destroy(&attributes); } #endif - if (threadStack <= Margin) + if (threadStack == 0) + { + return Fallback; // unknown: conservative, well under any plausible thread + } + if (threadStack <= 2 * Margin) { - return Fallback; + return threadStack / 2; // a known small stack must not get a limit larger than itself } return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 641467df..1351525e 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -34,7 +34,25 @@ namespace Napi ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); if (existingType == JsUndefined) { - ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + // { value: globalThis, writable: true, enumerable: false, configurable: true } -- the + // spec's own data property; plain assignment would make it enumerable. + JsValueRef descriptor; + ThrowIfFailed(JsCreateObject(&descriptor)); + JsValueRef trueValue; + ThrowIfFailed(JsGetTrueValue(&trueValue)); + JsValueRef falseValue; + ThrowIfFailed(JsGetFalseValue(&falseValue)); + JsPropertyIdRef descriptorPropertyId; + ThrowIfFailed(JsGetPropertyIdFromName(L"value", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, global, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"writable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"enumerable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, falseValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"configurable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + bool defined; + ThrowIfFailed(JsDefineProperty(global, propertyId, descriptor, &defined)); } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; From f6e087b64a08bb9dfee62893fd40bd528d3057c0 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:09:10 -0500 Subject: [PATCH 125/174] QuickJS: keep from defining min/max (Win32 QuickJS build) (cherry picked from commit 5cd790d5f628e1eb13057a1006260e91dc8a3dfb) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b1828b7f..621f6310 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -27,6 +27,9 @@ #include #endif #if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX // would otherwise define min/max macros that break std::min below +#endif #include #endif @@ -79,7 +82,7 @@ namespace Babylon { return threadStack / 2; // a known small stack must not get a limit larger than itself } - return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From dbbb16659f6e13a822b2a53250a96826e348412c Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:11:56 -0500 Subject: [PATCH 126/174] QuickJS: measure the JS stack budget from the current stack pointer to the thread's base (the nominal size under-budgeted the Android runtime thread: depth-128 recursion hit the limit) (cherry picked from commit d1ca32e239b60f5b71e20e0656f673c10fa711ba) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 32 ++++++++++++------- 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 621f6310..b2757f0c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -48,41 +48,49 @@ namespace Babylon // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit // from the thread that actually runs the runtime instead, keeping a margin for the native // frames QuickJS and the host add between the check and the guard page. + // Bytes of C stack below the current frame, measured from the actual stack pointer to the + // thread's stack base, minus a margin for the native frames QuickJS and the host add between + // the check and the guard page. Measuring from the current position (rather than trusting + // the nominal size) also absorbs whatever the host already consumed above this call. size_t JavaScriptStackLimit() { - constexpr size_t Margin{256 * 1024}; + constexpr size_t Margin{96 * 1024}; constexpr size_t Fallback{256 * 1024}; - size_t threadStack{}; + volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) + const auto here = reinterpret_cast(&marker); + uintptr_t base{}; #if defined(_WIN32) ULONG_PTR low{}; ULONG_PTR high{}; GetCurrentThreadStackLimits(&low, &high); - threadStack = static_cast(high - low); + base = static_cast(low); #elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. - threadStack = pthread_get_stacksize_np(pthread_self()); + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. + const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); + base = top - pthread_get_stacksize_np(pthread_self()); #else pthread_attr_t attributes; if (pthread_getattr_np(pthread_self(), &attributes) == 0) { - void* base{}; + void* address{}; size_t size{}; - if (pthread_attr_getstack(&attributes, &base, &size) == 0) + if (pthread_attr_getstack(&attributes, &address, &size) == 0) { - threadStack = size; + base = reinterpret_cast(address); } pthread_attr_destroy(&attributes); } #endif - if (threadStack == 0) + if (base == 0 || here <= base) { return Fallback; // unknown: conservative, well under any plausible thread } - if (threadStack <= 2 * Margin) + const size_t usable = here - base; + if (usable <= 2 * Margin) { - return threadStack / 2; // a known small stack must not get a limit larger than itself + return usable / 2; // a known small stack must not get a limit larger than itself } - return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From e5a96638fe10a35b1e91654160bb44805149fa63 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:01:49 -0500 Subject: [PATCH 127/174] Address review: define _GNU_SOURCE before system headers, bound the fallback stack limit by the thread's own size, define globalThis non-enumerable via JsDefineProperty (cherry picked from commit fef8cb97602e2d214d680aeedf9be29babbb376e) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 15 +++++++++++--- Core/Node-API/Source/env_chakra.cc | 20 ++++++++++++++++++- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index d9ab764c..b1828b7f 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,3 +1,8 @@ +// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, +// but this translation unit should not depend on the language dialect for a system declaration. +#if defined(__linux__) && !defined(_GNU_SOURCE) +#define _GNU_SOURCE +#endif #include "AppRuntime.h" #include @@ -43,7 +48,7 @@ namespace Babylon size_t JavaScriptStackLimit() { constexpr size_t Margin{256 * 1024}; - constexpr size_t Fallback{512 * 1024}; + constexpr size_t Fallback{256 * 1024}; size_t threadStack{}; #if defined(_WIN32) ULONG_PTR low{}; @@ -66,9 +71,13 @@ namespace Babylon pthread_attr_destroy(&attributes); } #endif - if (threadStack <= Margin) + if (threadStack == 0) + { + return Fallback; // unknown: conservative, well under any plausible thread + } + if (threadStack <= 2 * Margin) { - return Fallback; + return threadStack / 2; // a known small stack must not get a limit larger than itself } return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } diff --git a/Core/Node-API/Source/env_chakra.cc b/Core/Node-API/Source/env_chakra.cc index 641467df..1351525e 100644 --- a/Core/Node-API/Source/env_chakra.cc +++ b/Core/Node-API/Source/env_chakra.cc @@ -34,7 +34,25 @@ namespace Napi ThrowIfFailed(JsGetValueType(existingGlobalThis, &existingType)); if (existingType == JsUndefined) { - ThrowIfFailed(JsSetProperty(global, propertyId, global, true)); + // { value: globalThis, writable: true, enumerable: false, configurable: true } -- the + // spec's own data property; plain assignment would make it enumerable. + JsValueRef descriptor; + ThrowIfFailed(JsCreateObject(&descriptor)); + JsValueRef trueValue; + ThrowIfFailed(JsGetTrueValue(&trueValue)); + JsValueRef falseValue; + ThrowIfFailed(JsGetFalseValue(&falseValue)); + JsPropertyIdRef descriptorPropertyId; + ThrowIfFailed(JsGetPropertyIdFromName(L"value", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, global, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"writable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"enumerable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, falseValue, true)); + ThrowIfFailed(JsGetPropertyIdFromName(L"configurable", &descriptorPropertyId)); + ThrowIfFailed(JsSetProperty(descriptor, descriptorPropertyId, trueValue, true)); + bool defined; + ThrowIfFailed(JsDefineProperty(global, propertyId, descriptor, &defined)); } ThrowIfFailed(JsGetPropertyIdFromName(L"Object", &propertyId)); JsValueRef object; From f5b43de58eb01c0d3333419e656d9414b57ed909 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:09:10 -0500 Subject: [PATCH 128/174] QuickJS: keep from defining min/max (Win32 QuickJS build) (cherry picked from commit 5cd790d5f628e1eb13057a1006260e91dc8a3dfb) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b1828b7f..621f6310 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -27,6 +27,9 @@ #include #endif #if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX // would otherwise define min/max macros that break std::min below +#endif #include #endif @@ -79,7 +82,7 @@ namespace Babylon { return threadStack / 2; // a known small stack must not get a limit larger than itself } - return std::min(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From 6e662d7c55907028c3831b735e05d58ec90df514 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 14:11:56 -0500 Subject: [PATCH 129/174] QuickJS: measure the JS stack budget from the current stack pointer to the thread's base (the nominal size under-budgeted the Android runtime thread: depth-128 recursion hit the limit) (cherry picked from commit d1ca32e239b60f5b71e20e0656f673c10fa711ba) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 32 ++++++++++++------- 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 621f6310..b2757f0c 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -48,41 +48,49 @@ namespace Babylon // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit // from the thread that actually runs the runtime instead, keeping a margin for the native // frames QuickJS and the host add between the check and the guard page. + // Bytes of C stack below the current frame, measured from the actual stack pointer to the + // thread's stack base, minus a margin for the native frames QuickJS and the host add between + // the check and the guard page. Measuring from the current position (rather than trusting + // the nominal size) also absorbs whatever the host already consumed above this call. size_t JavaScriptStackLimit() { - constexpr size_t Margin{256 * 1024}; + constexpr size_t Margin{96 * 1024}; constexpr size_t Fallback{256 * 1024}; - size_t threadStack{}; + volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) + const auto here = reinterpret_cast(&marker); + uintptr_t base{}; #if defined(_WIN32) ULONG_PTR low{}; ULONG_PTR high{}; GetCurrentThreadStackLimits(&low, &high); - threadStack = static_cast(high - low); + base = static_cast(low); #elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the size directly. - threadStack = pthread_get_stacksize_np(pthread_self()); + // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. + const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); + base = top - pthread_get_stacksize_np(pthread_self()); #else pthread_attr_t attributes; if (pthread_getattr_np(pthread_self(), &attributes) == 0) { - void* base{}; + void* address{}; size_t size{}; - if (pthread_attr_getstack(&attributes, &base, &size) == 0) + if (pthread_attr_getstack(&attributes, &address, &size) == 0) { - threadStack = size; + base = reinterpret_cast(address); } pthread_attr_destroy(&attributes); } #endif - if (threadStack == 0) + if (base == 0 || here <= base) { return Fallback; // unknown: conservative, well under any plausible thread } - if (threadStack <= 2 * Margin) + const size_t usable = here - base; + if (usable <= 2 * Margin) { - return threadStack / 2; // a known small stack must not get a limit larger than itself + return usable / 2; // a known small stack must not get a limit larger than itself } - return (std::min)(threadStack - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); } } From 6e094fafc65af22ac5476e0b753f41401db651dc Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 15:24:19 -0500 Subject: [PATCH 130/174] QuickJS: run the Android environment on a nested 8 MiB-stack thread instead of clamping the recursion limit The prior fix measured the worker thread's stack and lowered JS_SetMaxStackSize below it to convert the guard-page SIGSEGV into a catchable error -- but bionic's ~1 MiB worker stack leaves no budget that both avoids the guard page and admits the call depths every other engine accepts (macOS QuickJS clears depth-128 on a 512 KiB secondary-thread stack), so depth-128 recursion started failing with 'Maximum call stack size exceeded'. Instead, run the QuickJS environment on a nested thread with an 8 MiB stack (parity with the desktop threads) and keep QuickJS's own default 1 MiB limit, which now sits safely below the guard page while leaving ordinary recursion room. Confined to the QuickJS backend; other engines and platforms are unchanged. --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 151 ++++++++---------- 1 file changed, 67 insertions(+), 84 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b2757f0c..32f1832f 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,8 +1,3 @@ -// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, -// but this translation unit should not depend on the language dialect for a system declaration. -#if defined(__linux__) && !defined(_GNU_SOURCE) -#define _GNU_SOURCE -#endif #include "AppRuntime.h" #include @@ -23,107 +18,95 @@ #pragma warning(pop) #endif -#if !defined(_WIN32) +#include + +#if defined(__ANDROID__) #include -#endif -#if defined(_WIN32) -#ifndef NOMINMAX -#define NOMINMAX // would otherwise define min/max macros that break std::min below -#endif -#include +#include +#include +#include #endif -#include -#include -#include - namespace Babylon { namespace { - // QuickJS guards against JS recursion by comparing the C stack pointer against - // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in - // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, - // so on those threads the limit sits below the real guard page: deep recursion faults - // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit - // from the thread that actually runs the runtime instead, keeping a margin for the native - // frames QuickJS and the host add between the check and the guard page. - // Bytes of C stack below the current frame, measured from the actual stack pointer to the - // thread's stack base, minus a margin for the native frames QuickJS and the host add between - // the check and the guard page. Measuring from the current position (rather than trusting - // the nominal size) also absorbs whatever the host already consumed above this call. - size_t JavaScriptStackLimit() + // Runs the QuickJS environment on the calling thread. QuickJS's interpreter recurses in C + // (one JS_CallInternal frame per JS call), so deep JS call stacks need a comparably deep C + // stack; QuickJS's own limit (JS_DEFAULT_STACK_SIZE, 1 MiB) guards against overrun. + void RunQuickJSEnvironment(AppRuntime& appRuntime, void (AppRuntime::*run)(Napi::Env)) { - constexpr size_t Margin{96 * 1024}; - constexpr size_t Fallback{256 * 1024}; - volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) - const auto here = reinterpret_cast(&marker); - uintptr_t base{}; -#if defined(_WIN32) - ULONG_PTR low{}; - ULONG_PTR high{}; - GetCurrentThreadStackLimits(&low, &high); - base = static_cast(low); -#elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. - const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); - base = top - pthread_get_stacksize_np(pthread_self()); -#else - pthread_attr_t attributes; - if (pthread_getattr_np(pthread_self(), &attributes) == 0) + JSRuntime* runtime = JS_NewRuntime(); + if (!runtime) { - void* address{}; - size_t size{}; - if (pthread_attr_getstack(&attributes, &address, &size) == 0) - { - base = reinterpret_cast(address); - } - pthread_attr_destroy(&attributes); + throw std::runtime_error{"Failed to create QuickJS runtime"}; } -#endif - if (base == 0 || here <= base) + + JSContext* context = JS_NewContext(runtime); + if (!context) { - return Fallback; // unknown: conservative, well under any plausible thread + JS_FreeRuntime(runtime); + throw std::runtime_error{"Failed to create QuickJS context"}; } - const size_t usable = here - base; - if (usable <= 2 * Margin) + { - return usable / 2; // a known small stack must not get a limit larger than itself + Napi::Env env = Napi::Attach(context); + (appRuntime.*run)(env); + Napi::Detach(env); } - return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + + JS_FreeContext(context); + JS_FreeRuntime(runtime); } } void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { - // Create the runtime. - JSRuntime* runtime = JS_NewRuntime(); - if (!runtime) - { - throw std::runtime_error{"Failed to create QuickJS runtime"}; - } - JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); - - // Create the context. - JSContext* context = JS_NewContext(runtime); - if (!context) - { - JS_FreeRuntime(runtime); - throw std::runtime_error{"Failed to create QuickJS context"}; - } +#if defined(__ANDROID__) + // bionic gives this worker thread ~1 MiB of stack, at or below QuickJS's default 1 MiB + // recursion limit -- so deep-but-legal JS recursion faults the guard page (SIGSEGV) before + // QuickJS can raise a catchable "stack overflow", while clamping the limit below 1 MiB + // instead rejects call depths that every other engine (and desktop QuickJS on its ~8 MiB + // stack) accepts. Run the environment on a nested thread with a desktop-sized stack so + // QuickJS's own default limit sits safely below the guard page and ordinary recursion fits. + std::function body{[this] { RunQuickJSEnvironment(*this, &AppRuntime::Run); }}; + std::exception_ptr thrown{}; + auto payload = std::make_pair(&body, &thrown); + auto trampoline = [](void* arg) -> void* { + auto* p = static_cast*, std::exception_ptr*>*>(arg); + try + { + (*p->first)(); + } + catch (...) + { + *p->second = std::current_exception(); + } + return nullptr; + }; - // Use the context within a scope. + pthread_attr_t attr; + if (pthread_attr_init(&attr) == 0) { - Napi::Env env = Napi::Attach(context); - - Run(env); - - Napi::Detach(env); + pthread_attr_setstacksize(&attr, 8 * 1024 * 1024); + pthread_t tid{}; + const int created = pthread_create(&tid, &attr, trampoline, &payload); + pthread_attr_destroy(&attr); + if (created == 0) + { + pthread_join(tid, nullptr); + if (thrown) + { + std::rethrow_exception(thrown); + } + return; + } } - - // Destroy the context and runtime. - JS_FreeContext(context); - JS_FreeRuntime(runtime); + // Thread creation failed: fall back to the current thread. + RunQuickJSEnvironment(*this, &AppRuntime::Run); +#else + RunQuickJSEnvironment(*this, &AppRuntime::Run); +#endif } void AppRuntime::ShutdownEnvironment(Napi::Env) From c502dcb2c2d9d9fa1a9d8936bdfd35bd4736a189 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 15:29:30 -0500 Subject: [PATCH 131/174] QuickJS: raise the nested-thread JS stack limit to 6 MiB for deep recursion (Debug frames) The nested 8 MiB thread removed the guard-page SIGSEGV but QuickJS's default 1 MiB limit still rejected depth-128 recursion in unoptimized Debug builds (large JS_CallInternal frames). Set JS_SetMaxStackSize to 6 MiB on the guaranteed-8 MiB nested thread; default elsewhere. Emulator-validated: Android QuickJS 30/30. --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 29 ++++++++++++++----- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index 32f1832f..ca219021 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -19,6 +19,7 @@ #endif #include +#include #if defined(__ANDROID__) #include @@ -34,13 +35,20 @@ namespace Babylon // Runs the QuickJS environment on the calling thread. QuickJS's interpreter recurses in C // (one JS_CallInternal frame per JS call), so deep JS call stacks need a comparably deep C // stack; QuickJS's own limit (JS_DEFAULT_STACK_SIZE, 1 MiB) guards against overrun. - void RunQuickJSEnvironment(AppRuntime& appRuntime, void (AppRuntime::*run)(Napi::Env)) + // jsStackLimit: value for JS_SetMaxStackSize, or 0 to keep QuickJS's default (1 MiB). A + // non-default limit is only safe when the caller guarantees a stack large enough to hold it + // below the guard page -- see the Android nested-thread path below. + void RunQuickJSEnvironment(AppRuntime& appRuntime, void (AppRuntime::*run)(Napi::Env), size_t jsStackLimit) { JSRuntime* runtime = JS_NewRuntime(); if (!runtime) { throw std::runtime_error{"Failed to create QuickJS runtime"}; } + if (jsStackLimit != 0) + { + JS_SetMaxStackSize(runtime, jsStackLimit); + } JSContext* context = JS_NewContext(runtime); if (!context) @@ -68,8 +76,14 @@ namespace Babylon // QuickJS can raise a catchable "stack overflow", while clamping the limit below 1 MiB // instead rejects call depths that every other engine (and desktop QuickJS on its ~8 MiB // stack) accepts. Run the environment on a nested thread with a desktop-sized stack so - // QuickJS's own default limit sits safely below the guard page and ordinary recursion fits. - std::function body{[this] { RunQuickJSEnvironment(*this, &AppRuntime::Run); }}; + // QuickJS's raised limit sits safely below the guard page and deep recursion fits. The + // stack must be generous because connectedAndroidTest is an unoptimized Debug build, whose + // JS_CallInternal frames are several times larger than a release build's -- depth-128 + // recursion (which release QuickJS clears within the 1 MiB default) needs well over 1 MiB + // here, so QuickJS's default limit would still reject it on any thread size. + constexpr size_t NestedStackSize{8 * 1024 * 1024}; + constexpr size_t JsStackLimit{6 * 1024 * 1024}; // < NestedStackSize guard; > debug depth-128 need + std::function body{[this] { RunQuickJSEnvironment(*this, &AppRuntime::Run, JsStackLimit); }}; std::exception_ptr thrown{}; auto payload = std::make_pair(&body, &thrown); auto trampoline = [](void* arg) -> void* { @@ -88,7 +102,7 @@ namespace Babylon pthread_attr_t attr; if (pthread_attr_init(&attr) == 0) { - pthread_attr_setstacksize(&attr, 8 * 1024 * 1024); + pthread_attr_setstacksize(&attr, NestedStackSize); pthread_t tid{}; const int created = pthread_create(&tid, &attr, trampoline, &payload); pthread_attr_destroy(&attr); @@ -102,10 +116,11 @@ namespace Babylon return; } } - // Thread creation failed: fall back to the current thread. - RunQuickJSEnvironment(*this, &AppRuntime::Run); + // Thread creation failed: fall back to the current (small) worker thread, where only + // QuickJS's default limit is safe. + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); #else - RunQuickJSEnvironment(*this, &AppRuntime::Run); + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); #endif } From fe7691bcc542e8a133c6ad1b28a2a530bb3c9ead Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 15:30:09 -0500 Subject: [PATCH 132/174] QuickJS: nested 8 MiB Android thread + 6 MiB JS stack limit (supersedes the measured-limit approach; emulator-validated depth-128) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 166 +++++++++--------- 1 file changed, 82 insertions(+), 84 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b2757f0c..ca219021 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,8 +1,3 @@ -// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, -// but this translation unit should not depend on the language dialect for a system declaration. -#if defined(__linux__) && !defined(_GNU_SOURCE) -#define _GNU_SOURCE -#endif #include "AppRuntime.h" #include @@ -23,107 +18,110 @@ #pragma warning(pop) #endif -#if !defined(_WIN32) +#include +#include + +#if defined(__ANDROID__) #include -#endif -#if defined(_WIN32) -#ifndef NOMINMAX -#define NOMINMAX // would otherwise define min/max macros that break std::min below -#endif -#include +#include +#include +#include #endif -#include -#include -#include - namespace Babylon { namespace { - // QuickJS guards against JS recursion by comparing the C stack pointer against - // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in - // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, - // so on those threads the limit sits below the real guard page: deep recursion faults - // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit - // from the thread that actually runs the runtime instead, keeping a margin for the native - // frames QuickJS and the host add between the check and the guard page. - // Bytes of C stack below the current frame, measured from the actual stack pointer to the - // thread's stack base, minus a margin for the native frames QuickJS and the host add between - // the check and the guard page. Measuring from the current position (rather than trusting - // the nominal size) also absorbs whatever the host already consumed above this call. - size_t JavaScriptStackLimit() + // Runs the QuickJS environment on the calling thread. QuickJS's interpreter recurses in C + // (one JS_CallInternal frame per JS call), so deep JS call stacks need a comparably deep C + // stack; QuickJS's own limit (JS_DEFAULT_STACK_SIZE, 1 MiB) guards against overrun. + // jsStackLimit: value for JS_SetMaxStackSize, or 0 to keep QuickJS's default (1 MiB). A + // non-default limit is only safe when the caller guarantees a stack large enough to hold it + // below the guard page -- see the Android nested-thread path below. + void RunQuickJSEnvironment(AppRuntime& appRuntime, void (AppRuntime::*run)(Napi::Env), size_t jsStackLimit) { - constexpr size_t Margin{96 * 1024}; - constexpr size_t Fallback{256 * 1024}; - volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) - const auto here = reinterpret_cast(&marker); - uintptr_t base{}; -#if defined(_WIN32) - ULONG_PTR low{}; - ULONG_PTR high{}; - GetCurrentThreadStackLimits(&low, &high); - base = static_cast(low); -#elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. - const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); - base = top - pthread_get_stacksize_np(pthread_self()); -#else - pthread_attr_t attributes; - if (pthread_getattr_np(pthread_self(), &attributes) == 0) + JSRuntime* runtime = JS_NewRuntime(); + if (!runtime) { - void* address{}; - size_t size{}; - if (pthread_attr_getstack(&attributes, &address, &size) == 0) - { - base = reinterpret_cast(address); - } - pthread_attr_destroy(&attributes); + throw std::runtime_error{"Failed to create QuickJS runtime"}; } -#endif - if (base == 0 || here <= base) + if (jsStackLimit != 0) { - return Fallback; // unknown: conservative, well under any plausible thread + JS_SetMaxStackSize(runtime, jsStackLimit); } - const size_t usable = here - base; - if (usable <= 2 * Margin) + + JSContext* context = JS_NewContext(runtime); + if (!context) { - return usable / 2; // a known small stack must not get a limit larger than itself + JS_FreeRuntime(runtime); + throw std::runtime_error{"Failed to create QuickJS context"}; } - return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + + { + Napi::Env env = Napi::Attach(context); + (appRuntime.*run)(env); + Napi::Detach(env); + } + + JS_FreeContext(context); + JS_FreeRuntime(runtime); } } void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { - // Create the runtime. - JSRuntime* runtime = JS_NewRuntime(); - if (!runtime) - { - throw std::runtime_error{"Failed to create QuickJS runtime"}; - } - JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); - - // Create the context. - JSContext* context = JS_NewContext(runtime); - if (!context) - { - JS_FreeRuntime(runtime); - throw std::runtime_error{"Failed to create QuickJS context"}; - } +#if defined(__ANDROID__) + // bionic gives this worker thread ~1 MiB of stack, at or below QuickJS's default 1 MiB + // recursion limit -- so deep-but-legal JS recursion faults the guard page (SIGSEGV) before + // QuickJS can raise a catchable "stack overflow", while clamping the limit below 1 MiB + // instead rejects call depths that every other engine (and desktop QuickJS on its ~8 MiB + // stack) accepts. Run the environment on a nested thread with a desktop-sized stack so + // QuickJS's raised limit sits safely below the guard page and deep recursion fits. The + // stack must be generous because connectedAndroidTest is an unoptimized Debug build, whose + // JS_CallInternal frames are several times larger than a release build's -- depth-128 + // recursion (which release QuickJS clears within the 1 MiB default) needs well over 1 MiB + // here, so QuickJS's default limit would still reject it on any thread size. + constexpr size_t NestedStackSize{8 * 1024 * 1024}; + constexpr size_t JsStackLimit{6 * 1024 * 1024}; // < NestedStackSize guard; > debug depth-128 need + std::function body{[this] { RunQuickJSEnvironment(*this, &AppRuntime::Run, JsStackLimit); }}; + std::exception_ptr thrown{}; + auto payload = std::make_pair(&body, &thrown); + auto trampoline = [](void* arg) -> void* { + auto* p = static_cast*, std::exception_ptr*>*>(arg); + try + { + (*p->first)(); + } + catch (...) + { + *p->second = std::current_exception(); + } + return nullptr; + }; - // Use the context within a scope. + pthread_attr_t attr; + if (pthread_attr_init(&attr) == 0) { - Napi::Env env = Napi::Attach(context); - - Run(env); - - Napi::Detach(env); + pthread_attr_setstacksize(&attr, NestedStackSize); + pthread_t tid{}; + const int created = pthread_create(&tid, &attr, trampoline, &payload); + pthread_attr_destroy(&attr); + if (created == 0) + { + pthread_join(tid, nullptr); + if (thrown) + { + std::rethrow_exception(thrown); + } + return; + } } - - // Destroy the context and runtime. - JS_FreeContext(context); - JS_FreeRuntime(runtime); + // Thread creation failed: fall back to the current (small) worker thread, where only + // QuickJS's default limit is safe. + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); +#else + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); +#endif } void AppRuntime::ShutdownEnvironment(Napi::Env) From 5d7db945e0b569e133725f97db91d0c2ce9c637a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 13 Sep 2026 15:30:10 -0500 Subject: [PATCH 133/174] QuickJS: nested 8 MiB Android thread + 6 MiB JS stack limit (supersedes the measured-limit approach; emulator-validated depth-128) --- Core/AppRuntime/Source/AppRuntime_QuickJS.cpp | 166 +++++++++--------- 1 file changed, 82 insertions(+), 84 deletions(-) diff --git a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp index b2757f0c..ca219021 100644 --- a/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp +++ b/Core/AppRuntime/Source/AppRuntime_QuickJS.cpp @@ -1,8 +1,3 @@ -// pthread_getattr_np is declared by glibc only under the GNU feature set; gnu++20 predefines it, -// but this translation unit should not depend on the language dialect for a system declaration. -#if defined(__linux__) && !defined(_GNU_SOURCE) -#define _GNU_SOURCE -#endif #include "AppRuntime.h" #include @@ -23,107 +18,110 @@ #pragma warning(pop) #endif -#if !defined(_WIN32) +#include +#include + +#if defined(__ANDROID__) #include -#endif -#if defined(_WIN32) -#ifndef NOMINMAX -#define NOMINMAX // would otherwise define min/max macros that break std::min below -#endif -#include +#include +#include +#include #endif -#include -#include -#include - namespace Babylon { namespace { - // QuickJS guards against JS recursion by comparing the C stack pointer against - // stack_top - stack_size, where stack_size defaults to JS_DEFAULT_STACK_SIZE (1 MiB in - // quickjs-ng). That is also the default size of a non-main thread on Android and Windows, - // so on those threads the limit sits below the real guard page: deep recursion faults - // (SIGSEGV) before QuickJS can raise "InternalError: stack overflow". Derive the limit - // from the thread that actually runs the runtime instead, keeping a margin for the native - // frames QuickJS and the host add between the check and the guard page. - // Bytes of C stack below the current frame, measured from the actual stack pointer to the - // thread's stack base, minus a margin for the native frames QuickJS and the host add between - // the check and the guard page. Measuring from the current position (rather than trusting - // the nominal size) also absorbs whatever the host already consumed above this call. - size_t JavaScriptStackLimit() + // Runs the QuickJS environment on the calling thread. QuickJS's interpreter recurses in C + // (one JS_CallInternal frame per JS call), so deep JS call stacks need a comparably deep C + // stack; QuickJS's own limit (JS_DEFAULT_STACK_SIZE, 1 MiB) guards against overrun. + // jsStackLimit: value for JS_SetMaxStackSize, or 0 to keep QuickJS's default (1 MiB). A + // non-default limit is only safe when the caller guarantees a stack large enough to hold it + // below the guard page -- see the Android nested-thread path below. + void RunQuickJSEnvironment(AppRuntime& appRuntime, void (AppRuntime::*run)(Napi::Env), size_t jsStackLimit) { - constexpr size_t Margin{96 * 1024}; - constexpr size_t Fallback{256 * 1024}; - volatile char marker{}; // the address of a local is a portable stack-pointer proxy (MSVC has no __builtin_frame_address) - const auto here = reinterpret_cast(&marker); - uintptr_t base{}; -#if defined(_WIN32) - ULONG_PTR low{}; - ULONG_PTR high{}; - GetCurrentThreadStackLimits(&low, &high); - base = static_cast(low); -#elif defined(__APPLE__) - // pthread_getattr_np is a GNU/bionic extension; Apple exposes the bounds directly. - const auto top = reinterpret_cast(pthread_get_stackaddr_np(pthread_self())); - base = top - pthread_get_stacksize_np(pthread_self()); -#else - pthread_attr_t attributes; - if (pthread_getattr_np(pthread_self(), &attributes) == 0) + JSRuntime* runtime = JS_NewRuntime(); + if (!runtime) { - void* address{}; - size_t size{}; - if (pthread_attr_getstack(&attributes, &address, &size) == 0) - { - base = reinterpret_cast(address); - } - pthread_attr_destroy(&attributes); + throw std::runtime_error{"Failed to create QuickJS runtime"}; } -#endif - if (base == 0 || here <= base) + if (jsStackLimit != 0) { - return Fallback; // unknown: conservative, well under any plausible thread + JS_SetMaxStackSize(runtime, jsStackLimit); } - const size_t usable = here - base; - if (usable <= 2 * Margin) + + JSContext* context = JS_NewContext(runtime); + if (!context) { - return usable / 2; // a known small stack must not get a limit larger than itself + JS_FreeRuntime(runtime); + throw std::runtime_error{"Failed to create QuickJS context"}; } - return (std::min)(usable - Margin, static_cast(JS_DEFAULT_STACK_SIZE) * 8); + + { + Napi::Env env = Napi::Attach(context); + (appRuntime.*run)(env); + Napi::Detach(env); + } + + JS_FreeContext(context); + JS_FreeRuntime(runtime); } } void AppRuntime::RunEnvironmentTier(const char* /*executablePath*/) { - // Create the runtime. - JSRuntime* runtime = JS_NewRuntime(); - if (!runtime) - { - throw std::runtime_error{"Failed to create QuickJS runtime"}; - } - JS_SetMaxStackSize(runtime, JavaScriptStackLimit()); - - // Create the context. - JSContext* context = JS_NewContext(runtime); - if (!context) - { - JS_FreeRuntime(runtime); - throw std::runtime_error{"Failed to create QuickJS context"}; - } +#if defined(__ANDROID__) + // bionic gives this worker thread ~1 MiB of stack, at or below QuickJS's default 1 MiB + // recursion limit -- so deep-but-legal JS recursion faults the guard page (SIGSEGV) before + // QuickJS can raise a catchable "stack overflow", while clamping the limit below 1 MiB + // instead rejects call depths that every other engine (and desktop QuickJS on its ~8 MiB + // stack) accepts. Run the environment on a nested thread with a desktop-sized stack so + // QuickJS's raised limit sits safely below the guard page and deep recursion fits. The + // stack must be generous because connectedAndroidTest is an unoptimized Debug build, whose + // JS_CallInternal frames are several times larger than a release build's -- depth-128 + // recursion (which release QuickJS clears within the 1 MiB default) needs well over 1 MiB + // here, so QuickJS's default limit would still reject it on any thread size. + constexpr size_t NestedStackSize{8 * 1024 * 1024}; + constexpr size_t JsStackLimit{6 * 1024 * 1024}; // < NestedStackSize guard; > debug depth-128 need + std::function body{[this] { RunQuickJSEnvironment(*this, &AppRuntime::Run, JsStackLimit); }}; + std::exception_ptr thrown{}; + auto payload = std::make_pair(&body, &thrown); + auto trampoline = [](void* arg) -> void* { + auto* p = static_cast*, std::exception_ptr*>*>(arg); + try + { + (*p->first)(); + } + catch (...) + { + *p->second = std::current_exception(); + } + return nullptr; + }; - // Use the context within a scope. + pthread_attr_t attr; + if (pthread_attr_init(&attr) == 0) { - Napi::Env env = Napi::Attach(context); - - Run(env); - - Napi::Detach(env); + pthread_attr_setstacksize(&attr, NestedStackSize); + pthread_t tid{}; + const int created = pthread_create(&tid, &attr, trampoline, &payload); + pthread_attr_destroy(&attr); + if (created == 0) + { + pthread_join(tid, nullptr); + if (thrown) + { + std::rethrow_exception(thrown); + } + return; + } } - - // Destroy the context and runtime. - JS_FreeContext(context); - JS_FreeRuntime(runtime); + // Thread creation failed: fall back to the current (small) worker thread, where only + // QuickJS's default limit is safe. + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); +#else + RunQuickJSEnvironment(*this, &AppRuntime::Run, 0); +#endif } void AppRuntime::ShutdownEnvironment(Napi::Env) From f8c8335da33d4ff0d231f09413093b63b0bf500b Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 04:17:27 -0500 Subject: [PATCH 134/174] Node-API (JavaScriptCore): only erase the environment registry entry we own The JavaScriptCore backend maps JSGlobalContextRef -> napi_env in a static registry so host callbacks can recover their env from the context. The env destructor erased the entry by context pointer unconditionally. Detach runs after JSGlobalContextRelease (finalizers still need the env), so between the release and the destructor a *new* environment can be handed the same context address and register it; the old destructor then erased the new environment's entry, and its next callback resolved ToNapi() to nullptr and dereferenced it (SIGSEGV inside NativeInfo::Query). With a single environment this never happens, which is why it stayed latent; it surfaced immediately once environments were created and torn down in quick succession (a worker-style create/terminate loop). Erase the entry only if it still maps to this environment. --- Core/Node-API/Source/js_native_api_javascriptcore.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 8d8dbd02..5d782f1e 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -47,7 +47,13 @@ struct napi_env__ { deinit_symbol(function_info_symbol); deinit_symbol(constructor_info_symbol); JSGlobalContextRelease(context); - napi_envs.erase(context); + // Erase only this environment's own registration. JavaScriptCore can hand a new environment the + // address of a context that was released just before this destructor runs (Detach must follow + // JSGlobalContextRelease so finalizers can still resolve their env), and an unconditional erase + // would then drop that newer environment's entry, leaving its callbacks with ToNapi() == nullptr. + if (const auto it = napi_envs.find(context); it != napi_envs.end() && it->second == this) { + napi_envs.erase(it); + } } static napi_env get(JSGlobalContextRef context) { From cefd4561b72a1b27fd9656181c424e550742f70a Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 05:24:07 -0500 Subject: [PATCH 135/174] JSC Node-API: reference primitives and coerce property receivers ToJSObject is a reinterpret_cast whose assert is compiled out in RelWithDebInfo, so every entry point that handed a caller value straight to a JSObject* API tripped JavaScriptCore's RELEASE_ASSERT (JSCell::getOwnPropertySlot) on a primitive. The reachable case is any non-object exception: node-addon-api wraps a pending exception with napi_create_reference, and the watchdog's termination exception is the bare string "JavaScript execution terminated.", as is `throw "text"`. - napi_create_reference follows Node: objects keep the sentinel scheme, symbols are held for the life of the reference (the C API has no weak handle for them), other primitives are strong while the count is positive and released at zero (Node-API 10; napi_invalid_arg before). The status of the reference's init is now propagated instead of being dropped, napi_get_reference_value reports NULL instead of leaving *result unset, and napi_reference_unref refuses an already-zero count. - Property get/set/has/delete and napi_get_prototype coerce the receiver with ToObject as Node does; null/undefined report napi_object_expected with the TypeError pending. - napi_wrap/unwrap/add_finalizer, napi_get_value_external, napi_get_array_length, napi_call_function, napi_new_instance and napi_instanceof validate their object/function argument first. --- .../Source/js_native_api_javascriptcore.cc | 170 +++++++++++++++--- 1 file changed, 150 insertions(+), 20 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 5c8583bc..79313859 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -222,6 +222,28 @@ namespace { return napi_set_last_error(env, napi_pending_exception); } + // Property access follows ToObject(), as it does in Node: a primitive receiver is boxed, while + // null and undefined leave their TypeError pending and report napi_object_expected. Handing a + // primitive straight to JSObject* entry points is a RELEASE_ASSERT inside JavaScriptCore. + napi_status ToJSObjectCoerced(napi_env env, napi_value value, JSObjectRef* result) { + CHECK_ARG(env, value); + const JSValueRef js_value{ToJSValue(value)}; + if (JSValueIsObject(env->context, js_value)) { + *result = ToJSObject(env, value); + return napi_ok; + } + + JSValueRef exception{}; + *result = JSValueToObject(env->context, js_value, &exception); + if (*result == nullptr) { + if (exception != nullptr) { + env->last_exception = exception; + } + return napi_set_last_error(env, napi_object_expected); + } + return napi_ok; + } + napi_status napi_set_error_code(napi_env env, napi_value error, napi_value code, @@ -645,6 +667,7 @@ namespace { } static napi_status Wrap(napi_env env, napi_value object, WrapperInfo** result) { + RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(object)), napi_invalid_arg); WrapperInfo* info{}; CHECK_NAPI(Unwrap(env, object, &info)); if (info == nullptr) { @@ -662,6 +685,7 @@ namespace { } static napi_status Unwrap(napi_env env, napi_value object, WrapperInfo** result) { + RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(object)), napi_invalid_arg); CHECK_NAPI(NativeInfo::Query(env, ToJSObject(env, object), result)); return napi_ok; } @@ -733,6 +757,10 @@ struct napi_ref__ { napi_status init(napi_env env, napi_value value, uint32_t count) { assert(!_value); + if (!JSValueIsObject(env->context, ToJSValue(value))) { + return init_primitive(env, value, count); + } + _value = value; _count = count; @@ -766,7 +794,7 @@ struct napi_ref__ { } void deinit(napi_env env) { - if (_count != 0) { + if (_protected) { unprotect(env); } @@ -775,8 +803,11 @@ struct napi_ref__ { } void ref(napi_env env) { - assert(_value); - if (_count++ == 0) { + if (_value == nullptr) { + // A primitive released at count zero cannot come back; Node reports a count of zero too. + return; + } + if (_count++ == 0 && !_protected) { protect(env); } } @@ -785,7 +816,13 @@ struct napi_ref__ { assert(_value); assert(_count != 0); if (--_count == 0) { - unprotect(env); + if (_kind == Kind::Object) { + unprotect(env); + } else if (_kind == Kind::Primitive) { + unprotect(env); + _value = nullptr; + } + // A symbol stays protected: see init_primitive. } } @@ -794,7 +831,14 @@ struct napi_ref__ { } napi_status value(napi_env env, napi_value* result) const { - assert(_value); + *result = nullptr; + if (_value == nullptr) { + return napi_ok; + } + if (_kind != Kind::Object) { + *result = _value; + return napi_ok; + } if (env->active_ref_values.find(_value) != env->active_ref_values.end()) { std::uintptr_t objectId{}; // NOTE: This check is needed for the same reason we need a similar check in the init function. @@ -809,19 +853,49 @@ struct napi_ref__ { } private: + enum class Kind { + Object, + Symbol, + Primitive, + }; + + // Primitives carry no identity to hang a sentinel on, and the JavaScriptCore C API has no weak + // handle for them, so they are held strongly while the count is positive and released once it + // reaches zero, which is what Node does for values it cannot hold weakly. Symbols are the + // exception: a weak reference to one has to keep resolving for as long as the symbol is alive, + // and that cannot be observed through the C API, so they stay protected for the life of the + // reference. Before Node-API 10 only symbols were referenceable among the non-objects. + napi_status init_primitive(napi_env env, napi_value value, uint32_t count) { + const bool symbol{JSValueIsSymbol(env->context, ToJSValue(value))}; +#if NAPI_VERSION < 10 + RETURN_STATUS_IF_FALSE(env, symbol, napi_invalid_arg); +#endif + _kind = symbol ? Kind::Symbol : Kind::Primitive; + _count = count; + if (symbol || _count != 0) { + _value = value; + protect(env); + } + return napi_ok; + } + void protect(napi_env env) { _iter = env->strong_refs.insert(env->strong_refs.end(), this); JSValueProtect(env->context, ToJSValue(_value)); + _protected = true; } void unprotect(napi_env env) { env->strong_refs.erase(_iter); JSValueUnprotect(env->context, ToJSValue(_value)); + _protected = false; } napi_value _value{}; uint32_t _count{}; std::uintptr_t _objectId{}; + Kind _kind{Kind::Object}; + bool _protected{false}; std::list::iterator _iter{}; }; @@ -983,13 +1057,16 @@ napi_status napi_set_property(napi_env env, CHECK_ARG(env, key); CHECK_ARG(env, value); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSString key_str{ToJSString(env, key, &exception)}; CHECK_JSC(env, exception); JSObjectSetProperty( env->context, - ToJSObject(env, object), + target, key_str, ToJSValue(value), kJSPropertyAttributeNone, @@ -1007,13 +1084,16 @@ napi_status napi_has_property(napi_env env, CHECK_ARG(env, result); CHECK_ARG(env, key); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSString key_str{ToJSString(env, key, &exception)}; CHECK_JSC(env, exception); *result = JSObjectHasProperty( env->context, - ToJSObject(env, object), + target, key_str); return napi_ok; } @@ -1026,13 +1106,16 @@ napi_status napi_get_property(napi_env env, CHECK_ARG(env, key); CHECK_ARG(env, result); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSString key_str{ToJSString(env, key, &exception)}; CHECK_JSC(env, exception); *result = ToNapi(JSObjectGetProperty( env->context, - ToJSObject(env, object), + target, key_str, &exception)); CHECK_JSC(env, exception); @@ -1047,13 +1130,16 @@ napi_status napi_delete_property(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSString key_str{ToJSString(env, key, &exception)}; CHECK_JSC(env, exception); *result = JSObjectDeleteProperty( env->context, - ToJSObject(env, object), + target, key_str, &exception); CHECK_JSC(env, exception); @@ -1085,10 +1171,13 @@ napi_status napi_set_named_property(napi_env env, CHECK_ENV(env); CHECK_ARG(env, value); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSObjectSetProperty( env->context, - ToJSObject(env, object), + target, JSString(utf8name), ToJSValue(value), kJSPropertyAttributeNone, @@ -1103,11 +1192,14 @@ napi_status napi_has_named_property(napi_env env, const char* utf8name, bool* result) { CHECK_ENV(env); - CHECK_ARG(env, object); + CHECK_ARG(env, result); + + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); *result = JSObjectHasProperty( env->context, - ToJSObject(env, object), + target, JSString(utf8name)); return napi_ok; @@ -1118,12 +1210,15 @@ napi_status napi_get_named_property(napi_env env, const char* utf8name, napi_value* result) { CHECK_ENV(env); - CHECK_ARG(env, object); + CHECK_ARG(env, result); + + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); JSValueRef exception{}; *result = ToNapi(JSObjectGetProperty( env->context, - ToJSObject(env, object), + target, JSString(utf8name), &exception)); CHECK_JSC(env, exception); @@ -1138,10 +1233,13 @@ napi_status napi_set_element(napi_env env, CHECK_ENV(env); CHECK_ARG(env, value); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSObjectSetPropertyAtIndex( env->context, - ToJSObject(env, object), + target, index, ToJSValue(value), &exception); @@ -1157,10 +1255,13 @@ napi_status napi_has_element(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSValueRef value{JSObjectGetPropertyAtIndex( env->context, - ToJSObject(env, object), + target, index, &exception)}; CHECK_JSC(env, exception); @@ -1176,10 +1277,13 @@ napi_status napi_get_element(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; *result = ToNapi(JSObjectGetPropertyAtIndex( env->context, - ToJSObject(env, object), + target, index, &exception)); CHECK_JSC(env, exception); @@ -1196,13 +1300,16 @@ napi_status napi_delete_element(napi_env env, napi_value index_value{ToNapi(JSValueMakeNumber(env->context, index))}; + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; JSString index_str{ToJSString(env, index_value, &exception)}; CHECK_JSC(env, exception); *result = JSObjectDeleteProperty( env->context, - ToJSObject(env, object), + target, index_str, &exception); CHECK_JSC(env, exception); @@ -1295,6 +1402,8 @@ napi_status napi_get_array_length(napi_env env, CHECK_ARG(env, value); CHECK_ARG(env, result); + RETURN_STATUS_IF_FALSE(env, JSValueIsArray(env->context, ToJSValue(value)), napi_array_expected); + JSValueRef exception{}; JSValueRef length = JSObjectGetProperty( env->context, @@ -1330,8 +1439,11 @@ napi_status napi_get_prototype(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); + JSObjectRef target{}; + CHECK_NAPI(ToJSObjectCoerced(env, object, &target)); + JSValueRef exception{}; - JSObjectRef prototype{JSValueToObject(env->context, JSObjectGetPrototype(env->context, ToJSObject(env, object)), &exception)}; + JSObjectRef prototype{JSValueToObject(env->context, JSObjectGetPrototype(env->context, target), &exception)}; CHECK_JSC(env, exception); *result = ToNapi(prototype); @@ -1643,9 +1755,14 @@ napi_status napi_call_function(napi_env env, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, recv); + CHECK_ARG(env, func); if (argc > 0) { CHECK_ARG(env, argv); } + // Only object-ness is checked here: a non-callable object surfaces as the TypeError that + // Function.prototype.call raises, whereas some JavaScriptCore builds report JSObjectMakeConstructor + // constructors as not-a-function (see napi_typeof). + RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(func)), napi_function_expected); JSValueRef exception{}; JSValueRef return_value{JSObjectCallAsFunction( @@ -2038,6 +2155,8 @@ napi_status napi_get_value_external(napi_env env, napi_value value, void** resul CHECK_ARG(env, value); CHECK_ARG(env, result); + RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(value)), napi_invalid_arg); + ExternalInfo* info = NativeInfo::Get(ToJSObject(env, value)); *result = (info != nullptr && info->Type() == NativeType::External) ? info->Data() : nullptr; return napi_ok; @@ -2057,7 +2176,11 @@ napi_status napi_create_reference(napi_env env, return napi_set_last_error(env, napi_generic_failure); } - ref->init(env, value, initial_refcount); + const napi_status status{ref->init(env, value, initial_refcount)}; + if (status != napi_ok) { + delete ref; + return status; + } *result = ref; return napi_ok; @@ -2098,6 +2221,7 @@ napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) { napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) { CHECK_ENV(env); CHECK_ARG(env, ref); + RETURN_STATUS_IF_FALSE(env, ref->count() != 0, napi_generic_failure); ref->unref(env); if (result != nullptr) { @@ -2196,6 +2320,10 @@ napi_status napi_new_instance(napi_env env, CHECK_ARG(env, argv); } CHECK_ARG(env, result); + RETURN_STATUS_IF_FALSE(env, + JSValueIsObject(env->context, ToJSValue(constructor)) && + JSObjectIsConstructor(env->context, ToJSObject(env, constructor)), + napi_function_expected); JSValueRef exception{}; *result = ToNapi(JSObjectCallAsConstructor( @@ -2215,7 +2343,9 @@ napi_status napi_instanceof(napi_env env, bool* result) { CHECK_ENV(env); CHECK_ARG(env, object); + CHECK_ARG(env, constructor); CHECK_ARG(env, result); + RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(constructor)), napi_function_expected); JSValueRef exception{}; *result = JSValueIsInstanceOfConstructor( From 1ff52630f12e01e013aed2593f6175faa33135ef Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 05:48:22 -0500 Subject: [PATCH 136/174] Performance: keep the time origin per environment performance.now() measured from one process-wide start time that every Initialize() rewrote. With Workers each runtime initializes the polyfill on its own thread, so ThreadSanitizer reports the write race, and every new worker also moved the main realm's clock backwards. Capture the origin per environment in the now() closure, as each realm has its own time origin on the web, and use steady_clock, which cannot step. (cherry picked from commit 2391b0d3cd8e7261f0a4bca3a55f95af9259c8bc) --- Polyfills/Performance/Source/Performance.cpp | 22 +++++++------------- 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/Polyfills/Performance/Source/Performance.cpp b/Polyfills/Performance/Source/Performance.cpp index 6fa142d6..b2e4a729 100644 --- a/Polyfills/Performance/Source/Performance.cpp +++ b/Polyfills/Performance/Source/Performance.cpp @@ -6,16 +6,6 @@ namespace { constexpr const char* JS_INSTANCE_NAME{"performance"}; - - // Store the start time when the polyfill is initialized - std::chrono::high_resolution_clock::time_point g_startTime; - - Napi::Value Now(const Napi::CallbackInfo& info) - { - auto now = std::chrono::high_resolution_clock::now(); - auto duration = std::chrono::duration(now - g_startTime); - return Napi::Number::New(info.Env(), duration.count()); - } } namespace Babylon::Polyfills::Performance @@ -24,9 +14,6 @@ namespace Babylon::Polyfills::Performance { Napi::HandleScope scope{env}; - // Initialize the start time - g_startTime = std::chrono::high_resolution_clock::now(); - auto performance = env.Global().Get(JS_INSTANCE_NAME).As(); if (!performance.IsUndefined()) { @@ -36,6 +23,13 @@ namespace Babylon::Polyfills::Performance performance = Napi::Object::New(env); env.Global().Set(JS_INSTANCE_NAME, performance); - performance.Set("now", Napi::Function::New(env, Now, "now")); + // The time origin belongs to this environment, as it does to each browsing context and + // worker: a process-wide origin would be reset by every runtime (worker) that initializes + // the polyfill, moving performance.now() backwards elsewhere and racing with it. + const auto timeOrigin = std::chrono::steady_clock::now(); + performance.Set("now", Napi::Function::New(env, [timeOrigin](const Napi::CallbackInfo& info) { + const auto elapsed = std::chrono::duration(std::chrono::steady_clock::now() - timeOrigin); + return Napi::Number::New(info.Env(), elapsed.count()); + }, "now")); } } From 2a07b6afd83211edab48d78806b4f18f5aed8648 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 05:29:24 -0500 Subject: [PATCH 137/174] Tests: cover primitive exceptions, receivers and references in Node-API PrimitiveExceptionSurvivesNativeCatch runs on every engine: `throw 'plain text'` must surface as a catchable Napi::Error whose Message() is callable, with the runtime still usable afterwards. It killed the process on JavaScriptCore before the previous commit. The coercion and reference semantics are Node's, and the other engines diverge (Chakra references any value, some reject a primitive receiver), so PropertyAccessCoercesPrimitiveReceiver and ReferencesToPrimitivesFollowNode build for JavaScriptCore only, behind a new JSRUNTIMEHOST_NAPI_ENGINE_JAVASCRIPTCORE test define. The reference test pins both the pre-10 napi_invalid_arg branch and the Node-API 10 hold-then-release branch. --- Tests/UnitTests/CMakeLists.txt | 7 ++ Tests/UnitTests/Shared/Shared.cpp | 134 ++++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+) diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..bdeb42e8 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -60,6 +60,13 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI") target_compile_definitions(UnitTests PRIVATE JSRUNTIMEHOST_NAPI_ENGINE_JSI) endif() +# The JavaScriptCore backend follows Node's ToObject coercion of property receivers and its +# reference rules for primitives; other engines diverge (Chakra references any value, some reject +# a primitive receiver outright), so the tests that pin those semantics build for it only. +if(NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") + target_compile_definitions(UnitTests PRIVATE JSRUNTIMEHOST_NAPI_ENGINE_JAVASCRIPTCORE) +endif() + target_link_libraries(UnitTests PRIVATE AppRuntime PRIVATE Console diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..ac070566 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -1,5 +1,6 @@ #include "Shared.h" #include +#include #include #include #include @@ -829,6 +830,139 @@ TEST(NodeApi, AdjacentEscapableScopesEscapeIndependently) #endif +// The V8JSI shim surfaces a script `throw` of a primitive as a jsi::JSError rather than a +// Napi::Error, which AppRuntime's dispatch treats as fatal, so this case cannot run there. +#if !defined(JSRUNTIMEHOST_NAPI_ENGINE_JSI) +TEST(NodeApi, PrimitiveExceptionSurvivesNativeCatch) +{ + // Regression: a JavaScript `throw` of a non-object reaches node-addon-api's + // Napi::Error, which wraps the pending exception with napi_create_reference. + // The JavaScriptCore backend handed the primitive to a JSObject* entry point + // (a reinterpret_cast whose assert is compiled out) and tripped a + // RELEASE_ASSERT inside the engine. Its execution-time-limit termination + // exception is such a string, so terminating a busy worker killed the + // process. + Babylon::AppRuntime runtime{}; + + std::promise caught; + std::promise runtimeStillWorks; + + runtime.Dispatch([&caught, &runtimeStillWorks](Napi::Env env) { + bool sawError{false}; + try + { + // Napi::Eval rather than Env::RunScript: the JSI shim has no RunScript and + // Hermes only implements the 3-argument napi_run_script. + Napi::Eval(env, "throw 'plain text';", "primitive-exception.js"); + } + catch (const Napi::Error& error) + { + // Must be callable whether the backend held the string itself or + // wrapped it in an object. + (void)error.Message(); + sawError = true; + } + caught.set_value(sawError); + + const auto sum = Napi::Eval(env, "1 + 1", "primitive-exception.js"); + runtimeStillWorks.set_value(sum.IsNumber() && sum.As().Int32Value() == 2); + }); + + EXPECT_TRUE(caught.get_future().get()); + EXPECT_TRUE(runtimeStillWorks.get_future().get()); +} +#endif + +#if defined(JSRUNTIMEHOST_NAPI_ENGINE_JAVASCRIPTCORE) +TEST(NodeApi, PropertyAccessCoercesPrimitiveReceiver) +{ + // Node coerces the receiver of the property entry points with ToObject: the + // "length" of a string reads through its wrapper, while null and undefined + // report napi_object_expected and leave the TypeError pending. The + // JavaScriptCore backend used to reinterpret the primitive as an object. + Babylon::AppRuntime runtime{}; + + std::promise coerced; + std::promise rejected; + + runtime.Dispatch([&coerced, &rejected](Napi::Env env) { + napi_env nenv{env}; + + napi_value text{Napi::String::New(env, "hello")}; + napi_value length{}; + int32_t value{}; + coerced.set_value( + napi_get_named_property(nenv, text, "length", &length) == napi_ok && + napi_get_value_int32(nenv, length, &value) == napi_ok && + value == 5); + + napi_value undefined{env.Undefined()}; + napi_value ignored{}; + const napi_status status{napi_get_named_property(nenv, undefined, "length", &ignored)}; + bool pending{false}; + napi_is_exception_pending(nenv, &pending); + napi_value exception{}; + napi_get_and_clear_last_exception(nenv, &exception); + rejected.set_value(status == napi_object_expected && pending); + }); + + EXPECT_TRUE(coerced.get_future().get()); + EXPECT_TRUE(rejected.get_future().get()); +} + +TEST(NodeApi, ReferencesToPrimitivesFollowNode) +{ + // Symbols have always been referenceable, and a weak reference keeps + // resolving while the symbol is alive. Other primitives are refused before + // Node-API 10; from 10 on they are held while the count is positive and + // released at zero, when the value reads back as NULL. + Babylon::AppRuntime runtime{}; + + std::promise primitivesHandled; + std::promise symbolResolves; + + runtime.Dispatch([&primitivesHandled, &symbolResolves](Napi::Env env) { + napi_env nenv{env}; + + napi_value text{Napi::String::New(env, "held")}; + napi_ref ref{}; + const napi_status status{napi_create_reference(nenv, text, 1, &ref)}; +#if NAPI_VERSION >= 10 + napi_value value{}; + uint32_t count{1}; + bool ok{status == napi_ok && + napi_get_reference_value(nenv, ref, &value) == napi_ok && + value != nullptr && + Napi::Value(env, value).As().Utf8Value() == "held" && + napi_reference_unref(nenv, ref, &count) == napi_ok && + count == 0}; + value = text; + ok = ok && + napi_get_reference_value(nenv, ref, &value) == napi_ok && + value == nullptr && + napi_reference_unref(nenv, ref, &count) == napi_generic_failure && + napi_delete_reference(nenv, ref) == napi_ok; + primitivesHandled.set_value(ok); +#else + primitivesHandled.set_value(status == napi_invalid_arg); +#endif + + napi_value symbol{Napi::Symbol::New(env, "tag")}; + napi_ref symbolRef{}; + napi_value resolved{}; + symbolResolves.set_value( + napi_create_reference(nenv, symbol, 0, &symbolRef) == napi_ok && + napi_get_reference_value(nenv, symbolRef, &resolved) == napi_ok && + resolved != nullptr && + Napi::Value(env, resolved).StrictEquals(Napi::Value(env, symbol)) && + napi_delete_reference(nenv, symbolRef) == napi_ok); + }); + + EXPECT_TRUE(primitivesHandled.get_future().get()); + EXPECT_TRUE(symbolResolves.get_future().get()); +} +#endif + int RunTests() { testing::InitGoogleTest(); From c3893a42936e6f6ce94f067bd19bc7bd2a7e279e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 06:42:39 -0500 Subject: [PATCH 138/174] Compression: stage output bytes, not Uint8Arrays, until the enqueue callback runs The codec collected its output chunks as Napi::Uint8Array values in a std::vector while zlib kept producing more. Between two chunks the next Uint8Array allocation can trigger a collection, and the JavaScriptCore backend roots nothing that is not on the C stack or protected (its handle scopes are stubs), so an earlier pending chunk could be reclaimed and its storage reused before enqueue ran. The 256 KiB reentrancy test then failed with "incorrect header check" on macOS and Android CI, and deterministically under JSC_collectContinuously=1. Keep the staged output as bytes and create each Uint8Array right before it is enqueued, where the fresh value lives on the stack for the call. (cherry picked from commit c6f1f7b3e29fea7921aee1431dd8725c6e8c2a41) --- Polyfills/Compression/Source/Compression.cpp | 22 +++++++++++++------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/Polyfills/Compression/Source/Compression.cpp b/Polyfills/Compression/Source/Compression.cpp index 7eefbff9..5dd5dc2b 100644 --- a/Polyfills/Compression/Source/Compression.cpp +++ b/Polyfills/Compression/Source/Compression.cpp @@ -150,22 +150,28 @@ namespace Babylon::Polyfills::Internal } } - void CaptureOutput(Napi::Env env, size_t byteLength) + void CaptureOutput(size_t byteLength) { if (byteLength == 0) { return; } - auto output = Napi::Uint8Array::New(env, byteLength); - std::memcpy(output.Data(), m_outputBuffer.get(), byteLength); - m_pendingOutput.emplace_back(std::move(output)); + // Stage bytes rather than JavaScript arrays: a Uint8Array created here would be + // referenced only from this vector until EnqueuePending, and the JavaScriptCore + // backend roots nothing that is not on the C stack or explicitly protected, so a + // collection triggered by allocating the next chunk could reclaim an earlier one + // (observed as a corrupted first chunk under JSC_collectContinuously=1). + m_pendingOutput.emplace_back(m_outputBuffer.get(), m_outputBuffer.get() + byteLength); } void EnqueuePending(const Napi::Function& enqueue) { - for (const auto& output : m_pendingOutput) + const auto env = enqueue.Env(); + for (const auto& bytes : m_pendingOutput) { + auto output = Napi::Uint8Array::New(env, bytes.size()); + std::memcpy(output.Data(), bytes.data(), bytes.size()); enqueue.Call({output}); } m_pendingOutput.clear(); @@ -211,7 +217,7 @@ namespace Babylon::Polyfills::Internal ? deflate(&m_stream, finishing ? Z_FINISH : Z_NO_FLUSH) : inflate(&m_stream, finishing ? Z_FINISH : Z_NO_FLUSH); const auto produced = OUTPUT_BUFFER_SIZE - m_stream.avail_out; - CaptureOutput(env, produced); + CaptureOutput(produced); if (result == Z_STREAM_END) { @@ -355,12 +361,12 @@ namespace Babylon::Polyfills::Internal void ReleasePendingStorage() { m_pendingOutput.clear(); - std::vector{}.swap(m_pendingOutput); + std::vector>{}.swap(m_pendingOutput); } z_stream m_stream{}; std::unique_ptr m_outputBuffer; - std::vector m_pendingOutput; + std::vector> m_pendingOutput; bool m_compressing{}; bool m_initialized{}; bool m_finished{}; From f8e8152c0441739a83ae67b14a9daa37f13be4e4 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 07:03:39 -0500 Subject: [PATCH 139/174] =?UTF-8?q?JSC=20Node-API:=20address=20review=20?= =?UTF-8?q?=E2=80=94=20dead=20weak=20targets,=20primitive=20receivers,=20i?= =?UTF-8?q?nstanceof=20constructors?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - napi_reference_ref no longer promotes a weak object reference whose target was collected (or whose address a newer object reuses); the liveness check that napi_get_reference_value already performs is shared and the count stays at zero, as in Node. - napi_call_function boxes a primitive receiver (ToObject) and maps undefined/null to the null receiver instead of reinterpreting the value. - napi_instanceof requires a function or constructor for the constructor argument (napi_function_expected), not any object. - The JavaScriptCore-only regression tests also build into the Android UnitTestsJNI target, and the receiver coercion is covered. --- .../Source/js_native_api_javascriptcore.cc | 43 ++++++++++++++----- .../Android/app/src/main/cpp/CMakeLists.txt | 5 +++ Tests/UnitTests/Shared/Shared.cpp | 11 ++++- 3 files changed, 48 insertions(+), 11 deletions(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.cc b/Core/Node-API/Source/js_native_api_javascriptcore.cc index 79313859..6fa43e82 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.cc +++ b/Core/Node-API/Source/js_native_api_javascriptcore.cc @@ -807,6 +807,11 @@ struct napi_ref__ { // A primitive released at count zero cannot come back; Node reports a count of zero too. return; } + if (_count == 0 && _kind == Kind::Object && !IsObjectAlive(env)) { + // The weak target has been collected (or its address reused by another object): promoting + // it would protect a stale pointer. Node likewise leaves such a reference at zero. + return; + } if (_count++ == 0 && !_protected) { protect(env); } @@ -839,20 +844,25 @@ struct napi_ref__ { *result = _value; return napi_ok; } - if (env->active_ref_values.find(_value) != env->active_ref_values.end()) { - std::uintptr_t objectId{}; - // NOTE: This check is needed for the same reason we need a similar check in the init function. - // See the comment in init for more details. - CHECK_NAPI(ReferenceInfo::GetObjectId(env, _value, &objectId)); - if (objectId == _objectId) { - *result = _value; - } + if (IsObjectAlive(env)) { + *result = _value; } return napi_ok; } private: + // Whether the weakly tracked object is still the one this reference was created for. The + // sentinel finalizer removes the active entry once the object is collected, and the object id + // check catches an address reused by a newer object before that finalizer ran (see init). + bool IsObjectAlive(napi_env env) const { + if (env->active_ref_values.find(_value) == env->active_ref_values.end()) { + return false; + } + std::uintptr_t objectId{}; + return ReferenceInfo::GetObjectId(env, _value, &objectId) == napi_ok && objectId == _objectId; + } + enum class Kind { Object, Symbol, @@ -1764,11 +1774,18 @@ napi_status napi_call_function(napi_env env, // constructors as not-a-function (see napi_typeof). RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(func)), napi_function_expected); + // The receiver may be any value. A primitive is boxed as ToObject would; undefined and null + // become the null receiver, for which JavaScriptCore supplies the global object. + JSObjectRef receiver{}; + if (!JSValueIsUndefined(env->context, ToJSValue(recv)) && !JSValueIsNull(env->context, ToJSValue(recv))) { + CHECK_NAPI(ToJSObjectCoerced(env, recv, &receiver)); + } + JSValueRef exception{}; JSValueRef return_value{JSObjectCallAsFunction( env->context, ToJSObject(env, func), - JSValueIsUndefined(env->context, ToJSValue(recv)) ? nullptr : ToJSObject(env, recv), + receiver, argc, ToJSValues(argv), &exception)}; @@ -2345,7 +2362,13 @@ napi_status napi_instanceof(napi_env env, CHECK_ARG(env, object); CHECK_ARG(env, constructor); CHECK_ARG(env, result); - RETURN_STATUS_IF_FALSE(env, JSValueIsObject(env->context, ToJSValue(constructor)), napi_function_expected); + // Either predicate: some JavaScriptCore builds report JSObjectMakeConstructor constructors as + // not-a-function (see napi_typeof). + RETURN_STATUS_IF_FALSE(env, + JSValueIsObject(env->context, ToJSValue(constructor)) && + (JSObjectIsFunction(env->context, ToJSObject(env, constructor)) || + JSObjectIsConstructor(env->context, ToJSObject(env, constructor))), + napi_function_expected); JSValueRef exception{}; *result = JSValueIsInstanceOfConstructor( diff --git a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt index 2e31e0fb..9b1c9482 100644 --- a/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt +++ b/Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt @@ -29,6 +29,11 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8") target_link_libraries(UnitTestsJNI PRIVATE AppRuntimeInternal) endif() +# Mirrors Tests/UnitTests/CMakeLists.txt so the JavaScriptCore-only Node-API tests run here too. +if(NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore") + target_compile_definitions(UnitTestsJNI PRIVATE JSRUNTIMEHOST_NAPI_ENGINE_JAVASCRIPTCORE) +endif() + target_compile_definitions(UnitTestsJNI PRIVATE JSRUNTIMEHOST_PLATFORM="${JSRUNTIMEHOST_PLATFORM}") target_compile_definitions(UnitTestsJNI PRIVATE NAPI_JAVASCRIPT_ENGINE="${NAPI_JAVASCRIPT_ENGINE}") target_compile_definitions(UnitTestsJNI PRIVATE ARCANA_TEST_HOOKS) diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index ac070566..90b7bdbf 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -884,8 +884,9 @@ TEST(NodeApi, PropertyAccessCoercesPrimitiveReceiver) std::promise coerced; std::promise rejected; + std::promise calledOnPrimitive; - runtime.Dispatch([&coerced, &rejected](Napi::Env env) { + runtime.Dispatch([&coerced, &rejected, &calledOnPrimitive](Napi::Env env) { napi_env nenv{env}; napi_value text{Napi::String::New(env, "hello")}; @@ -904,10 +905,18 @@ TEST(NodeApi, PropertyAccessCoercesPrimitiveReceiver) napi_value exception{}; napi_get_and_clear_last_exception(nenv, &exception); rejected.set_value(status == napi_object_expected && pending); + + // A primitive receiver is boxed for napi_call_function as well. + napi_value toUpperCase{env.Global().Get("String").As().Get("prototype").As().Get("toUpperCase")}; + napi_value upper{}; + calledOnPrimitive.set_value( + napi_call_function(nenv, text, toUpperCase, 0, nullptr, &upper) == napi_ok && + Napi::Value(env, upper).As().Utf8Value() == "HELLO"); }); EXPECT_TRUE(coerced.get_future().get()); EXPECT_TRUE(rejected.get_future().get()); + EXPECT_TRUE(calledOnPrimitive.get_future().get()); } TEST(NodeApi, ReferencesToPrimitivesFollowNode) From 6f4e7e2ec840adffd89e40f67d2430b667a43ba9 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 07:03:57 -0500 Subject: [PATCH 140/174] Node-API (JavaScriptCore): guard the environment registry with a mutex Environments live on their own runtime threads, so registration, lookup and the conditional erase all touch one std::unordered_map concurrently. --- Core/Node-API/Source/js_native_api_javascriptcore.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Core/Node-API/Source/js_native_api_javascriptcore.h b/Core/Node-API/Source/js_native_api_javascriptcore.h index 5d782f1e..e18b33e9 100644 --- a/Core/Node-API/Source/js_native_api_javascriptcore.h +++ b/Core/Node-API/Source/js_native_api_javascriptcore.h @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -32,7 +33,10 @@ struct napi_env__ { const std::thread::id thread_id{std::this_thread::get_id()}; napi_env__(JSGlobalContextRef context) : context{context} { - napi_envs[context] = this; + { + std::lock_guard lock{napi_envs_mutex}; + napi_envs[context] = this; + } JSGlobalContextRetain(context); init_symbol(constructor_info_symbol, "BabylonNative_ConstructorInfo"); init_symbol(function_info_symbol, "BabylonNative_FunctionInfo"); @@ -51,12 +55,14 @@ struct napi_env__ { // address of a context that was released just before this destructor runs (Detach must follow // JSGlobalContextRelease so finalizers can still resolve their env), and an unconditional erase // would then drop that newer environment's entry, leaving its callbacks with ToNapi() == nullptr. + std::lock_guard lock{napi_envs_mutex}; if (const auto it = napi_envs.find(context); it != napi_envs.end() && it->second == this) { napi_envs.erase(it); } } static napi_env get(JSGlobalContextRef context) { + std::lock_guard lock{napi_envs_mutex}; auto it = napi_envs.find(context); if (it != napi_envs.end()) { return it->second; @@ -66,6 +72,8 @@ struct napi_env__ { } private: + // Environments live on their own runtime threads, so the registry is shared between them. + static inline std::mutex napi_envs_mutex{}; static inline std::unordered_map napi_envs{}; void deinit_refs(); From 5c6cd00c57c86874d02a8dbdd24d73aaabc653c6 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Mon, 14 Sep 2026 07:04:18 -0500 Subject: [PATCH 141/174] Tests: cover the per-environment performance.now() origin Two runtimes: after the second initializes the polyfill, the first one's performance.now() must not go backwards. Fails against the process-wide origin (the second Initialize reset it to zero). --- Tests/UnitTests/Shared/Shared.cpp | 34 +++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 1c7e9ff7..f11b9edc 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -829,6 +829,40 @@ TEST(NodeApi, AdjacentEscapableScopesEscapeIndependently) #endif +TEST(Performance, TimeOriginIsPerEnvironment) +{ + // Regression: performance.now() measured from one process-wide start time that every + // Initialize() rewrote, so bringing up a second runtime moved the first one's clock back to + // zero. Each environment keeps its own origin now, so the first clock stays monotonic. + const auto initialize = [](Babylon::AppRuntime& runtime) { + std::promise done; + runtime.Dispatch([&done](Napi::Env env) { + Babylon::Polyfills::Performance::Initialize(env); + done.set_value(); + }); + done.get_future().get(); + }; + const auto now = [](Babylon::AppRuntime& runtime) { + std::promise value; + runtime.Dispatch([&value](Napi::Env env) { + auto performance = env.Global().Get("performance").As(); + value.set_value(performance.Get("now").As().Call(performance, {}).As().DoubleValue()); + }); + return value.get_future().get(); + }; + + Babylon::AppRuntime first{}; + initialize(first); + std::this_thread::sleep_for(std::chrono::milliseconds{50}); + const double before = now(first); + + Babylon::AppRuntime second{}; + initialize(second); + const double after = now(first); + + EXPECT_GE(after, before); +} + int RunTests() { testing::InitGoogleTest(); From cf3904ad6c705f7e691fe0517277e1873ee29410 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 17:06:06 -0700 Subject: [PATCH 142/174] Blob/URL: identify Blobs by our own constructor; make URL's static methods writable Blob::TryGetData compared an object's prototype chain against whatever the global `Blob` binding held at call time. A script that replaces the global Blob with its own class (BabylonNative's validation harness does, for image loading) made every instance of that class look like one of ours, and Unwrap on an object that wraps nothing threw a bare "Invalid argument" out of URL.createObjectURL -- while a real Blob was rejected as "not a Blob". The constructor is now kept on the runtime's native object at Initialize and identity is checked against that; a null Unwrap yields "not a Blob" like any other foreign object. The same harness assigns its own URL.createObjectURL. napi_default makes static methods read-only, so that assignment failed silently and the native method kept receiving the foreign Blob. WebIDL static operations are writable, enumerable and configurable; declare the URL statics that way. Found by the SOG Gaussian-splat scenes of BabylonNative's Dawn validation catalog ("Failed to parse SOG zip data", cause "Invalid argument"); they pass again with this change. Regression tests cover both halves. --- Polyfills/Blob/Source/Blob.cpp | 12 ++++++++++- Polyfills/URL/Source/URL.cpp | 16 +++++++++++---- Tests/UnitTests/Scripts/tests.ts | 34 ++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+), 5 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 242763fe..f7b79099 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -21,6 +21,10 @@ namespace Babylon::Polyfills::Internal InstanceMethod("bytes", &Blob::Bytes), }); + // TryGetData identifies our instances through this reference, so a script that later + // replaces the global `Blob` (a test shim, another polyfill) cannot make a foreign object + // look like one of ours. + JsRuntime::NativeObject::GetFromJavaScript(env).Set(JS_BLOB_CONSTRUCTOR_NAME, func); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -156,7 +160,9 @@ namespace Babylon::Polyfills::Blob // This keeps the check portable across QuickJS, V8, JavaScriptCore, Chakra and JSI, and it // also accepts Blob subclasses (e.g. File). We deliberately avoid napi_instanceof, whose // node-addon-api wrapper requires a Napi::Function. - const auto blobConstructor = global.Get("Blob"); + // Our constructor is the one registered at Initialize, not the global `Blob` binding: a + // script may have replaced that with its own class whose instances wrap nothing. + const auto blobConstructor = JsRuntime::NativeObject::GetFromJavaScript(env).Get("Blob"); if (!blobConstructor.IsFunction()) { return std::nullopt; @@ -200,6 +206,10 @@ namespace Babylon::Polyfills::Blob } const auto* blob = Internal::Blob::Unwrap(object); + if (blob == nullptr) + { + return std::nullopt; + } return BlobData{blob->Data(), blob->Type()}; } } diff --git a/Polyfills/URL/Source/URL.cpp b/Polyfills/URL/Source/URL.cpp index 3d2b9d7d..eb61eb95 100644 --- a/Polyfills/URL/Source/URL.cpp +++ b/Polyfills/URL/Source/URL.cpp @@ -456,6 +456,11 @@ namespace namespace Babylon::Polyfills::Internal { + namespace + { + constexpr auto WebIdlOperationAttributes = static_cast(napi_writable | napi_enumerable | napi_configurable); + } + static constexpr auto JS_URL_CONSTRUCTOR_NAME = "URL"; void URL::Initialize(Napi::Env env) @@ -485,10 +490,13 @@ namespace Babylon::Polyfills::Internal InstanceMethod("toString", &URL::ToString), InstanceMethod("toJSON", &URL::ToJSON), // Static methods - StaticMethod("canParse", &URL::CanParse), - StaticMethod("parse", &URL::Parse), - StaticMethod("createObjectURL", &URL::CreateObjectURL), - StaticMethod("revokeObjectURL", &URL::RevokeObjectURL), + // WebIDL static operations are writable, enumerable and configurable (a page can + // replace URL.createObjectURL); napi_default would make them read-only and let + // such an assignment fail silently. + StaticMethod("canParse", &URL::CanParse, WebIdlOperationAttributes), + StaticMethod("parse", &URL::Parse, WebIdlOperationAttributes), + StaticMethod("createObjectURL", &URL::CreateObjectURL, WebIdlOperationAttributes), + StaticMethod("revokeObjectURL", &URL::RevokeObjectURL, WebIdlOperationAttributes), }); env.Global().Set(JS_URL_CONSTRUCTOR_NAME, func); diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 654c60b6..edb32de1 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1306,6 +1306,40 @@ describe("URL.createObjectURL", function () { expect(() => URL.createObjectURL("not a blob" as any)).to.throw(); }); + it("identifies real Blobs, and rejects look-alikes, after a script replaces the global Blob", function () { + // A page or test harness may install its own Blob class. Identity must come from the + // polyfill's own constructor: a real Blob still works and a foreign instance is a clean + // TypeError, not a bare "Invalid argument" from unwrapping an object that wraps nothing. + const NativeBlob = Blob; + const real = new NativeBlob(["hello"], { type: "text/plain" }); + class LookAlikeBlob { + size = 5; + type = "text/plain"; + } + (globalThis as any).Blob = LookAlikeBlob; + try { + const url = URL.createObjectURL(real); + expect(url.indexOf("blob:")).to.equal(0); + URL.revokeObjectURL(url); + expect(() => URL.createObjectURL(new LookAlikeBlob() as any)).to.throw(TypeError, /not a Blob/); + } finally { + (globalThis as any).Blob = NativeBlob; + } + }); + + it("exposes createObjectURL as a writable, configurable static (WebIDL operation)", function () { + const descriptor = Object.getOwnPropertyDescriptor(URL, "createObjectURL")!; + expect(descriptor.writable, "writable").to.equal(true); + expect(descriptor.configurable, "configurable").to.equal(true); + const original = URL.createObjectURL; + try { + (URL as any).createObjectURL = () => "blob:replaced"; + expect(URL.createObjectURL(new Blob([]))).to.equal("blob:replaced"); + } finally { + (URL as any).createObjectURL = original; + } + }); + it("resolves a blob: URL through fetch (text + content-type)", async function () { const url = URL.createObjectURL(new Blob(["hello blob"], { type: "text/plain" })); const response = await fetch(url); From b374eb4e83f596662ef0516c8591cdf3aa04514d Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 17:11:10 -0700 Subject: [PATCH 143/174] Tests: reach the global object without globalThis (ChakraCore lacks it) --- Tests/UnitTests/Scripts/tests.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index edb32de1..94251e55 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1310,20 +1310,22 @@ describe("URL.createObjectURL", function () { // A page or test harness may install its own Blob class. Identity must come from the // polyfill's own constructor: a real Blob still works and a foreign instance is a clean // TypeError, not a bare "Invalid argument" from unwrapping an object that wraps nothing. + // ChakraCore has no globalThis; the sloppy-mode Function trick reaches the global object everywhere. + const globalObject: any = Function("return this")(); const NativeBlob = Blob; const real = new NativeBlob(["hello"], { type: "text/plain" }); class LookAlikeBlob { size = 5; type = "text/plain"; } - (globalThis as any).Blob = LookAlikeBlob; + globalObject.Blob = LookAlikeBlob; try { const url = URL.createObjectURL(real); expect(url.indexOf("blob:")).to.equal(0); URL.revokeObjectURL(url); expect(() => URL.createObjectURL(new LookAlikeBlob() as any)).to.throw(TypeError, /not a Blob/); } finally { - (globalThis as any).Blob = NativeBlob; + globalObject.Blob = NativeBlob; } }); From e27baca578a05f335bad1ea70c80c2fdee326498 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 17:36:54 -0700 Subject: [PATCH 144/174] Node-API-JSI: honour napi_writable for method properties; assert the look-alike rejection by message --- Core/Node-API-JSI/Include/napi/napi-inl.h | 4 ++++ Tests/UnitTests/Scripts/tests.ts | 3 ++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Core/Node-API-JSI/Include/napi/napi-inl.h b/Core/Node-API-JSI/Include/napi/napi-inl.h index 14fb745c..d9473742 100644 --- a/Core/Node-API-JSI/Include/napi/napi-inl.h +++ b/Core/Node-API-JSI/Include/napi/napi-inl.h @@ -2315,12 +2315,14 @@ ObjectWrap::DefineClass(napi_env env, prototype; if (p.staticVoidMethod != nullptr) { + descriptor.setProperty(rt, "writable", jsi::Value{(p.attributes & napi_writable) != 0}); descriptor.setProperty(rt, "value", jsi::Function::createFromHostFunction(rt, name, 0, [env, method{p.staticVoidMethod}, data{p.data}](jsi::Runtime& /*rt*/, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value { (*method)({env, thisVal, args, count, nullptr, data}); return {}; })); } else if (p.staticMethod != nullptr) { + descriptor.setProperty(rt, "writable", jsi::Value{(p.attributes & napi_writable) != 0}); descriptor.setProperty(rt, "value", jsi::Function::createFromHostFunction(rt, name, 0, [env, method{p.staticMethod}, data{p.data}](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value { return {rt, (*method)({env, thisVal, args, count, nullptr, data})}; @@ -2344,6 +2346,7 @@ ObjectWrap::DefineClass(napi_env env, descriptor.setProperty(rt, "writable", jsi::Value{(p.attributes & napi_writable) != 0}); descriptor.setProperty(rt, "value", static_cast(p.staticValue)); } else if (p.instanceVoidMethod != nullptr) { + descriptor.setProperty(rt, "writable", jsi::Value{(p.attributes & napi_writable) != 0}); descriptor.setProperty(rt, "value", jsi::Function::createFromHostFunction(rt, name, 0, [env, method{p.instanceVoidMethod}, data{p.data}](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value { T* nativeObject{Unwrap(env, thisVal.getObject(rt))}; @@ -2351,6 +2354,7 @@ ObjectWrap::DefineClass(napi_env env, return {}; })); } else if (p.instanceMethod != nullptr) { + descriptor.setProperty(rt, "writable", jsi::Value{(p.attributes & napi_writable) != 0}); descriptor.setProperty(rt, "value", jsi::Function::createFromHostFunction(rt, name, 0, [env, method{p.instanceMethod}, data{p.data}](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value { T* nativeObject{Unwrap(env, thisVal.getObject(rt))}; diff --git a/Tests/UnitTests/Scripts/tests.ts b/Tests/UnitTests/Scripts/tests.ts index 94251e55..26108c70 100644 --- a/Tests/UnitTests/Scripts/tests.ts +++ b/Tests/UnitTests/Scripts/tests.ts @@ -1323,7 +1323,8 @@ describe("URL.createObjectURL", function () { const url = URL.createObjectURL(real); expect(url.indexOf("blob:")).to.equal(0); URL.revokeObjectURL(url); - expect(() => URL.createObjectURL(new LookAlikeBlob() as any)).to.throw(TypeError, /not a Blob/); + // Message only: the JSI adapter still surfaces native throws as plain Errors. + expect(() => URL.createObjectURL(new LookAlikeBlob() as any)).to.throw(/not a Blob/); } finally { globalObject.Blob = NativeBlob; } From a5c341dd02df4217b03663fd095160efa0047c8e Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 17:38:37 -0700 Subject: [PATCH 145/174] Blob: pin the constructor under a hidden global instead of the JsRuntime native object (workers have no JsRuntime) --- Polyfills/Blob/Source/Blob.cpp | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index f7b79099..876b65da 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -5,9 +5,15 @@ namespace Babylon::Polyfills::Internal { + namespace + { + constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; + // Hidden global holding the polyfill's own constructor (see TryGetData). + constexpr auto JS_BLOB_CONSTRUCTOR_KEY = "__jsRuntimeHostBlob"; + } + void Blob::Initialize(Napi::Env env) { - static constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; if (env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).IsUndefined()) { Napi::Function func = DefineClass( @@ -21,10 +27,15 @@ namespace Babylon::Polyfills::Internal InstanceMethod("bytes", &Blob::Bytes), }); - // TryGetData identifies our instances through this reference, so a script that later - // replaces the global `Blob` (a test shim, another polyfill) cannot make a foreign object - // look like one of ours. - JsRuntime::NativeObject::GetFromJavaScript(env).Set(JS_BLOB_CONSTRUCTOR_NAME, func); + // TryGetData identifies our instances through this hidden, non-writable, non-configurable + // global, so a script that later replaces the global `Blob` (a test shim, another + // polyfill) cannot make a foreign object look like one of ours. A plain global rather + // than the JsRuntime native object: worker environments have no JsRuntime. + auto constructorDescriptor = Napi::Object::New(env); + constructorDescriptor.Set("value", func); + env.Global().Get("Object").As().Get("defineProperty").As().Call( + env.Global().Get("Object"), + {env.Global(), Napi::String::New(env, JS_BLOB_CONSTRUCTOR_KEY), constructorDescriptor}); env.Global().Set(JS_BLOB_CONSTRUCTOR_NAME, func); } } @@ -160,9 +171,9 @@ namespace Babylon::Polyfills::Blob // This keeps the check portable across QuickJS, V8, JavaScriptCore, Chakra and JSI, and it // also accepts Blob subclasses (e.g. File). We deliberately avoid napi_instanceof, whose // node-addon-api wrapper requires a Napi::Function. - // Our constructor is the one registered at Initialize, not the global `Blob` binding: a - // script may have replaced that with its own class whose instances wrap nothing. - const auto blobConstructor = JsRuntime::NativeObject::GetFromJavaScript(env).Get("Blob"); + // Our constructor is the one Initialize pinned under the hidden key, not the global `Blob` + // binding: a script may have replaced that with its own class whose instances wrap nothing. + const auto blobConstructor = global.Get(JS_BLOB_CONSTRUCTOR_KEY); if (!blobConstructor.IsFunction()) { return std::nullopt; From 78a9a7faaf443a4e9b71eb7a8911471f56df56de Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 17:39:19 -0700 Subject: [PATCH 146/174] Blob: hoist the constructor-key constants to file scope (fix the build) --- Polyfills/Blob/Source/Blob.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Polyfills/Blob/Source/Blob.cpp b/Polyfills/Blob/Source/Blob.cpp index 876b65da..dabf6f24 100644 --- a/Polyfills/Blob/Source/Blob.cpp +++ b/Polyfills/Blob/Source/Blob.cpp @@ -3,15 +3,15 @@ #include #include -namespace Babylon::Polyfills::Internal +namespace { - namespace - { - constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; - // Hidden global holding the polyfill's own constructor (see TryGetData). - constexpr auto JS_BLOB_CONSTRUCTOR_KEY = "__jsRuntimeHostBlob"; - } + constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob"; + // Hidden global holding the polyfill's own constructor (see Babylon::Polyfills::Blob::TryGetData). + constexpr auto JS_BLOB_CONSTRUCTOR_KEY = "__jsRuntimeHostBlob"; +} +namespace Babylon::Polyfills::Internal +{ void Blob::Initialize(Napi::Env env) { if (env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).IsUndefined()) From 5f246d736b20980b55003352b5f0440ee21cce69 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Wed, 16 Sep 2026 23:01:52 -0700 Subject: [PATCH 147/174] Keep runtime schedulers safe through teardown Share synchronized dispatch state with scheduler copies, close it before AppRuntime discards pending work, and release dispatch captures outside the lock. Preserve existing callable overload behavior while accepting mutable and environment-taking callbacks. Add bounded native regression tests with owned timeout state. Adapted from integration commits by Matt Hargett: Source-commit: 7093c83d3a29020fc52f070859b7f7514ed3195f Source-commit: 0a5d570d156d75f5fc01162f5fe6a7ccc891e3c3 --- Core/AppRuntime/Source/AppRuntime.cpp | 8 +- Core/JsRuntime/Include/Babylon/JsRuntime.h | 12 +- .../Include/Babylon/JsRuntimeScheduler.h | 24 +- Core/JsRuntime/Source/JsRuntime.cpp | 48 ++- Tests/UnitTests/CMakeLists.txt | 1 + Tests/UnitTests/Shared/JsRuntimeScheduler.cpp | 305 ++++++++++++++++++ 6 files changed, 387 insertions(+), 11 deletions(-) create mode 100644 Tests/UnitTests/Shared/JsRuntimeScheduler.cpp diff --git a/Core/AppRuntime/Source/AppRuntime.cpp b/Core/AppRuntime/Source/AppRuntime.cpp index 78ebe2d9..77d9c4aa 100644 --- a/Core/AppRuntime/Source/AppRuntime.cpp +++ b/Core/AppRuntime/Source/AppRuntime.cpp @@ -34,6 +34,7 @@ namespace Babylon } std::optional m_env{}; + std::shared_ptr m_jsRuntimeState{}; std::optional> m_suspensionLock{}; arcana::cancellation_source m_cancelSource{}; arcana::manual_dispatcher<128> m_dispatcher{}; @@ -54,7 +55,7 @@ namespace Babylon m_impl->m_thread = std::thread{[this] { RunPlatformTier(); }}; Dispatch([this](Napi::Env env) { - JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); }); + m_impl->m_jsRuntimeState = JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); }).m_state; Internal::DelayedTaskScheduler::SetForJavaScript(env, GetDelayedTaskScheduler()); m_impl->m_delayedTaskSchedulerRegistered = true; }); @@ -94,6 +95,11 @@ namespace Babylon } Napi::HandleScope scope{env}; + + // Stop native completions before discarding work, while captures can still + // safely release environment-owned values. Do not rely on JS finalizer order. + JsRuntime::Close(m_impl->m_jsRuntimeState); + ShutdownEnvironment(env); if (m_impl->m_delayedTaskSchedulerRegistered) diff --git a/Core/JsRuntime/Include/Babylon/JsRuntime.h b/Core/JsRuntime/Include/Babylon/JsRuntime.h index 75a7f4d9..da11b8df 100644 --- a/Core/JsRuntime/Include/Babylon/JsRuntime.h +++ b/Core/JsRuntime/Include/Babylon/JsRuntime.h @@ -4,7 +4,7 @@ #include #include -#include +#include namespace Babylon { @@ -45,9 +45,15 @@ namespace Babylon JsRuntime& operator=(const JsRuntime&) = delete; private: + friend class AppRuntime; + friend class JsRuntimeScheduler; + JsRuntime(Napi::Env, DispatchFunctionT); + ~JsRuntime(); + + static void Dispatch(const std::shared_ptr&, std::function); + static void Close(const std::shared_ptr&); - DispatchFunctionT m_dispatchFunction{}; - std::mutex m_mutex{}; + std::shared_ptr m_state; }; } diff --git a/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h b/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h index b123611d..6f5cf6da 100644 --- a/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h +++ b/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h @@ -2,29 +2,45 @@ #include "JsRuntime.h" +#include +#include + namespace Babylon { /** * Scheduler that invokes continuations via JsRuntime::Dispatch. * Intended to be consumed by arcana.cpp tasks. + * Copies can outlive the runtime; dispatch after shutdown is discarded. */ class JsRuntimeScheduler { public: explicit JsRuntimeScheduler(JsRuntime& runtime) - : m_runtime{runtime} + : m_runtimeState{runtime.m_state} { } template void operator()(CallableT&& callable) const { - m_runtime.Dispatch([callable{std::forward(callable)}](Napi::Env) { - callable(); + JsRuntime::Dispatch(m_runtimeState, [callable{std::forward(callable)}](Napi::Env env) mutable { + // Preserve the original const, zero-argument invocation when available. + if constexpr (std::is_invocable_v) + { + std::as_const(callable)(); + } + else if constexpr (std::is_invocable_v) + { + callable(); + } + else + { + callable(env); + } }); } private: - JsRuntime& m_runtime; + std::shared_ptr m_runtimeState; }; } diff --git a/Core/JsRuntime/Source/JsRuntime.cpp b/Core/JsRuntime/Source/JsRuntime.cpp index 27db82b0..8c7155bc 100644 --- a/Core/JsRuntime/Source/JsRuntime.cpp +++ b/Core/JsRuntime/Source/JsRuntime.cpp @@ -1,8 +1,22 @@ #include "JsRuntime.h" #include "Babylon/DebugTrace.h" +#include +#include + namespace Babylon { + struct JsRuntime::InternalState + { + explicit InternalState(DispatchFunctionT dispatchFunction) + : DispatchFunction{std::move(dispatchFunction)} + { + } + + DispatchFunctionT DispatchFunction; + std::mutex Mutex; + }; + namespace { static constexpr auto JS_RUNTIME_NAME = "runtime"; @@ -10,7 +24,7 @@ namespace Babylon } JsRuntime::JsRuntime(Napi::Env env, DispatchFunctionT dispatchFunction) - : m_dispatchFunction{std::move(dispatchFunction)} + : m_state{std::make_shared(std::move(dispatchFunction))} { auto global = env.Global(); @@ -28,6 +42,22 @@ namespace Babylon DEBUG_TRACE("JsRuntime created"); } + JsRuntime::~JsRuntime() + { + Close(m_state); + } + + void JsRuntime::Close(const std::shared_ptr& state) + { + DispatchFunctionT dispatchFunction; + if (state) + { + std::scoped_lock lock{state->Mutex}; + dispatchFunction = std::exchange(state->DispatchFunction, {}); + } + // Captured objects may dispatch from their destructors. Release them unlocked. + } + JsRuntime& BABYLON_API JsRuntime::CreateForJavaScript(Napi::Env env, DispatchFunctionT dispatchFunction) { auto* runtime = new JsRuntime(env, std::move(dispatchFunction)); @@ -45,8 +75,20 @@ namespace Babylon void JsRuntime::Dispatch(std::function function) { - std::scoped_lock lock{m_mutex}; - m_dispatchFunction([function = std::move(function)](Napi::Env env) { + Dispatch(m_state, std::move(function)); + } + + void JsRuntime::Dispatch(const std::shared_ptr& state, std::function function) + { + // Keep the host enqueue and Close mutually exclusive: copying the dispatch + // function out of the lock would allow it to run after the host is gone. + std::scoped_lock lock{state->Mutex}; + if (!state->DispatchFunction) + { + return; + } + + state->DispatchFunction([function = std::move(function)](Napi::Env env) { function(env); // The environment will be in a pending exceptional state if diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index f3676d7d..0133ed77 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -9,6 +9,7 @@ file(GLOB ASSETS "${CMAKE_CURRENT_SOURCE_DIR}/Assets/*") set(SOURCES "Shared/DelayedTaskScheduler.cpp" + "Shared/JsRuntimeScheduler.cpp" "Shared/StandardStreamLogger.cpp" "Shared/TimeoutDispatcher.cpp" "Shared/Shared.cpp" diff --git a/Tests/UnitTests/Shared/JsRuntimeScheduler.cpp b/Tests/UnitTests/Shared/JsRuntimeScheduler.cpp new file mode 100644 index 00000000..a17d39a2 --- /dev/null +++ b/Tests/UnitTests/Shared/JsRuntimeScheduler.cpp @@ -0,0 +1,305 @@ +#include +#include +#include "DelayedTaskScheduler.h" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace std::chrono_literals; + +namespace +{ + template + T GetWithTimeout(std::future& future) + { + if (future.wait_for(5s) != std::future_status::ready) + { + throw std::runtime_error{"Runtime callback timed out"}; + } + return future.get(); + } + + // Include destruction in the deadline. A deadlocked worker may be detached, + // so every test and runtime callback owns its state, never a caller's stack. + template + void RunWithTimeout(CallbackT callback) + { + auto completed = std::make_shared>(); + auto future = completed->get_future(); + std::thread worker{[callback = std::move(callback), completed]() { + try + { + callback(); + completed->set_value(); + } + catch (...) + { + completed->set_exception(std::current_exception()); + } + }}; + + if (future.wait_for(15s) != std::future_status::ready) + { + worker.detach(); + FAIL() << "Runtime lifecycle did not finish within 15 seconds"; + } + worker.join(); + EXPECT_NO_THROW(future.get()); + } + + Babylon::JsRuntimeScheduler GetScheduler(Babylon::AppRuntime& runtime) + { + auto ready = std::make_shared>(); + auto future = ready->get_future(); + runtime.Dispatch([ready](Napi::Env env) { + ready->set_value(Babylon::JsRuntimeScheduler{Babylon::JsRuntime::GetFromJavaScript(env)}); + }); + return GetWithTimeout(future); + } + + struct OnDestruction + { + std::function Callback; + ~OnDestruction() + { + Callback(); + } + }; +} + +TEST(JsRuntimeScheduler, CopiesCanOutliveRuntime) +{ + RunWithTimeout([]() { + auto runtime = std::make_unique(); + const auto scheduler = GetScheduler(*runtime); + auto copy = scheduler; + auto moved = std::move(copy); + runtime.reset(); + + auto called = std::make_shared>(false); + scheduler([called]() { *called = true; }); + moved([called]() { *called = true; }); + if (called->load()) + { + throw std::runtime_error{"Callback ran after runtime destruction"}; + } + }); +} + +TEST(JsRuntimeScheduler, AcceptsMutableZeroArgumentLvalue) +{ + RunWithTimeout([]() { + Babylon::AppRuntime runtime; + const auto scheduler = GetScheduler(runtime); + auto completed = std::make_shared>(); + auto future = completed->get_future(); + auto callable = [completed, count = 0]() mutable { completed->set_value(++count); }; + scheduler(callable); + if (GetWithTimeout(future) != 1) + { + throw std::runtime_error{"Mutable callable was not invoked"}; + } + }); +} + +TEST(JsRuntimeScheduler, ForwardsEnvironmentAndAllowsNestedDispatch) +{ + RunWithTimeout([]() { + Babylon::AppRuntime runtime; + auto completed = std::make_shared>(); + auto future = completed->get_future(); + runtime.Dispatch([completed](Napi::Env env) { + const Babylon::JsRuntimeScheduler scheduler{Babylon::JsRuntime::GetFromJavaScript(env)}; + scheduler([completed, scheduler, expected = static_cast(env), count = 0](Napi::Env callbackEnv) mutable { + const bool correct = static_cast(callbackEnv) == expected && ++count == 1; + scheduler([completed, correct]() { completed->set_value(correct); }); + }); + }); + if (!GetWithTimeout(future)) + { + throw std::runtime_error{"Scheduler forwarded the wrong environment"}; + } + }); +} + +TEST(JsRuntimeScheduler, PrefersExistingZeroArgumentOverload) +{ + struct Callable + { + std::shared_ptr> Completed; + void operator()() const { Completed->set_value(true); } + void operator()(Napi::Env) const { Completed->set_value(false); } + }; + + RunWithTimeout([]() { + Babylon::AppRuntime runtime; + auto completed = std::make_shared>(); + auto future = completed->get_future(); + const Callable callable{completed}; + GetScheduler(runtime)(callable); + if (!GetWithTimeout(future)) + { + throw std::runtime_error{"Existing zero-argument overload was bypassed"}; + } + }); +} + +TEST(JsRuntimeScheduler, RunsArcanaContinuation) +{ + RunWithTimeout([]() { + Babylon::AppRuntime runtime; + auto completed = std::make_shared>(); + auto future = completed->get_future(); + auto scheduler = GetScheduler(runtime); + arcana::task_from_result().then( + scheduler, arcana::cancellation::none(), [completed]() { completed->set_value(); }); + GetWithTimeout(future); + }); +} + +TEST(JsRuntimeScheduler, PreservesConstZeroArgumentInvocation) +{ + struct Callable + { + std::shared_ptr> Completed; + void operator()() const { Completed->set_value(true); } + void operator()() { Completed->set_value(false); } + }; + + RunWithTimeout([]() { + Babylon::AppRuntime runtime; + auto completed = std::make_shared>(); + auto future = completed->get_future(); + GetScheduler(runtime)(Callable{completed}); + if (!GetWithTimeout(future)) + { + throw std::runtime_error{"Existing const invocation was bypassed"}; + } + }); +} + +TEST(JsRuntimeScheduler, DispatchCanRaceRuntimeTeardown) +{ + RunWithTimeout([]() { + auto runtime = std::make_unique(); + const auto scheduler = GetScheduler(*runtime); + auto started = std::make_shared>(); + auto future = started->get_future(); + auto called = std::make_shared>(0); + auto stop = std::make_shared>(false); + std::thread producer{[scheduler, started, called, stop]() { + const auto deadline = std::chrono::steady_clock::now() + 5s; + size_t attempts{}; + while (!stop->load() && std::chrono::steady_clock::now() < deadline) + { + scheduler([called]() { called->fetch_add(1); }); + if (++attempts == 100) + { + started->set_value(); + } + std::this_thread::yield(); + } + }}; + auto joinProducer = gsl::finally([&producer, stop]() { + *stop = true; + producer.join(); + }); + GetWithTimeout(future); + runtime.reset(); + + const auto countAfterTeardown = called->load(); + scheduler([called]() { called->fetch_add(1); }); + if (called->load() != countAfterTeardown) + { + throw std::runtime_error{"Callback ran after concurrent teardown"}; + } + }); +} + +TEST(JsRuntimeScheduler, ClosesBeforeDiscardingPendingWork) +{ + RunWithTimeout([]() { + auto runtime = std::make_unique(); + auto ready = std::make_shared>(); + auto future = ready->get_future(); + auto rejected = std::make_shared>(false); + runtime->Dispatch([ready, rejected](Napi::Env env) { + const Babylon::JsRuntimeScheduler scheduler{Babylon::JsRuntime::GetFromJavaScript(env)}; + auto probe = std::make_shared(); + probe->Callback = [scheduler, rejected]() { + auto token = std::make_shared(0); + std::weak_ptr weak = token; + scheduler([token = std::move(token)]() {}); + *rejected = weak.expired(); + }; + // Shutdown discards this capture before clearing the runtime queue. + Babylon::Internal::DelayedTaskScheduler::GetFromJavaScript(env)->Schedule(1h, [probe]() {}); + // Shutdown must not retrieve its state through a mutable JS property. + env.Global().Set("savedNative", env.Global().Get("_native")); + env.Global().Set("_native", env.Undefined()); + ready->set_value(); + }); + GetWithTimeout(future); + runtime.reset(); + if (!rejected->load()) + { + throw std::runtime_error{"Shutdown accepted work while discarding pending captures"}; + } + }); +} + +TEST(JsRuntimeScheduler, RejectedCaptureCanRedispatchFromDestructor) +{ + RunWithTimeout([]() { + auto runtime = std::make_unique(); + const auto scheduler = GetScheduler(*runtime); + runtime.reset(); + auto released = std::make_shared>(false); + auto probe = std::make_shared(); + probe->Callback = [scheduler, released]() { + scheduler([]() {}); + *released = true; + }; + scheduler([probe = std::move(probe)]() {}); + if (!released->load()) + { + throw std::runtime_error{"Rejected callback retained its captures"}; + } + }); +} + +TEST(JsRuntimeScheduler, FinalizerReleasesDispatchCapturesOutsideLock) +{ + RunWithTimeout([]() { + auto runtime = std::make_unique(); + auto ready = std::make_shared>(); + auto future = ready->get_future(); + auto released = std::make_shared>(false); + runtime->Dispatch([ready, released](Napi::Env env) { + auto probe = std::make_shared(); + // An independently created JsRuntime exercises finalizer-only closure, + // including breaking a dispatch capture that owns a scheduler copy. + auto& nativeRuntime = Babylon::JsRuntime::CreateForJavaScript(env, [probe](auto) {}); + probe->Callback = [scheduler = Babylon::JsRuntimeScheduler{nativeRuntime}, released]() { + scheduler([]() {}); + *released = true; + }; + ready->set_value(); + }); + GetWithTimeout(future); + runtime.reset(); + if (!released->load()) + { + throw std::runtime_error{"Finalizer retained the dispatch function"}; + } + }); +} From 688f0444d53f77ea65d7893668355444c4b486b1 Mon Sep 17 00:00:00 2001 From: Matt Hargett Date: Sun, 26 Jul 2026 04:53:10 -0700 Subject: [PATCH 148/174] Restack Worker after CTS staging fix (cherry picked from commit cba438c3cb3ad56fc24960eab1008c58cf3a0c71) --- .github/workflows/worker-wpt.yml | 23 + CMakeLists.txt | 1 + Core/AppRuntime/CMakeLists.txt | 2 + Core/AppRuntime/Include/Babylon/AppRuntime.h | 15 + Core/AppRuntime/Source/AppRuntime.cpp | 47 +- .../Source/AppRuntime_JavaScriptCore.cpp | 59 + Polyfills/CMakeLists.txt | 30 + Polyfills/Worker/CMakeLists.txt | 28 + .../Worker/Include/Babylon/Polyfills/Worker.h | 30 + Polyfills/Worker/Readme.md | 37 + Polyfills/Worker/Source/Worker.cpp | 685 +++ Polyfills/Worker/Source/Worker.h | 45 + Polyfills/Worker/Source/WorkerScripts.h | 470 ++ Tests/UnitTests/CMakeLists.txt | 13 + Tests/UnitTests/Shared/Shared.cpp | 169 +- Tests/UnitTests/WebPlatformTests/LICENSE.md | 11 + Tests/UnitTests/WebPlatformTests/README.md | 35 + .../WebPlatformTests/UPSTREAM_REVISION | 1 + .../WebPlatformTests/resources/testharness.js | 5207 +++++++++++++++++ Tests/UnitTests/WebPlatformTests/runner.js | 340 ++ .../workers/constructors/Worker/terminate.js | 4 + .../EventTarget.worker.js | 23 + .../onmessage.worker.js | 40 + .../postMessage/return-value.worker.js | 8 + .../interfaces/WorkerGlobalScope/self.any.js | 19 + .../WorkerGlobalScope/self.worker.js | 3 + .../WorkerUtils/importScripts/001.worker.js | 7 + .../workers/support/Worker-early-message.js | 12 + .../workers/support/Worker-run-forever.js | 9 + .../support/Worker-structure-message.js | 15 + .../support/Worker-termination-stress.js | 8 + .../support/WorkerGlobalScope-close.js | 24 + 32 files changed, 7407 insertions(+), 13 deletions(-) create mode 100644 .github/workflows/worker-wpt.yml create mode 100644 Polyfills/Worker/CMakeLists.txt create mode 100644 Polyfills/Worker/Include/Babylon/Polyfills/Worker.h create mode 100644 Polyfills/Worker/Readme.md create mode 100644 Polyfills/Worker/Source/Worker.cpp create mode 100644 Polyfills/Worker/Source/Worker.h create mode 100644 Polyfills/Worker/Source/WorkerScripts.h create mode 100644 Tests/UnitTests/WebPlatformTests/LICENSE.md create mode 100644 Tests/UnitTests/WebPlatformTests/README.md create mode 100644 Tests/UnitTests/WebPlatformTests/UPSTREAM_REVISION create mode 100644 Tests/UnitTests/WebPlatformTests/resources/testharness.js create mode 100644 Tests/UnitTests/WebPlatformTests/runner.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/constructors/Worker/terminate.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/DedicatedWorkerGlobalScope/EventTarget.worker.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/DedicatedWorkerGlobalScope/onmessage.worker.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/DedicatedWorkerGlobalScope/postMessage/return-value.worker.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/WorkerGlobalScope/self.any.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/WorkerGlobalScope/self.worker.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/interfaces/WorkerUtils/importScripts/001.worker.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/support/Worker-early-message.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/support/Worker-run-forever.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/support/Worker-structure-message.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/support/Worker-termination-stress.js create mode 100644 Tests/UnitTests/WebPlatformTests/workers/support/WorkerGlobalScope-close.js diff --git a/.github/workflows/worker-wpt.yml b/.github/workflows/worker-wpt.yml new file mode 100644 index 00000000..8204511a --- /dev/null +++ b/.github/workflows/worker-wpt.yml @@ -0,0 +1,23 @@ +name: Worker WPT + +on: + pull_request: + branches: [napi-v7] + +jobs: + Ubuntu_JSC: + uses: ./.github/workflows/build-linux.yml + + Ubuntu_JSC_Sanitizers: + uses: ./.github/workflows/build-linux.yml + with: + cc: clang + cxx: clang++ + enable-sanitizers: true + + Ubuntu_JSC_ThreadSanitizer: + uses: ./.github/workflows/build-linux.yml + with: + cc: clang + cxx: clang++ + enable-thread-sanitizer: true diff --git a/CMakeLists.txt b/CMakeLists.txt index 48117518..f5741a20 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -104,6 +104,7 @@ option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDe option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON) option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON) option(JSRUNTIMEHOST_POLYFILL_COMPRESSION "Include JsRuntimeHost Polyfills CompressionStream and DecompressionStream." ON) +option(JSRUNTIMEHOST_POLYFILL_WORKER "Include JsRuntimeHost Polyfill Worker." ON) # Sanitizers option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF) diff --git a/Core/AppRuntime/CMakeLists.txt b/Core/AppRuntime/CMakeLists.txt index 9e8d10c9..5022ad94 100644 --- a/Core/AppRuntime/CMakeLists.txt +++ b/Core/AppRuntime/CMakeLists.txt @@ -63,6 +63,8 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" AND JSRUNTIMEHOST_CORE_APPRUNTIME_V8_INS set_property(TARGET v8inspector PROPERTY FOLDER Dependencies) elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "QuickJS") target_link_libraries(AppRuntime PRIVATE qjs) +elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore" AND UNIX AND NOT APPLE) + target_link_libraries(AppRuntime PRIVATE ${CMAKE_DL_LIBS}) endif() set_property(TARGET AppRuntime PROPERTY FOLDER Core) diff --git a/Core/AppRuntime/Include/Babylon/AppRuntime.h b/Core/AppRuntime/Include/Babylon/AppRuntime.h index d6d024e5..81572638 100644 --- a/Core/AppRuntime/Include/Babylon/AppRuntime.h +++ b/Core/AppRuntime/Include/Babylon/AppRuntime.h @@ -26,6 +26,11 @@ namespace Babylon // Optional handler for unhandled exceptions. std::function UnhandledExceptionHandler{DefaultUnhandledExceptionHandler}; + // Optional final runtime-thread notification after engine and + // environment teardown. The callback is the thread's last action + // and must not access that runtime's Napi objects. + std::function ThreadExitHandler{}; + // Defines whether to enable the debugger. Only implemented for V8 and Chakra. bool EnableDebugger{false}; @@ -48,6 +53,12 @@ namespace Babylon void Suspend(); void Resume(); + // Permanently stop accepting work and request interruption of any + // JavaScript currently executing. The interruption is immediate on + // engines with an interrupt hook (including system JavaScriptCore) and + // cooperative between dispatches on the remaining engines. + void Terminate(); + void Dispatch(Dispatchable callback); // Default unhandled exception handler that outputs the error message to the program output. @@ -87,6 +98,10 @@ namespace Babylon Internal::DelayedTaskScheduler& GetDelayedTaskScheduler(); + // Engine tiers may query the shared termination flag without exposing + // engine types in the public API. + bool IsTerminationRequested() const noexcept; + Options m_options; class Impl; diff --git a/Core/AppRuntime/Source/AppRuntime.cpp b/Core/AppRuntime/Source/AppRuntime.cpp index 78ebe2d9..281eb46e 100644 --- a/Core/AppRuntime/Source/AppRuntime.cpp +++ b/Core/AppRuntime/Source/AppRuntime.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include @@ -40,6 +41,7 @@ namespace Babylon std::unique_ptr m_delayedTaskScheduler{std::make_unique()}; bool m_delayedTaskSchedulerRegistered{}; std::thread m_thread; + std::atomic_bool m_terminationRequested{false}; }; AppRuntime::AppRuntime() : @@ -51,7 +53,13 @@ namespace Babylon : m_options{std::move(options)} , m_impl{std::make_unique()} { - m_impl->m_thread = std::thread{[this] { RunPlatformTier(); }}; + m_impl->m_thread = std::thread{[this] { + RunPlatformTier(); + if (m_options.ThreadExitHandler) + { + m_options.ThreadExitHandler(); + } + }}; Dispatch([this](Napi::Env env) { JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); }); @@ -67,17 +75,7 @@ namespace Babylon m_impl->m_suspensionLock.reset(); } - // Cancel immediately so pending work is dropped promptly, then append - // a no-op work item to wake the worker thread from blocking_tick. The - // no-op goes through push() which acquires the queue mutex, avoiding - // the race where a bare notify_all() can be missed by wait(). - // - // NOTE: This preserves the existing shutdown behavior where pending - // callbacks are dropped on cancellation. A more complete solution - // would add cooperative shutdown (e.g. NotifyDisposing/Rundown) so - // consumers can finish cleanup work before the runtime is destroyed. - m_impl->m_cancelSource.cancel(); - m_impl->Append([](Napi::Env) {}); + Terminate(); m_impl->m_thread.join(); } @@ -126,8 +124,33 @@ namespace Babylon m_impl->m_suspensionLock.reset(); } + void AppRuntime::Terminate() + { + if (m_impl->m_terminationRequested.exchange(true)) + { + return; + } + + m_impl->m_cancelSource.cancel(); + + // Queueing under the dispatcher's mutex makes the wake-up immune to + // the missed-notification race covered by DestroyDoesNotDeadlock. + // The cancelled run loop drops this no-op rather than executing it. + m_impl->m_dispatcher.queue([]() {}); + } + + bool AppRuntime::IsTerminationRequested() const noexcept + { + return m_impl->m_terminationRequested.load(); + } + void AppRuntime::Dispatch(Dispatchable func) { + if (IsTerminationRequested()) + { + return; + } + m_impl->Append([this, func{std::move(func)}](Napi::Env env) mutable { Execute([this, env, func{std::move(func)}]() mutable { // Some engines (notably Hermes) require an open NAPI handle diff --git a/Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp b/Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp index f2483f41..e3ac526e 100644 --- a/Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp +++ b/Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp @@ -1,12 +1,62 @@ #include "AppRuntime.h" #include +#if __has_include() +#include +#define JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT 1 +#elif defined(__unix__) +#include +#define JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT 1 +#endif + +namespace +{ +#if defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT) + using SetExecutionTimeLimit = void (*)(JSContextGroupRef, double, bool (*)(JSContextRef, void*), void*); + using ClearExecutionTimeLimit = void (*)(JSContextGroupRef); +#endif +} + namespace Babylon { void AppRuntime::RunEnvironmentTier(const char*) { auto globalContext = JSGlobalContextCreateInGroup(nullptr, nullptr); +#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT) || \ + defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT) + auto contextGroup = JSContextGetGroup(globalContext); + const auto shouldTerminateJSC = [](JSContextRef, void* context) { + return static_cast(context)->IsTerminationRequested(); + }; +#endif + +#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT) + // Poll at a modest interval while JS is running. Returning true from + // this callback raises a catchable termination exception and lets the + // AppRuntime thread unwind, so Worker::terminate() also stops a tight + // loop that never reaches the dispatch queue. + JSContextGroupSetExecutionTimeLimit( + contextGroup, + 0.05, + shouldTerminateJSC, + this); +#elif defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT) + // WebKitGTK deliberately omits JSContextRefPrivate.h from its dev + // package, but current system builds export the same C ABI. Resolve it + // dynamically so JsRuntimeHost stays buildable against the public + // package and gracefully falls back to between-dispatch termination on + // older builds that do not export the watchdog. + auto setExecutionTimeLimit = reinterpret_cast( + dlsym(RTLD_DEFAULT, "JSContextGroupSetExecutionTimeLimit")); + auto clearExecutionTimeLimit = reinterpret_cast( + dlsym(RTLD_DEFAULT, "JSContextGroupClearExecutionTimeLimit")); + if (setExecutionTimeLimit != nullptr && clearExecutionTimeLimit != nullptr) + { + setExecutionTimeLimit(contextGroup, 0.05, shouldTerminateJSC, this); + } +#endif + #if __APPLE__ if (__builtin_available(iOS 16.4, macOS 13.3, *)) { @@ -18,6 +68,15 @@ namespace Babylon Run(env); +#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT) + JSContextGroupClearExecutionTimeLimit(contextGroup); +#elif defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT) + if (setExecutionTimeLimit != nullptr && clearExecutionTimeLimit != nullptr) + { + clearExecutionTimeLimit(contextGroup); + } +#endif + JSGlobalContextRelease(globalContext); // Detach must come after JSGlobalContextRelease since it triggers finalizers which require env. diff --git a/Polyfills/CMakeLists.txt b/Polyfills/CMakeLists.txt index 3368375f..c2d60b87 100644 --- a/Polyfills/CMakeLists.txt +++ b/Polyfills/CMakeLists.txt @@ -55,4 +55,34 @@ if(JSRUNTIMEHOST_POLYFILL_COMPRESSION) message(FATAL_ERROR "The Compression polyfill requires the Streams polyfill.") endif() add_subdirectory(Compression) +if(JSRUNTIMEHOST_POLYFILL_COMPRESSION + if(NOT JSRUNTIMEHOST_POLYFILL_STREAMS + message(FATAL_ERROR "The Compression polyfill requires the Streams polyfill." + add_subdirectory(Compression +if(JSRUNTIMEHOST_POLYFILL_WORKER + if(NAPI_JAVASCRIPT_ENGINE STREQUAL "JSI" + # The legacy JSI adapter only implements the v5-shaped C++ surface and + # has no detachable ArrayBuffer ABI. Keep existing JSI configurations + # buildable while the v7-capable engine adapters expose Worker. + message(STATUS "Worker polyfill is unavailable with the legacy JSI adapter" + else( + set(_worker_required_polyfills + JSRUNTIMEHOST_POLYFILL_CONSOLE + JSRUNTIMEHOST_POLYFILL_SCHEDULING + JSRUNTIMEHOST_POLYFILL_XMLHTTPREQUEST + JSRUNTIMEHOST_POLYFILL_FETCH + JSRUNTIMEHOST_POLYFILL_URL + JSRUNTIMEHOST_POLYFILL_ABORT_CONTROLLER + JSRUNTIMEHOST_POLYFILL_WEBSOCKET + JSRUNTIMEHOST_POLYFILL_BLOB + JSRUNTIMEHOST_POLYFILL_FILE + JSRUNTIMEHOST_POLYFILL_PERFORMANCE + JSRUNTIMEHOST_POLYFILL_TEXTDECODER + JSRUNTIMEHOST_POLYFILL_TEXTENCODER + foreach(_worker_dependency IN LISTS _worker_required_polyfills + if(NOT ${_worker_dependency} + message(FATAL_ERROR + "JSRUNTIMEHOST_POLYFILL_WORKER requires ${_worker_dependency}=ON so Worker realms expose the browser baseline." + endforeach( + add_subdirectory(Worker endif() diff --git a/Polyfills/Worker/CMakeLists.txt b/Polyfills/Worker/CMakeLists.txt new file mode 100644 index 00000000..c3e73ddd --- /dev/null +++ b/Polyfills/Worker/CMakeLists.txt @@ -0,0 +1,28 @@ +set(SOURCES + "Include/Babylon/Polyfills/Worker.h" + "Source/Worker.cpp" + "Source/Worker.h" + "Source/WorkerScripts.h") + +add_library(Worker ${SOURCES}) +warnings_as_errors(Worker) + +target_include_directories(Worker PUBLIC "Include") + +target_link_libraries(Worker + PUBLIC AppRuntime + PRIVATE AbortController + PRIVATE Blob + PRIVATE Console + PRIVATE Fetch + PRIVATE File + PRIVATE Performance + PRIVATE Scheduling + PRIVATE TextDecoder + PRIVATE TextEncoder + PRIVATE URL + PRIVATE WebSocket + PRIVATE XMLHttpRequest) + +set_property(TARGET Worker PROPERTY FOLDER Polyfills) +source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES}) diff --git a/Polyfills/Worker/Include/Babylon/Polyfills/Worker.h b/Polyfills/Worker/Include/Babylon/Polyfills/Worker.h new file mode 100644 index 00000000..00a03921 --- /dev/null +++ b/Polyfills/Worker/Include/Babylon/Polyfills/Worker.h @@ -0,0 +1,30 @@ +#pragma once + +#include +#include + +#include +#include + +namespace Babylon::Polyfills::Worker +{ + struct Options + { + // Base directory used for relative paths and app:/// URLs. Files are + // read directly from this directory when ScriptResolver is not set. + std::string ScriptRoot{}; + + // Optional host asset resolver. The callback receives a normalized + // worker URL and returns its JavaScript source. It may be called from + // any Worker runtime thread and therefore must be thread-safe. + std::function ScriptResolver{}; + + // Optional worker-console sink. The callback is invoked on the Worker + // runtime thread and must be thread-safe. + std::function ConsoleCallback{}; + }; + + // Installs Worker, EventTarget, Event, MessageEvent, ErrorEvent and + // DOMException on the current global object. + void BABYLON_API Initialize(Napi::Env env, Options options = {}); +} diff --git a/Polyfills/Worker/Readme.md b/Polyfills/Worker/Readme.md new file mode 100644 index 00000000..3a95e51f --- /dev/null +++ b/Polyfills/Worker/Readme.md @@ -0,0 +1,37 @@ +# Worker + +Provides a browser-compatible dedicated `Worker` backed by one `AppRuntime` +(and therefore one engine realm and native thread) per Worker. + +Implemented surface: + +- `new Worker(url, { name, type })`, `postMessage()`, and `terminate()` +- `WorkerGlobalScope` / `DedicatedWorkerGlobalScope`, `self`, `location`, + `close()`, synchronous `importScripts()`, and worker `postMessage()` +- `EventTarget`, `Event`, `MessageEvent`, `ErrorEvent`, `DOMException`, + `onmessage`, `onmessageerror`, and `onerror` +- structured cloning for cyclic objects, arrays, dates, regular expressions, + maps, sets, errors, ArrayBuffers, DataViews, typed arrays, BigInts, and + special number values +- transferable ArrayBuffers using the N-API v7 detach operation + +The default loader reads relative paths and `app:///` URLs below +`Options::ScriptRoot`. Native applications can instead supply a thread-safe +`ScriptResolver` for packaged assets. + +`type: "module"` accepts self-contained, script-compatible application bundles. +JavaScriptCore's public C API has no module-loader hook, so the application's +normal bundler must flatten top-level `import` and `export` declarations before +loading. Classic workers and bundled module workers share the same isolated +runtime. + +On system JavaScriptCore, `terminate()` uses the engine execution-time-limit +symbol when the installed build exports it and can interrupt a tight loop. +Other engines, and older WebKitGTK builds without that symbol, currently stop +between dispatches until their native interrupt hooks are connected. + +`WorkerGlobalScope.close()` stops future worker tasks but preserves messages +and uncaught errors produced later in the task that called it, as required by +WPT. Worker-owned runtime state is torn down on the worker thread; the final +strong reference to the parent-realm `Worker` object is released by a FIFO +dispatch on the parent runtime after worker engine/environment teardown. diff --git a/Polyfills/Worker/Source/Worker.cpp b/Polyfills/Worker/Source/Worker.cpp new file mode 100644 index 00000000..033d3b96 --- /dev/null +++ b/Polyfills/Worker/Source/Worker.cpp @@ -0,0 +1,685 @@ +#include "Worker.h" +#include "WorkerScripts.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Babylon::Polyfills::Internal +{ + namespace + { + using Options = Babylon::Polyfills::Worker::Options; + + bool HasScheme(const std::string& value) + { + const auto separator = value.find(':'); + if (separator == std::string::npos || separator == 0) + { + return false; + } + for (std::size_t i = 0; i < separator; ++i) + { + const auto c = static_cast(value[i]); + if (!(std::isalnum(c) || c == '+' || c == '-' || c == '.')) + { + return false; + } + } + return true; + } + + std::string PercentDecode(const std::string& value) + { + std::string result; + result.reserve(value.size()); + for (std::size_t i = 0; i < value.size(); ++i) + { + if (value[i] == '%' && i + 2 < value.size()) + { + const auto hex = value.substr(i + 1, 2); + char* end{}; + const auto decoded = std::strtoul(hex.c_str(), &end, 16); + if (end != nullptr && *end == '\0') + { + result.push_back(static_cast(decoded)); + i += 2; + continue; + } + } + result.push_back(value[i]); + } + return result; + } + + std::string ResolveUrl(const std::string& root, + const std::string& base, + const std::string& requested) + { + if (requested.rfind("data:", 0) == 0 || requested.rfind("file://", 0) == 0 || + requested.rfind("app://", 0) == 0) + { + return requested; + } + + // A leading slash is origin-relative in Worker/importScripts, not + // a host-filesystem escape from ScriptRoot. + if (!requested.empty() && requested.front() == '/') + { + return (std::filesystem::path{root} / requested.substr(1)).lexically_normal().string(); + } + + if (HasScheme(requested)) + { + return requested; + } + + if (base.rfind("app://", 0) == 0) + { + const auto slash = base.find('/', 6); + const std::string prefix = slash == std::string::npos ? base + "/" : base.substr(0, slash + 1); + const std::filesystem::path path = slash == std::string::npos ? std::filesystem::path{} : + std::filesystem::path{base.substr(slash + 1)}.parent_path(); + return prefix + (path / requested).lexically_normal().generic_string(); + } + + if (base.rfind("file://", 0) == 0) + { + const auto path = std::filesystem::path{base.substr(7)}.parent_path() / requested; + return "file://" + path.lexically_normal().generic_string(); + } + + if (base.rfind("data:", 0) == 0) + { + throw std::runtime_error{"A relative importScripts URL cannot be resolved from a data URL"}; + } + + std::filesystem::path parent = root; + if (!base.empty() && !HasScheme(base)) + { + parent = std::filesystem::path{base}.parent_path(); + } + return (parent / requested).lexically_normal().string(); + } + + std::string ReadFile(const std::filesystem::path& path) + { + std::ifstream stream{path, std::ios::binary}; + if (!stream) + { + throw std::runtime_error{"Unable to load Worker script: " + path.string()}; + } + return {std::istreambuf_iterator{stream}, std::istreambuf_iterator{}}; + } + + std::filesystem::path ResolveWithinRoot(const std::string& root, + const std::filesystem::path& candidate) + { + const auto configuredRoot = root.empty() ? std::filesystem::current_path() : + std::filesystem::path{root}; + const auto rootPath = std::filesystem::weakly_canonical( + std::filesystem::absolute(configuredRoot)); + const auto candidatePath = std::filesystem::weakly_canonical( + std::filesystem::absolute(candidate)); + + auto rootPart = rootPath.begin(); + auto candidatePart = candidatePath.begin(); + for (; rootPart != rootPath.end(); ++rootPart, ++candidatePart) + { + if (candidatePart == candidatePath.end() || *candidatePart != *rootPart) + { + throw std::runtime_error{"Worker script path escapes ScriptRoot: " + candidate.string()}; + } + } + + return candidatePath; + } + + std::string LoadSource(const Options& options, const std::string& url) + { + if (options.ScriptResolver) + { + return options.ScriptResolver(url); + } + + if (url.rfind("data:", 0) == 0) + { + const auto comma = url.find(','); + if (comma == std::string::npos || url.substr(0, comma).find(";base64") != std::string::npos) + { + throw std::runtime_error{"Only percent-encoded JavaScript data URLs are supported"}; + } + return PercentDecode(url.substr(comma + 1)); + } + + if (url.rfind("app://", 0) == 0) + { + const auto pathStart = url.find('/', 6); + const auto relative = pathStart == std::string::npos ? std::string{} : url.substr(pathStart + 1); + return ReadFile(ResolveWithinRoot( + options.ScriptRoot, std::filesystem::path{options.ScriptRoot} / relative)); + } + + if (url.rfind("file://", 0) == 0) + { + return ReadFile(PercentDecode(url.substr(7))); + } + + return ReadFile(ResolveWithinRoot(options.ScriptRoot, url)); + } + +#if NAPI_VERSION >= 7 + void ThrowStatus(Napi::Env env, napi_status status, const char* operation) + { + if (status == napi_pending_exception && env.IsExceptionPending()) + { + throw env.GetAndClearPendingException(); + } + throw Napi::Error::New(env, std::string{operation} + " failed with Node-API status " + + std::to_string(static_cast(status))); + } + + [[noreturn]] void ThrowDataCloneError(Napi::Env env, const char* message) + { + const auto exception = env.Global() + .Get("DOMException") + .As() + .New({Napi::String::New(env, message), + Napi::String::New(env, "DataCloneError")}); + throw Napi::Error{env, exception}; + } +#endif + } + + struct Worker::State + { + Options Config{}; + JsRuntime* ParentRuntime{}; + Napi::ObjectReference ParentObject{}; + std::unique_ptr Runtime{}; + std::atomic_bool Terminated{false}; + std::atomic_bool Closed{false}; + std::string ActiveUrl{}; + std::string Name{}; + bool Module{}; + std::mutex RuntimeMutex{}; + }; + + void Worker::Initialize(Napi::Env env, Options options) + { + if (!env.Global().Get("Worker").IsUndefined()) + { + return; + } + + Napi::Eval(env, WorkerScripts::Common, "jsruntimehost-worker-common.js"); + + auto* classOptions = new Options{std::move(options)}; + auto constructor = DefineClass( + env, + "Worker", + { + InstanceMethod("__jsrhNativePostMessage", &Worker::PostMessage), + InstanceMethod("terminate", &Worker::Terminate), + }, + classOptions); + + // Keep constructor data alive for exactly as long as the constructor. + constructor.Set( + "__jsrhOptions", + Napi::External::New(env, classOptions, [](Napi::Env, Options* value) { delete value; })); + + env.Global().Get("__jsrhInstallWorker").As().Call(env.Global(), {constructor}); + env.Global().Set("Worker", constructor); + } + + Worker::Worker(const Napi::CallbackInfo& info) + : Napi::ObjectWrap{info} + { + if (info.Length() == 0) + { + throw Napi::TypeError::New(info.Env(), "Worker requires a script URL"); + } + + auto state = std::make_shared(); + state->Config = *static_cast(info.Data()); + state->ParentRuntime = &JsRuntime::GetFromJavaScript(info.Env()); + // An active Worker is a browser "active object": it remains alive even + // if script drops its last reference, until terminate()/close(). A + // strong reference also works on engines such as QuickJS whose N-API + // weak-reference adapter cannot materialize a live weak value. + state->ParentObject = Napi::Persistent(info.This().As()); + + const auto requestedUrl = info[0].ToString().Utf8Value(); + const auto resolvedUrl = ResolveUrl(state->Config.ScriptRoot, {}, requestedUrl); + bool module = false; + if (info.Length() > 1 && info[1].IsObject()) + { + const auto options = info[1].As(); + if (options.Has("type")) + { + const auto type = options.Get("type").ToString().Utf8Value(); + if (type != "classic" && type != "module") + { + throw Napi::TypeError::New(info.Env(), "Worker type must be 'classic' or 'module'"); + } + module = type == "module"; + } + if (options.Has("name")) + { + state->Name = options.Get("name").ToString().Utf8Value(); + } + } + state->Module = module; + + AppRuntime::Options runtimeOptions{}; + const std::weak_ptr weakState{state}; + runtimeOptions.UnhandledExceptionHandler = [weakState](const Napi::Error& error) { + const auto locked = weakState.lock(); + if (!locked || locked->Terminated.load()) + { + return; + } + DispatchErrorToParent(weakState, Napi::GetErrorString(error)); + }; + runtimeOptions.ThreadExitHandler = [weakState] { + const auto locked = weakState.lock(); + if (!locked) + { + return; + } + + // The Worker wrapper is a parent-realm JS object. Never release + // its strong reference from the worker thread: WebKit fixed this + // exact cross-thread destruction pattern after a terminate UAF. + // Queue this after all same-task message/error deliveries so + // WorkerGlobalScope.close() preserves their FIFO ordering. + // https://github.com/WebKit/WebKit/commit/4aaa3c1477e296e67b03e1461479b8caf57c37dd + locked->ParentRuntime->Dispatch([weakState](Napi::Env) { + const auto parentState = weakState.lock(); + if (parentState && !parentState->ParentObject.IsEmpty()) + { + parentState->ParentObject.Reset(); + } + }); + }; + + state->Runtime = std::make_unique(std::move(runtimeOptions)); + state->Runtime->Dispatch([state, resolvedUrl, module](Napi::Env env) { + InitializeWorker(state, env, resolvedUrl, module); + }); + + m_state = std::move(state); + } + + Worker::~Worker() + { + Stop(); + } + + void Worker::Stop() + { + auto state = std::move(m_state); + if (!state) + { + return; + } + + state->Terminated.store(true); + state->Closed.store(true); + { + std::scoped_lock lock{state->RuntimeMutex}; + if (state->Runtime) + { + state->Runtime->Terminate(); + } + } + state->ParentObject.Reset(); + state->Runtime.reset(); + } + + void Worker::Terminate(const Napi::CallbackInfo&) + { + if (!m_state || m_state->Terminated.exchange(true)) + { + return; + } + + m_state->Closed.store(true); + std::scoped_lock lock{m_state->RuntimeMutex}; + if (m_state->Runtime) + { + m_state->Runtime->Terminate(); + } + m_state->ParentObject.Reset(); + } + + Worker::Message Worker::Serialize(Napi::Env env, + const Napi::Value& value, + const Napi::Value& transfer) + { + const auto encoded = env.Global() + .Get("__jsrhSerialize") + .As() + .Call(env.Global(), {value, transfer}) + .As(); + + Message result{}; + result.Json = encoded.Get("json").As().Utf8Value(); + const auto buffers = encoded.Get("buffers").As(); + const auto transferBuffers = encoded.Get("transferBuffers").As(); +#if NAPI_VERSION >= 7 + // Validate all transferables before copying or detaching any of them. + // Some engines do not expose detached state as a JavaScript property, + // so the Node-API check is the portable source of truth. + for (std::uint32_t i = 0; i < transferBuffers.Length(); ++i) + { + bool detached{}; + const napi_status status = napi_is_detached_arraybuffer(env, transferBuffers.Get(i), &detached); + if (status != napi_ok) + { + ThrowStatus(env, status, "napi_is_detached_arraybuffer"); + } + if (detached) + { + ThrowDataCloneError(env, "An ArrayBuffer in the transfer list is already detached"); + } + } +#endif + + result.Buffers.reserve(buffers.Length()); + for (std::uint32_t i = 0; i < buffers.Length(); ++i) + { + const auto buffer = buffers.Get(i).As(); + std::vector bytes(buffer.ByteLength()); + if (!bytes.empty()) + { + std::memcpy(bytes.data(), buffer.Data(), bytes.size()); + } + result.Buffers.emplace_back(std::move(bytes)); + } + + // Duplicate and invalid entries were rejected by the JS serializer; + // after validation and copying, detach each original transfer target. + // The native byte-copy loop above only inspects JS-side snapshots, so + // JavaScriptCore never exposes the original backing pointer before its + // standards-track transfer() implementation detaches it. + for (std::uint32_t i = 0; i < transferBuffers.Length(); ++i) + { +#if NAPI_VERSION >= 7 + const napi_status status = napi_detach_arraybuffer(env, transferBuffers.Get(i)); + if (status != napi_ok) + { + ThrowStatus(env, status, "napi_detach_arraybuffer"); + } +#else + (void)i; + throw Napi::Error::New(env, "Transferable ArrayBuffers require N-API v7"); +#endif + } + + return result; + } + + Napi::Value Worker::Deserialize(Napi::Env env, const Message& message) + { + const auto buffers = Napi::Array::New(env, message.Buffers.size()); + for (std::size_t i = 0; i < message.Buffers.size(); ++i) + { + const auto& bytes = message.Buffers[i]; + auto buffer = Napi::ArrayBuffer::New(env, bytes.size()); + if (!bytes.empty()) + { + std::memcpy(buffer.Data(), bytes.data(), bytes.size()); + } + buffers.Set(static_cast(i), buffer); + } + + return env.Global() + .Get("__jsrhDeserialize") + .As() + .Call(env.Global(), {Napi::String::New(env, message.Json), buffers}); + } + + Napi::Value Worker::PostMessage(const Napi::CallbackInfo& info) + { + if (!m_state || m_state->Terminated.load() || m_state->Closed.load()) + { + return info.Env().Undefined(); + } + + const auto envelope = info[0].As(); + const auto value = envelope.Get("__jsrhMessage"); + const auto transfer = envelope.Get("__jsrhTransfer"); + auto message = Serialize(info.Env(), value, transfer); + const std::weak_ptr weakState{m_state}; + + std::scoped_lock lock{m_state->RuntimeMutex}; + if (m_state->Runtime && !m_state->Terminated.load()) + { + m_state->Runtime->Dispatch([weakState, message = std::move(message)](Napi::Env env) mutable { + const auto state = weakState.lock(); + if (!state || state->Terminated.load() || state->Closed.load()) + { + return; + } + const auto value = Deserialize(env, message); + env.Global().Get("__jsrhDispatchMessage").As().Call( + env.Global(), {env.Global(), value}); + }); + } + + return info.Env().Undefined(); + } + + void Worker::InitializeWorker(const std::shared_ptr& state, + Napi::Env env, + const std::string& url, + bool module) + { + (void)module; + Babylon::Polyfills::Console::Initialize(env, [weakState = std::weak_ptr{state}](const char* message, + Babylon::Polyfills::Console::LogLevel) { + const auto locked = weakState.lock(); + if (locked && locked->Config.ConsoleCallback) + { + locked->Config.ConsoleCallback(message); + } + }); + Babylon::Polyfills::AbortController::Initialize(env); + Babylon::Polyfills::Performance::Initialize(env); + Babylon::Polyfills::Scheduling::Initialize(env); + Babylon::Polyfills::URL::Initialize(env); + Babylon::Polyfills::WebSocket::Initialize(env); + Babylon::Polyfills::XMLHttpRequest::Initialize(env); + Babylon::Polyfills::Fetch::Initialize(env); + Babylon::Polyfills::Blob::Initialize(env); + Babylon::Polyfills::File::Initialize(env); + Babylon::Polyfills::TextDecoder::Initialize(env); + Babylon::Polyfills::TextEncoder::Initialize(env); + + const std::weak_ptr weakState{state}; + env.Global().Set("__jsrhNativePostMessage", Napi::Function::New( + env, + [weakState](const Napi::CallbackInfo& info) { + const auto locked = weakState.lock(); + if (!locked || locked->Terminated.load()) + { + return info.Env().Undefined(); + } + const auto envelope = info[0].As(); + const auto value = envelope.Get("__jsrhMessage"); + const auto transfer = envelope.Get("__jsrhTransfer"); + DispatchMessageToParent(weakState, Serialize(info.Env(), value, transfer)); + return info.Env().Undefined(); + }, + "postMessage")); + + env.Global().Set("__jsrhNativeClose", Napi::Function::New( + env, + [weakState](const Napi::CallbackInfo& info) { + const auto locked = weakState.lock(); + if (locked && !locked->Terminated.load() && !locked->Closed.exchange(true)) + { + std::scoped_lock lock{locked->RuntimeMutex}; + if (locked->Runtime) + { + locked->Runtime->Terminate(); + } + } + return info.Env().Undefined(); + }, + "close")); + + env.Global().Set("__jsrhNativeImportScripts", Napi::Function::New( + env, + [weakState](const Napi::CallbackInfo& info) { + const auto locked = weakState.lock(); + if (!locked || locked->Terminated.load() || locked->Closed.load()) + { + return info.Env().Undefined(); + } + if (locked->Module) + { + throw Napi::TypeError::New(info.Env(), "importScripts is unavailable in a module Worker"); + } + + for (std::size_t i = 0; i < info.Length(); ++i) + { + const auto requested = info[i].ToString().Utf8Value(); + const auto resolved = ResolveUrl(locked->Config.ScriptRoot, locked->ActiveUrl, requested); + try + { + const auto source = LoadSource(locked->Config, resolved); + const auto previous = std::exchange(locked->ActiveUrl, resolved); + try + { + Napi::Eval(info.Env(), source.c_str(), resolved.c_str()); + } + catch (...) + { + locked->ActiveUrl = previous; + throw; + } + locked->ActiveUrl = previous; + } + catch (const Napi::Error&) + { + throw; + } + catch (const std::exception& error) + { + throw Napi::Error::New(info.Env(), error.what()); + } + } + return info.Env().Undefined(); + }, + "importScripts")); + + env.Global().Set("__jsrhWorkerLocation", Napi::String::New(env, url)); + env.Global().Set("__jsrhWorkerName", Napi::String::New(env, state->Name)); + Napi::Eval(env, WorkerScripts::Common, "jsruntimehost-worker-common.js"); + Napi::Eval(env, WorkerScripts::WorkerGlobal, "jsruntimehost-worker-global.js"); + + try + { + state->ActiveUrl = url; + const auto source = LoadSource(state->Config, url); + // JavaScriptCore's C API exposes script evaluation but no module + // loader. A script-compatible module bundle is already + // self-contained and can use the same isolated realm; remaining + // import/export declarations surface as a worker error. + Napi::Eval(env, source.c_str(), url.c_str()); + } + catch (const Napi::Error&) + { + throw; + } + catch (const std::exception& error) + { + throw Napi::Error::New(env, error.what()); + } + } + + void Worker::DispatchMessageToParent(const std::weak_ptr& weakState, Message message) + { + const auto state = weakState.lock(); + if (!state || state->Terminated.load()) + { + return; + } + + state->ParentRuntime->Dispatch([weakState, message = std::move(message)](Napi::Env env) mutable { + const auto locked = weakState.lock(); + if (!locked || locked->Terminated.load()) + { + return; + } + const auto target = locked->ParentObject.Value(); + if (target.IsEmpty()) + { + return; + } + const auto value = Deserialize(env, message); + env.Global().Get("__jsrhDispatchMessage").As().Call( + env.Global(), {target, value}); + }); + } + + void Worker::DispatchErrorToParent(const std::weak_ptr& weakState, std::string message) + { + const auto state = weakState.lock(); + if (!state || state->Terminated.load()) + { + return; + } + + state->ParentRuntime->Dispatch([weakState, message = std::move(message)](Napi::Env env) { + const auto locked = weakState.lock(); + if (!locked || locked->Terminated.load()) + { + return; + } + const auto target = locked->ParentObject.Value(); + if (!target.IsEmpty()) + { + env.Global().Get("__jsrhDispatchError").As().Call( + env.Global(), {target, Napi::String::New(env, message)}); + } + }); + } +} + +namespace Babylon::Polyfills::Worker +{ + void BABYLON_API Initialize(Napi::Env env, Options options) + { + Internal::Worker::Initialize(env, std::move(options)); + } +} diff --git a/Polyfills/Worker/Source/Worker.h b/Polyfills/Worker/Source/Worker.h new file mode 100644 index 00000000..ff76eab7 --- /dev/null +++ b/Polyfills/Worker/Source/Worker.h @@ -0,0 +1,45 @@ +#pragma once + +#include +#include + +#include +#include +#include +#include + +namespace Babylon::Polyfills::Internal +{ + class Worker final : public Napi::ObjectWrap + { + public: + static void Initialize(Napi::Env env, Babylon::Polyfills::Worker::Options options); + + explicit Worker(const Napi::CallbackInfo& info); + ~Worker() override; + + private: + struct Message + { + std::string Json; + std::vector> Buffers; + }; + + struct State; + + Napi::Value PostMessage(const Napi::CallbackInfo& info); + void Terminate(const Napi::CallbackInfo& info); + void Stop(); + + static Message Serialize(Napi::Env env, const Napi::Value& value, const Napi::Value& transfer); + static Napi::Value Deserialize(Napi::Env env, const Message& message); + static void InitializeWorker(const std::shared_ptr& state, + Napi::Env env, + const std::string& url, + bool module); + static void DispatchMessageToParent(const std::weak_ptr& state, Message message); + static void DispatchErrorToParent(const std::weak_ptr& state, std::string message); + + std::shared_ptr m_state{}; + }; +} diff --git a/Polyfills/Worker/Source/WorkerScripts.h b/Polyfills/Worker/Source/WorkerScripts.h new file mode 100644 index 00000000..49cbfbf0 --- /dev/null +++ b/Polyfills/Worker/Source/WorkerScripts.h @@ -0,0 +1,470 @@ +#pragma once + +namespace Babylon::Polyfills::Internal::WorkerScripts +{ + inline constexpr char Common[] = R"JSRH( +(() => { + 'use strict'; + const g = globalThis; + if (g.__jsrhWorkerCommonInstalled) return; + + const listeners = new WeakMap(); + const handlers = new WeakMap(); + + class DOMException extends Error { + constructor(message = '', name = 'Error') { + super(String(message)); + this.name = String(name); + const codes = { IndexSizeError: 1, HierarchyRequestError: 3, + WrongDocumentError: 4, InvalidCharacterError: 5, + NoModificationAllowedError: 7, NotFoundError: 8, + NotSupportedError: 9, InUseAttributeError: 10, + InvalidStateError: 11, SyntaxError: 12, InvalidModificationError: 13, + NamespaceError: 14, InvalidAccessError: 15, TypeMismatchError: 17, + SecurityError: 18, NetworkError: 19, AbortError: 20, + URLMismatchError: 21, QuotaExceededError: 22, TimeoutError: 23, + InvalidNodeTypeError: 24, DataCloneError: 25 }; + Object.defineProperty(this, 'code', { + value: codes[this.name] || 0, enumerable: true + }); + } + } + + class Event { + constructor(type, init = {}) { + if (arguments.length === 0) throw new TypeError('Event type is required'); + this._type = String(type); + this._bubbles = Boolean(init.bubbles); + this._cancelable = Boolean(init.cancelable); + this._composed = Boolean(init.composed); + this._target = null; + this._currentTarget = null; + this._defaultPrevented = false; + this._stopped = false; + this._immediateStopped = false; + this._timeStamp = Date.now(); + } + get type() { return this._type; } + get target() { return this._target; } + get srcElement() { return this._target; } + get currentTarget() { return this._currentTarget; } + get eventPhase() { return this._currentTarget === null ? 0 : 2; } + get bubbles() { return this._bubbles; } + get cancelable() { return this._cancelable; } + get composed() { return this._composed; } + get defaultPrevented() { return this._defaultPrevented; } + get timeStamp() { return this._timeStamp; } + get isTrusted() { return false; } + preventDefault() { if (this._cancelable) this._defaultPrevented = true; } + stopPropagation() { this._stopped = true; } + stopImmediatePropagation() { + this._stopped = true; + this._immediateStopped = true; + } + composedPath() { return this._target === null ? [] : [this._target]; } + } + Event.NONE = 0; + Event.CAPTURING_PHASE = 1; + Event.AT_TARGET = 2; + Event.BUBBLING_PHASE = 3; + + class MessageEvent extends Event { + constructor(type, init = {}) { + super(type, init); + this.data = init.data === undefined ? null : init.data; + this.origin = init.origin === undefined ? '' : String(init.origin); + this.lastEventId = init.lastEventId === undefined ? '' : String(init.lastEventId); + this.source = init.source === undefined ? null : init.source; + this.ports = init.ports === undefined ? [] : Array.from(init.ports); + } + } + + class ErrorEvent extends Event { + constructor(type, init = {}) { + super(type, Object.assign({ cancelable: true }, init)); + this.message = init.message === undefined ? '' : String(init.message); + this.filename = init.filename === undefined ? '' : String(init.filename); + this.lineno = Number(init.lineno || 0); + this.colno = Number(init.colno || 0); + this.error = init.error === undefined ? null : init.error; + } + } + + function optionCapture(options) { + return typeof options === 'boolean' ? options : Boolean(options && options.capture); + } + + class EventTarget { + addEventListener(type, callback, options = false) { + if (callback === null || callback === undefined) return; + if (typeof callback !== 'function' && + (typeof callback !== 'object' || typeof callback.handleEvent !== 'function')) return; + type = String(type); + let byType = listeners.get(this); + if (!byType) listeners.set(this, byType = new Map()); + let list = byType.get(type); + if (!list) byType.set(type, list = []); + const capture = optionCapture(options); + if (list.some(x => x.callback === callback && x.capture === capture)) return; + const entry = { callback, capture, once: Boolean(options && options.once) }; + list.push(entry); + if (options && options.signal) { + if (options.signal.aborted) { + list.splice(list.indexOf(entry), 1); + } else if (typeof options.signal.addEventListener === 'function') { + options.signal.addEventListener('abort', () => { + this.removeEventListener(type, callback, capture); + }, { once: true }); + } + } + } + + removeEventListener(type, callback, options = false) { + const byType = listeners.get(this); + const list = byType && byType.get(String(type)); + if (!list) return; + const capture = optionCapture(options); + const index = list.findIndex(x => x.callback === callback && x.capture === capture); + if (index !== -1) list.splice(index, 1); + } + + dispatchEvent(event) { + if (!(event instanceof Event)) throw new TypeError('Argument 1 is not an Event'); + if (event._currentTarget !== null) throw new DOMException('Event is already being dispatched', 'InvalidStateError'); + event._target = this; + event._currentTarget = this; + event._immediateStopped = false; + const byType = listeners.get(this); + const snapshot = byType && byType.get(event.type) ? byType.get(event.type).slice() : []; + for (const entry of snapshot) { + if (event._immediateStopped) break; + const current = byType && byType.get(event.type); + if (!current || current.indexOf(entry) === -1) continue; + if (entry.once) this.removeEventListener(event.type, entry.callback, entry.capture); + if (typeof entry.callback === 'function') entry.callback.call(this, event); + else entry.callback.handleEvent.call(entry.callback, event); + } + if (!event._immediateStopped) { + const byTypeHandler = handlers.get(this); + const handler = byTypeHandler && byTypeHandler.get(event.type); + // EventHandler attributes retain arbitrary objects, but only callable + // values are invoked (matching Web IDL's EventHandler processing). + if (typeof handler === 'function') handler.call(this, event); + } + event._currentTarget = null; + return !event.defaultPrevented; + } + } + + function installHandler(target, type) { + Object.defineProperty(target, 'on' + type, { + configurable: true, + enumerable: true, + get() { + const byType = handlers.get(this); + return byType && byType.has(type) ? byType.get(type) : null; + }, + set(value) { + let byType = handlers.get(this); + if (!byType) handlers.set(this, byType = new Map()); + if ((typeof value === 'object' && value !== null) || typeof value === 'function') { + byType.set(type, value); + } else { + byType.delete(type); + } + } + }); + } + + function dataCloneError(message) { + return new DOMException(message, 'DataCloneError'); + } + + function normalizeTransfers(argument) { + if (argument === undefined || argument === null) return []; + const value = Array.isArray(argument) ? argument : argument.transfer; + if (value === undefined || value === null) return []; + try { return Array.from(value); } + catch (_) { throw new TypeError('transfer must be an iterable'); } + } + + function serialize(root, transferArgument) { + const transferList = normalizeTransfers(transferArgument); + const buffers = []; + const bufferIndexes = new Map(); + const transferSet = new Set(); + + function addBuffer(buffer) { + let index = bufferIndexes.get(buffer); + if (index === undefined) { + index = buffers.length; + bufferIndexes.set(buffer, index); + buffers.push(buffer); + } + return index; + } + + for (const value of transferList) { + if (!(value instanceof ArrayBuffer)) throw dataCloneError('Only ArrayBuffer transfer is supported'); + if (transferSet.has(value)) throw dataCloneError('Transfer list contains a duplicate ArrayBuffer'); + if (value.detached === true) throw dataCloneError('A detached ArrayBuffer cannot be transferred'); + transferSet.add(value); + addBuffer(value); + } + + const seen = new Map(); + const nodes = []; + const ref = id => ['r', id]; + const ownProperties = (value, skip) => { + const result = []; + for (const key of Object.keys(value)) { + if (!skip || !skip(key)) result.push([key, encode(value[key])]); + } + return result; + }; + + function encode(value) { + if (value === null || typeof value === 'string' || typeof value === 'boolean') return value; + if (value === undefined) return ['u']; + if (typeof value === 'number') { + if (Number.isNaN(value)) return ['n', 'nan']; + if (value === Infinity) return ['n', 'inf']; + if (value === -Infinity) return ['n', '-inf']; + if (Object.is(value, -0)) return ['n', '-0']; + return value; + } + if (typeof value === 'bigint') return ['bi', value.toString()]; + if (typeof value === 'symbol' || typeof value === 'function') { + throw dataCloneError('The value could not be cloned'); + } + if (typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer) { + throw dataCloneError('SharedArrayBuffer is not available across native runtimes'); + } + if (seen.has(value)) return ref(seen.get(value)); + + const id = nodes.length; + seen.set(value, id); + nodes.push(null); + + if (value instanceof ArrayBuffer) { + nodes[id] = { t: 'ab', b: addBuffer(value) }; + } else if (ArrayBuffer.isView(value)) { + if (value instanceof DataView) { + nodes[id] = { t: 'dv', b: encode(value.buffer), o: value.byteOffset, l: value.byteLength }; + } else { + nodes[id] = { t: 'ta', c: value.constructor.name, b: encode(value.buffer), + o: value.byteOffset, l: value.length }; + } + } else if (Array.isArray(value)) { + const items = []; + for (let i = 0; i < value.length; ++i) { + items.push(Object.prototype.hasOwnProperty.call(value, i) ? encode(value[i]) : ['h']); + } + nodes[id] = { t: 'a', i: items, + p: ownProperties(value, key => key === 'length' || /^(0|[1-9][0-9]*)$/.test(key)) }; + } else if (value instanceof Date) { + nodes[id] = { t: 'd', v: value.getTime(), p: ownProperties(value) }; + } else if (value instanceof RegExp) { + nodes[id] = { t: 're', s: value.source, f: value.flags, x: value.lastIndex, + p: ownProperties(value) }; + } else if (value instanceof Map) { + nodes[id] = { t: 'm', e: Array.from(value, pair => [encode(pair[0]), encode(pair[1])]), + p: ownProperties(value) }; + } else if (value instanceof Set) { + nodes[id] = { t: 's', e: Array.from(value, encode), p: ownProperties(value) }; + } else if (value instanceof Error) { + nodes[id] = { t: 'e', n: value.name, m: value.message, s: value.stack || '', + p: ownProperties(value, key => key === 'name' || key === 'message' || key === 'stack') }; + } else if (value instanceof WeakMap || value instanceof WeakSet || value instanceof Promise) { + throw dataCloneError('The value could not be cloned'); + } else { + nodes[id] = { t: 'o', z: Object.getPrototypeOf(value) === null, p: ownProperties(value) }; + } + return ref(id); + } + + // Keep the buffers used for native byte extraction distinct from the + // transfer targets. In JavaScriptCore, exposing a source buffer's backing + // pointer through the public C API before ArrayBuffer.prototype.transfer() + // can prevent the original JS wrapper from observing the detach. Slicing + // first also makes the required copy-before-detach ordering explicit for + // every backend. + return { + json: JSON.stringify({ root: encode(root), nodes }), + buffers: buffers.map(buffer => buffer.slice(0)), + transferBuffers: transferList + }; + } + + function deserialize(json, buffers) { + const graph = JSON.parse(json); + const nodes = graph.nodes; + const values = new Array(nodes.length); + const built = new Array(nodes.length).fill(false); + + function decode(value) { + if (!Array.isArray(value)) return value; + switch (value[0]) { + case 'u': return undefined; + case 'h': return undefined; + case 'n': return value[1] === 'nan' ? NaN : value[1] === 'inf' ? Infinity : + value[1] === '-inf' ? -Infinity : -0; + case 'bi': return BigInt(value[1]); + case 'r': return build(value[1]); + default: throw dataCloneError('Invalid native structured-clone record'); + } + } + + function properties(target, entries) { + for (const [key, value] of entries || []) { + Object.defineProperty(target, key, { + value: decode(value), writable: true, enumerable: true, configurable: true + }); + } + } + + function build(id) { + if (built[id]) return values[id]; + const node = nodes[id]; + if (!node) throw dataCloneError('Invalid native structured-clone node'); + let value; + switch (node.t) { + case 'a': value = []; break; + case 'o': value = node.z ? Object.create(null) : {}; break; + case 'd': value = new Date(node.v); break; + case 're': value = new RegExp(node.s, node.f); value.lastIndex = node.x; break; + case 'm': value = new Map(); break; + case 's': value = new Set(); break; + case 'e': value = new Error(node.m); value.name = node.n; value.stack = node.s; break; + case 'ab': value = buffers[node.b]; break; + case 'dv': value = new DataView(decode(node.b), node.o, node.l); break; + case 'ta': { + const Constructor = g[node.c]; + if (typeof Constructor !== 'function') throw dataCloneError('Unknown TypedArray ' + node.c); + value = new Constructor(decode(node.b), node.o, node.l); + break; + } + default: throw dataCloneError('Unknown native structured-clone type'); + } + values[id] = value; + built[id] = true; + if (node.t === 'a') { + value.length = node.i.length; + node.i.forEach((item, index) => { if (!(Array.isArray(item) && item[0] === 'h')) value[index] = decode(item); }); + } else if (node.t === 'm') { + for (const pair of node.e) value.set(decode(pair[0]), decode(pair[1])); + } else if (node.t === 's') { + for (const entry of node.e) value.add(decode(entry)); + } + properties(value, node.p); + return value; + } + + return decode(graph.root); + } + + function dispatchMessage(target, value) { + target.dispatchEvent(new MessageEvent('message', { data: value })); + } + + function dispatchError(target, message) { + const error = new Error(String(message)); + target.dispatchEvent(new ErrorEvent('error', { message: String(message), error })); + } + + function installWorker(Constructor) { + const nativePostMessage = Constructor.prototype.__jsrhNativePostMessage; + Object.defineProperty(Constructor.prototype, 'postMessage', { + configurable: true, + writable: true, + value(message, transfer) { + return nativePostMessage.call(this, { + __jsrhMessage: message, + __jsrhTransfer: transfer + }); + } + }); + Object.setPrototypeOf(Constructor.prototype, EventTarget.prototype); + installHandler(Constructor.prototype, 'message'); + installHandler(Constructor.prototype, 'messageerror'); + installHandler(Constructor.prototype, 'error'); + Object.defineProperty(Constructor.prototype, Symbol.toStringTag, + { value: 'Worker', configurable: true }); + } + + Object.defineProperties(g, { + EventTarget: { value: EventTarget, writable: true, configurable: true }, + Event: { value: Event, writable: true, configurable: true }, + MessageEvent: { value: MessageEvent, writable: true, configurable: true }, + ErrorEvent: { value: ErrorEvent, writable: true, configurable: true }, + DOMException: { value: DOMException, writable: true, configurable: true }, + __jsrhInstallHandler: { value: installHandler }, + __jsrhInstallWorker: { value: installWorker }, + __jsrhSerialize: { value: serialize }, + __jsrhDeserialize: { value: deserialize }, + __jsrhDispatchMessage: { value: dispatchMessage }, + __jsrhDispatchError: { value: dispatchError }, + __jsrhWorkerCommonInstalled: { value: true } + }); +})(); +)JSRH"; + + inline constexpr char WorkerGlobal[] = R"JSRH( +(() => { + 'use strict'; + const g = globalThis; + + class WorkerGlobalScope extends EventTarget {} + class DedicatedWorkerGlobalScope extends WorkerGlobalScope {} + __jsrhInstallHandler(WorkerGlobalScope.prototype, 'message'); + __jsrhInstallHandler(WorkerGlobalScope.prototype, 'messageerror'); + __jsrhInstallHandler(WorkerGlobalScope.prototype, 'error'); + Object.defineProperty(WorkerGlobalScope.prototype, Symbol.toStringTag, + { value: 'WorkerGlobalScope', configurable: true }); + Object.defineProperty(DedicatedWorkerGlobalScope.prototype, Symbol.toStringTag, + { value: 'DedicatedWorkerGlobalScope', configurable: true }); + + try { delete g.window; } catch (_) { g.window = undefined; } + try { + Object.setPrototypeOf(g, DedicatedWorkerGlobalScope.prototype); + } catch (_) { + // JavaScriptCore's global object has an immutable prototype. Preserve its + // engine-owned prototype and provide the observable worker-global shape + // through own accessors plus @@hasInstance instead. + Object.defineProperty(WorkerGlobalScope, Symbol.hasInstance, { + configurable: true, + value(instance) { + return instance === g || Function.prototype[Symbol.hasInstance].call(this, instance); + } + }); + } + __jsrhInstallHandler(g, 'message'); + __jsrhInstallHandler(g, 'messageerror'); + __jsrhInstallHandler(g, 'error'); + + Object.defineProperties(g, { + WorkerGlobalScope: { value: WorkerGlobalScope, writable: true, configurable: true }, + DedicatedWorkerGlobalScope: { value: DedicatedWorkerGlobalScope, writable: true, configurable: true }, + self: { value: g, writable: false, enumerable: true, configurable: false }, + location: { value: Object.freeze({ href: String(g.__jsrhWorkerLocation || '') }), + writable: false, enumerable: true, configurable: false }, + name: { value: String(g.__jsrhWorkerName || ''), writable: false, configurable: true }, + navigator: { value: Object.freeze({ hardwareConcurrency: 1, language: 'en-US', languages: ['en-US'] }), + writable: false, configurable: true }, + addEventListener: { value: EventTarget.prototype.addEventListener.bind(g), + writable: true, configurable: true }, + removeEventListener: { value: EventTarget.prototype.removeEventListener.bind(g), + writable: true, configurable: true }, + dispatchEvent: { value: EventTarget.prototype.dispatchEvent.bind(g), + writable: true, configurable: true }, + postMessage: { value(message, transfer) { g.__jsrhNativePostMessage({ + __jsrhMessage: message, __jsrhTransfer: transfer + }); }, + writable: true, configurable: true }, + close: { value() { g.__jsrhNativeClose(); }, writable: true, configurable: true }, + importScripts: { value(...urls) { return g.__jsrhNativeImportScripts(...urls); }, + writable: true, configurable: true } + }); +})(); +)JSRH"; +} diff --git a/Tests/UnitTests/CMakeLists.txt b/Tests/UnitTests/CMakeLists.txt index 76cc1fa4..383986c5 100644 --- a/Tests/UnitTests/CMakeLists.txt +++ b/Tests/UnitTests/CMakeLists.txt @@ -89,11 +89,24 @@ target_link_libraries(UnitTests PRIVATE Compression ${ADDITIONAL_LIBRARIES}) +if(TARGET Worker) + target_link_libraries(UnitTests PRIVATE Worker) + target_compile_definitions(UnitTests PRIVATE JSRUNTIMEHOST_TEST_WORKER=1) +endif() + # See https://gitlab.kitware.com/cmake/cmake/-/issues/23543 # If we can set minimum required to 3.26+, then we can use the `copy -t` syntax instead. add_custom_command(TARGET UnitTests POST_BUILD COMMAND ${CMAKE_COMMAND} -E $>,copy,true> $ $ COMMAND_EXPAND_LISTS) +if(TARGET Worker) + add_custom_command(TARGET UnitTests POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + "${CMAKE_CURRENT_SOURCE_DIR}/WebPlatformTests" + "$/WebPlatformTests" + COMMENT "Copying pinned Web Platform Tests Worker subset") +endif() + if(APPLE) enable_objc_arc(UnitTests) endif() diff --git a/Tests/UnitTests/Shared/Shared.cpp b/Tests/UnitTests/Shared/Shared.cpp index 876b0da6..22a18b47 100644 --- a/Tests/UnitTests/Shared/Shared.cpp +++ b/Tests/UnitTests/Shared/Shared.cpp @@ -16,11 +16,18 @@ #include #include #include +#include +#include +#include +#if defined(JSRUNTIMEHOST_TEST_WORKER) +#include +#endif #include #include #include #include #include +#include #include #include #include @@ -34,7 +41,6 @@ #include #include #include -#include #include #include @@ -283,6 +289,12 @@ TEST(JavaScript, All) Babylon::Polyfills::Compression::Initialize(env); Babylon::Polyfills::Fetch::Initialize(env); +#if defined(JSRUNTIMEHOST_TEST_WORKER) + Babylon::Polyfills::Worker::Options workerOptions{}; + workerOptions.ScriptRoot = std::filesystem::current_path().string(); + Babylon::Polyfills::Worker::Initialize(env, std::move(workerOptions)); +#endif + auto setExitCodeCallback = Napi::Function::New( env, [&exitCodePromise](const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); @@ -813,6 +825,161 @@ TEST(NodeApi, DetachArrayBufferOrReportsUnsupported) } #endif +#if defined(JSRUNTIMEHOST_NAPI_ENGINE_V8) +TEST(AppRuntime, V8FinalizersDrainAfterDispatch) +{ + constexpr size_t ExternalCount{32}; + std::atomic finalized{}; + std::promise created; + std::promise collectionRequested; + std::promise observed; + + Babylon::AppRuntime runtime{}; + runtime.Dispatch([&finalized, &created](Napi::Env env) { + for (size_t index{}; index < ExternalCount; ++index) + { + Napi::External>::New( + env, + &finalized, + [](Napi::Env, std::atomic* count) { + count->fetch_add(1, std::memory_order_relaxed); + }); + } + created.set_value(); + }); + created.get_future().wait(); + + runtime.Dispatch([&collectionRequested](Napi::Env env) { + Napi::GetContext(env)->GetIsolate()->LowMemoryNotification(); + collectionRequested.set_value(); + }); + collectionRequested.get_future().wait(); + + runtime.Dispatch([&finalized, &observed](Napi::Env) { + observed.set_value(finalized.load(std::memory_order_relaxed)); + }); + + EXPECT_EQ(observed.get_future().get(), ExternalCount); +} + +TEST(AppRuntime, V8FinalizerDrainYieldsBetweenDispatcherTurns) +{ + constexpr size_t ExternalCount{16}; + std::atomic finalized{}; + std::promise created; + std::promise collectionRequested; + + Babylon::AppRuntime runtime{}; + runtime.Dispatch([&](Napi::Env env) { + for (size_t index{}; index < ExternalCount; ++index) + { + Napi::External>::New( + env, + &finalized, + [](Napi::Env, std::atomic* count) { + std::this_thread::sleep_for(std::chrono::milliseconds{2}); + count->fetch_add(1, std::memory_order_relaxed); + }); + } + created.set_value(); + }); + created.get_future().wait(); + + runtime.Dispatch([&](Napi::Env env) { + Napi::GetContext(env)->GetIsolate()->LowMemoryNotification(); + collectionRequested.set_value(); + }); + collectionRequested.get_future().wait(); + + const auto observeFinalized = [&]() { + std::promise observed; + auto future = observed.get_future(); + runtime.Dispatch([&](Napi::Env) { + observed.set_value(finalized.load(std::memory_order_relaxed)); + }); + return future.get(); + }; + + auto observed = observeFinalized(); + EXPECT_GT(observed, 0u); + EXPECT_LT(observed, ExternalCount); + + for (size_t turn{}; turn < ExternalCount && observed < ExternalCount; ++turn) + { + observed = observeFinalized(); + } + EXPECT_EQ(observed, ExternalCount); +} +#endif + +#if defined(JSRUNTIMEHOST_TEST_WORKER) && !defined(__ANDROID__) && \ + (defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) || defined(JSR_NAPI_ENGINE_QUICKJS) || \ + defined(JSR_NAPI_ENGINE_V8) || defined(JSR_NAPI_ENGINE_HERMES)) +TEST(Worker, WebPlatformTests) +{ + struct Result + { + bool Passed{}; + std::string Detail{}; + }; + + std::promise completion; + std::atomic_bool completed{false}; + + Babylon::AppRuntime::Options runtimeOptions{}; + runtimeOptions.UnhandledExceptionHandler = [&completion, &completed](const Napi::Error& error) { + if (!completed.exchange(true)) + { + completion.set_value({false, Napi::GetErrorString(error)}); + } + }; + + Babylon::AppRuntime runtime{std::move(runtimeOptions)}; + runtime.Dispatch([&completion, &completed](Napi::Env env) { + Babylon::Polyfills::Scheduling::Initialize(env); + + Babylon::Polyfills::Worker::Options options{}; + options.ScriptRoot = (std::filesystem::current_path() / "WebPlatformTests").string(); + options.ConsoleCallback = [](const char* message) { + std::cerr << "[Worker] " << message << std::endl; + }; + Babylon::Polyfills::Worker::Initialize(env, std::move(options)); + +#if defined(JSR_NAPI_ENGINE_JAVASCRIPTCORE) + // System JSC exposes the execution-time-limit hook used to interrupt + // a worker stuck in top-level evaluation. Other adapters currently + // terminate cooperatively between dispatches, so the infinite-loop + // WPT regression is intentionally JSC-only for now. + env.Global().Set("__jsrhCanInterruptWorker", Napi::Boolean::New(env, true)); +#else + env.Global().Set("__jsrhCanInterruptWorker", Napi::Boolean::New(env, false)); +#endif + + env.Global().Set("__jsrhWptDone", Napi::Function::New( + env, + [&completion, &completed](const Napi::CallbackInfo& info) { + if (!completed.exchange(true)) + { + completion.set_value({ + info[0].ToBoolean().Value(), + info[1].ToString().Utf8Value(), + }); + } + }, + "__jsrhWptDone")); + }); + + Babylon::ScriptLoader loader{runtime}; + loader.LoadScript("app:///WebPlatformTests/runner.js"); + + auto future = completion.get_future(); + ASSERT_EQ(future.wait_for(std::chrono::seconds{90}), std::future_status::ready) + << "Worker WPT subset timed out"; + const auto result = future.get(); + EXPECT_TRUE(result.Passed) << result.Detail; +} +#endif + // The V8JSI Node-API shim does not implement napi_create_dataview / // napi_get_dataview_info (its DataView::New throws "TODO"), so this native test // only builds on the Chakra, V8, and JavaScriptCore backends. The size_t-width diff --git a/Tests/UnitTests/WebPlatformTests/LICENSE.md b/Tests/UnitTests/WebPlatformTests/LICENSE.md new file mode 100644 index 00000000..39c46d03 --- /dev/null +++ b/Tests/UnitTests/WebPlatformTests/LICENSE.md @@ -0,0 +1,11 @@ +# The 3-Clause BSD License + +Copyright © web-platform-tests contributors + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Tests/UnitTests/WebPlatformTests/README.md b/Tests/UnitTests/WebPlatformTests/README.md new file mode 100644 index 00000000..a8e490e4 --- /dev/null +++ b/Tests/UnitTests/WebPlatformTests/README.md @@ -0,0 +1,35 @@ +# Pinned Worker WPT subset + +`UPSTREAM_REVISION` records the exact +[web-platform-tests/wpt](https://github.com/web-platform-tests/wpt) commit used +for this directory. `LICENSE.md`, `resources/testharness.js`, and the files +below are copied from that revision: + +- `workers/interfaces/DedicatedWorkerGlobalScope/EventTarget.worker.js` +- `workers/interfaces/DedicatedWorkerGlobalScope/onmessage.worker.js` +- `workers/interfaces/DedicatedWorkerGlobalScope/postMessage/return-value.worker.js` +- `workers/interfaces/WorkerGlobalScope/self.any.js` +- `workers/interfaces/WorkerUtils/importScripts/001.worker.js` +- `workers/support/Worker-structure-message.js` +- `workers/constructors/Worker/terminate.js` + +`self.worker.js` is a local worker-harness wrapper for `self.any.js`. +The following focused lifecycle regressions are adapted from newer WPT and +browser-engine fixes; each source file carries its exact upstream links: + +- `workers/support/WorkerGlobalScope-close.js` checks that `close()` preserves + same-task messages/errors while discarding later tasks. +- `workers/support/Worker-early-message.js` checks the startup queue and the + complementary terminate-before-start cleanup path. +- `workers/support/Worker-run-forever.js` checks JSC interruption during + top-level evaluation, based on WPT's terminate-during-evaluation regression. +- `workers/support/Worker-termination-stress.js` repeats shutdown with an + inbound task pending, guarding the cross-thread destruction pattern fixed by + WebKit in July 2026. + +`runner.js` replaces WPT's browser document/server runner: it launches the +worker tests sequentially, consumes `testharness.js` completion records, and +adapts the document-side structured-clone, transfer, startup, close, and +termination checks to the JsRuntimeHost unit-test host. The infinite-evaluation +case runs only when the selected engine has a native execution-interrupt hook; +the rest of the subset remains cross-engine. diff --git a/Tests/UnitTests/WebPlatformTests/UPSTREAM_REVISION b/Tests/UnitTests/WebPlatformTests/UPSTREAM_REVISION new file mode 100644 index 00000000..b7616c05 --- /dev/null +++ b/Tests/UnitTests/WebPlatformTests/UPSTREAM_REVISION @@ -0,0 +1 @@ +4809b72f863e05ab1df710d3390547dd86694239 diff --git a/Tests/UnitTests/WebPlatformTests/resources/testharness.js b/Tests/UnitTests/WebPlatformTests/resources/testharness.js new file mode 100644 index 00000000..c7ce4f51 --- /dev/null +++ b/Tests/UnitTests/WebPlatformTests/resources/testharness.js @@ -0,0 +1,5207 @@ +/*global self*/ +/*jshint latedef: nofunc*/ + +/* Documentation: https://web-platform-tests.org/writing-tests/testharness-api.html + * (../docs/_writing-tests/testharness-api.md) */ + +(function (global_scope) +{ + // default timeout is 10 seconds, test can override if needed + var settings = { + output:true, + harness_timeout:{ + "normal":10000, + "long":60000 + }, + test_timeout:null, + message_events: ["start", "test_state", "result", "completion"], + debug: false, + }; + + var xhtml_ns = "http://www.w3.org/1999/xhtml"; + + /* + * TestEnvironment is an abstraction for the environment in which the test + * harness is used. Each implementation of a test environment has to provide + * the following interface: + * + * interface TestEnvironment { + * // Invoked after the global 'tests' object has been created and it's + * // safe to call add_*_callback() to register event handlers. + * void on_tests_ready(); + * + * // Invoked after setup() has been called to notify the test environment + * // of changes to the test harness properties. + * void on_new_harness_properties(object properties); + * + * // Should return a new unique default test name. + * DOMString next_default_test_name(); + * + * // Should return the test harness timeout duration in milliseconds. + * float test_timeout(); + * }; + */ + + /* + * A test environment with a DOM. The global object is 'window'. By default + * test results are displayed in a table. Any parent windows receive + * callbacks or messages via postMessage() when test events occur. See + * apisample11.html and apisample12.html. + */ + function WindowTestEnvironment() { + this.name_counter = 0; + this.window_cache = null; + this.output_handler = null; + this.all_loaded = false; + var this_obj = this; + this.message_events = []; + this.dispatched_messages = []; + + this.message_functions = { + start: [add_start_callback, remove_start_callback, + function (properties) { + this_obj._dispatch("start_callback", [properties], + {type: "start", properties: properties}); + }], + + test_state: [add_test_state_callback, remove_test_state_callback, + function(test) { + this_obj._dispatch("test_state_callback", [test], + {type: "test_state", + test: test.structured_clone()}); + }], + result: [add_result_callback, remove_result_callback, + function (test) { + this_obj.output_handler.show_status(); + this_obj._dispatch("result_callback", [test], + {type: "result", + test: test.structured_clone()}); + }], + completion: [add_completion_callback, remove_completion_callback, + function (tests, harness_status, asserts) { + var cloned_tests = map(tests, function(test) { + return test.structured_clone(); + }); + this_obj._dispatch("completion_callback", [tests, harness_status], + {type: "complete", + tests: cloned_tests, + status: harness_status.structured_clone(), + asserts: asserts.map(assert => assert.structured_clone())}); + }] + }; + + on_event(window, 'load', function() { + setTimeout(() => { + this_obj.all_loaded = true; + if (tests.all_done()) { + tests.complete(); + } + },0); + }); + + on_event(window, 'message', function(event) { + if (event.data && event.data.type === "getmessages" && event.source) { + // A window can post "getmessages" to receive a duplicate of every + // message posted by this environment so far. This allows subscribers + // from fetch_tests_from_window to 'catch up' to the current state of + // this environment. + for (var i = 0; i < this_obj.dispatched_messages.length; ++i) + { + event.source.postMessage(this_obj.dispatched_messages[i], "*"); + } + } + }); + } + + WindowTestEnvironment.prototype._dispatch = function(selector, callback_args, message_arg) { + this.dispatched_messages.push(message_arg); + this._forEach_windows( + function(w, same_origin) { + if (same_origin) { + try { + var has_selector = selector in w; + } catch(e) { + // If document.domain was set at some point same_origin can be + // wrong and the above will fail. + has_selector = false; + } + if (has_selector) { + try { + w[selector].apply(undefined, callback_args); + } catch (e) {} + } + } + if (w !== self) { + w.postMessage(message_arg, "*"); + } + }); + }; + + WindowTestEnvironment.prototype._forEach_windows = function(callback) { + // Iterate over the windows [self ... top, opener]. The callback is passed + // two objects, the first one is the window object itself, the second one + // is a boolean indicating whether or not it's on the same origin as the + // current window. + var cache = this.window_cache; + if (!cache) { + cache = [[self, true]]; + var w = self; + var i = 0; + var so; + while (w != w.parent) { + w = w.parent; + so = is_same_origin(w); + cache.push([w, so]); + i++; + } + w = window.opener; + if (w) { + cache.push([w, is_same_origin(w)]); + } + this.window_cache = cache; + } + + forEach(cache, + function(a) { + callback.apply(null, a); + }); + }; + + WindowTestEnvironment.prototype.on_tests_ready = function() { + var output = new Output(); + this.output_handler = output; + + var this_obj = this; + + add_start_callback(function (properties) { + this_obj.output_handler.init(properties); + }); + + add_test_state_callback(function(test) { + this_obj.output_handler.show_status(); + }); + + add_result_callback(function (test) { + this_obj.output_handler.show_status(); + }); + + add_completion_callback(function (tests, harness_status, asserts_run) { + this_obj.output_handler.show_results(tests, harness_status, asserts_run); + }); + this.setup_messages(settings.message_events); + }; + + WindowTestEnvironment.prototype.setup_messages = function(new_events) { + var this_obj = this; + forEach(settings.message_events, function(x) { + var current_dispatch = this_obj.message_events.indexOf(x) !== -1; + var new_dispatch = new_events.indexOf(x) !== -1; + if (!current_dispatch && new_dispatch) { + this_obj.message_functions[x][0](this_obj.message_functions[x][2]); + } else if (current_dispatch && !new_dispatch) { + this_obj.message_functions[x][1](this_obj.message_functions[x][2]); + } + }); + this.message_events = new_events; + }; + + WindowTestEnvironment.prototype.next_default_test_name = function() { + var suffix = this.name_counter > 0 ? " " + this.name_counter : ""; + this.name_counter++; + return get_title() + suffix; + }; + + WindowTestEnvironment.prototype.on_new_harness_properties = function(properties) { + this.output_handler.setup(properties); + if (properties.hasOwnProperty("message_events")) { + this.setup_messages(properties.message_events); + } + }; + + WindowTestEnvironment.prototype.add_on_loaded_callback = function(callback) { + on_event(window, 'load', callback); + }; + + WindowTestEnvironment.prototype.test_timeout = function() { + var metas = document.getElementsByTagName("meta"); + for (var i = 0; i < metas.length; i++) { + if (metas[i].name === "timeout") { + if (metas[i].content === "long") { + return settings.harness_timeout.long; + } + break; + } + } + return settings.harness_timeout.normal; + }; + + /* + * Base TestEnvironment implementation for a generic web worker. + * + * Workers accumulate test results. One or more clients can connect and + * retrieve results from a worker at any time. + * + * WorkerTestEnvironment supports communicating with a client via a + * MessagePort. The mechanism for determining the appropriate MessagePort + * for communicating with a client depends on the type of worker and is + * implemented by the various specializations of WorkerTestEnvironment + * below. + * + * A client document using testharness can use fetch_tests_from_worker() to + * retrieve results from a worker. See apisample16.html. + */ + function WorkerTestEnvironment() { + this.name_counter = 0; + this.all_loaded = true; + this.message_list = []; + this.message_ports = []; + } + + WorkerTestEnvironment.prototype._dispatch = function(message) { + this.message_list.push(message); + for (var i = 0; i < this.message_ports.length; ++i) + { + this.message_ports[i].postMessage(message); + } + }; + + // The only requirement is that port has a postMessage() method. It doesn't + // have to be an instance of a MessagePort, and often isn't. + WorkerTestEnvironment.prototype._add_message_port = function(port) { + this.message_ports.push(port); + for (var i = 0; i < this.message_list.length; ++i) + { + port.postMessage(this.message_list[i]); + } + }; + + WorkerTestEnvironment.prototype.next_default_test_name = function() { + var suffix = this.name_counter > 0 ? " " + this.name_counter : ""; + this.name_counter++; + return get_title() + suffix; + }; + + WorkerTestEnvironment.prototype.on_new_harness_properties = function() {}; + + WorkerTestEnvironment.prototype.on_tests_ready = function() { + var this_obj = this; + add_start_callback( + function(properties) { + this_obj._dispatch({ + type: "start", + properties: properties, + }); + }); + add_test_state_callback( + function(test) { + this_obj._dispatch({ + type: "test_state", + test: test.structured_clone() + }); + }); + add_result_callback( + function(test) { + this_obj._dispatch({ + type: "result", + test: test.structured_clone() + }); + }); + add_completion_callback( + function(tests, harness_status, asserts) { + this_obj._dispatch({ + type: "complete", + tests: map(tests, + function(test) { + return test.structured_clone(); + }), + status: harness_status.structured_clone(), + asserts: asserts.map(assert => assert.structured_clone()), + }); + }); + }; + + WorkerTestEnvironment.prototype.add_on_loaded_callback = function() {}; + + WorkerTestEnvironment.prototype.test_timeout = function() { + // Tests running in a worker don't have a default timeout. I.e. all + // worker tests behave as if settings.explicit_timeout is true. + return null; + }; + + /* + * Dedicated web workers. + * https://html.spec.whatwg.org/multipage/workers.html#dedicatedworkerglobalscope + * + * This class is used as the test_environment when testharness is running + * inside a dedicated worker. + */ + function DedicatedWorkerTestEnvironment() { + WorkerTestEnvironment.call(this); + // self is an instance of DedicatedWorkerGlobalScope which exposes + // a postMessage() method for communicating via the message channel + // established when the worker is created. + this._add_message_port(self); + } + DedicatedWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype); + + DedicatedWorkerTestEnvironment.prototype.on_tests_ready = function() { + WorkerTestEnvironment.prototype.on_tests_ready.call(this); + // In the absence of an onload notification, we a require dedicated + // workers to explicitly signal when the tests are done. + tests.wait_for_finish = true; + }; + + /* + * Shared web workers. + * https://html.spec.whatwg.org/multipage/workers.html#sharedworkerglobalscope + * + * This class is used as the test_environment when testharness is running + * inside a shared web worker. + */ + function SharedWorkerTestEnvironment() { + WorkerTestEnvironment.call(this); + var this_obj = this; + // Shared workers receive message ports via the 'onconnect' event for + // each connection. + self.addEventListener("connect", + function(message_event) { + this_obj._add_message_port(message_event.source); + }, false); + } + SharedWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype); + + SharedWorkerTestEnvironment.prototype.on_tests_ready = function() { + WorkerTestEnvironment.prototype.on_tests_ready.call(this); + // In the absence of an onload notification, we a require shared + // workers to explicitly signal when the tests are done. + tests.wait_for_finish = true; + }; + + /* + * Service workers. + * http://www.w3.org/TR/service-workers/ + * + * This class is used as the test_environment when testharness is running + * inside a service worker. + */ + function ServiceWorkerTestEnvironment() { + WorkerTestEnvironment.call(this); + this.all_loaded = false; + this.on_loaded_callback = null; + var this_obj = this; + self.addEventListener("message", + function(event) { + if (event.data && event.data.type && event.data.type === "connect") { + this_obj._add_message_port(event.source); + } + }, false); + + // The oninstall event is received after the service worker script and + // all imported scripts have been fetched and executed. It's the + // equivalent of an onload event for a document. All tests should have + // been added by the time this event is received, thus it's not + // necessary to wait until the onactivate event. However, tests for + // installed service workers need another event which is equivalent to + // the onload event because oninstall is fired only on installation. The + // onmessage event is used for that purpose since tests using + // testharness.js should ask the result to its service worker by + // PostMessage. If the onmessage event is triggered on the service + // worker's context, that means the worker's script has been evaluated. + on_event(self, "install", on_all_loaded); + on_event(self, "message", on_all_loaded); + function on_all_loaded() { + if (this_obj.all_loaded) + return; + this_obj.all_loaded = true; + if (this_obj.on_loaded_callback) { + this_obj.on_loaded_callback(); + } + } + } + + ServiceWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype); + + ServiceWorkerTestEnvironment.prototype.add_on_loaded_callback = function(callback) { + if (this.all_loaded) { + callback(); + } else { + this.on_loaded_callback = callback; + } + }; + + /* + * Shadow realms. + * https://github.com/tc39/proposal-shadowrealm + * + * This class is used as the test_environment when testharness is running + * inside a shadow realm. + */ + function ShadowRealmTestEnvironment() { + WorkerTestEnvironment.call(this); + this.all_loaded = false; + this.on_loaded_callback = null; + } + + ShadowRealmTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype); + + /** + * Signal to the test environment that the tests are ready and the on-loaded + * callback should be run. + * + * Shadow realms are not *really* a DOM context: they have no `onload` or similar + * event for us to use to set up the test environment; so, instead, this method + * is manually triggered from the incubating realm + * + * @param {Function} message_destination - a function that receives JSON-serializable + * data to send to the incubating realm, in the same format as used by RemoteContext + */ + ShadowRealmTestEnvironment.prototype.begin = function(message_destination) { + if (this.all_loaded) { + throw new Error("Tried to start a shadow realm test environment after it has already started"); + } + var fakeMessagePort = {}; + fakeMessagePort.postMessage = message_destination; + this._add_message_port(fakeMessagePort); + this.all_loaded = true; + if (this.on_loaded_callback) { + this.on_loaded_callback(); + } + }; + + ShadowRealmTestEnvironment.prototype.add_on_loaded_callback = function(callback) { + if (this.all_loaded) { + callback(); + } else { + this.on_loaded_callback = callback; + } + }; + + /* + * JavaScript shells. + * + * This class is used as the test_environment when testharness is running + * inside a JavaScript shell. + */ + function ShellTestEnvironment() { + this.name_counter = 0; + this.all_loaded = false; + this.on_loaded_callback = null; + Promise.resolve().then(function() { + this.all_loaded = true; + if (this.on_loaded_callback) { + this.on_loaded_callback(); + } + }.bind(this)); + this.message_list = []; + this.message_ports = []; + } + + ShellTestEnvironment.prototype.next_default_test_name = function() { + var suffix = this.name_counter > 0 ? " " + this.name_counter : ""; + this.name_counter++; + return get_title() + suffix; + }; + + ShellTestEnvironment.prototype.on_new_harness_properties = function() {}; + + ShellTestEnvironment.prototype.on_tests_ready = function() {}; + + ShellTestEnvironment.prototype.add_on_loaded_callback = function(callback) { + if (this.all_loaded) { + callback(); + } else { + this.on_loaded_callback = callback; + } + }; + + ShellTestEnvironment.prototype.test_timeout = function() { + // Tests running in a shell don't have a default timeout, so behave as + // if settings.explicit_timeout is true. + return null; + }; + + function create_test_environment() { + if ('document' in global_scope) { + return new WindowTestEnvironment(); + } + if ('DedicatedWorkerGlobalScope' in global_scope && + global_scope instanceof DedicatedWorkerGlobalScope) { + return new DedicatedWorkerTestEnvironment(); + } + if ('SharedWorkerGlobalScope' in global_scope && + global_scope instanceof SharedWorkerGlobalScope) { + return new SharedWorkerTestEnvironment(); + } + if ('ServiceWorkerGlobalScope' in global_scope && + global_scope instanceof ServiceWorkerGlobalScope) { + return new ServiceWorkerTestEnvironment(); + } + if ('WorkerGlobalScope' in global_scope && + global_scope instanceof WorkerGlobalScope) { + return new DedicatedWorkerTestEnvironment(); + } + /* Shadow realm global objects are _ordinary_ objects (i.e. their prototype is + * Object) so we don't have a nice `instanceof` test to use; instead, we + * check if the there is a GLOBAL.isShadowRealm() property + * on the global object. that was set by the test harness when it + * created the ShadowRealm. + */ + if (global_scope.GLOBAL && global_scope.GLOBAL.isShadowRealm()) { + return new ShadowRealmTestEnvironment(); + } + + return new ShellTestEnvironment(); + } + + var test_environment = create_test_environment(); + + function is_shared_worker(worker) { + return 'SharedWorker' in global_scope && worker instanceof SharedWorker; + } + + function is_service_worker(worker) { + // The worker object may be from another execution context, + // so do not use instanceof here. + return 'ServiceWorker' in global_scope && + Object.prototype.toString.call(worker) === '[object ServiceWorker]'; + } + + var seen_func_name = Object.create(null); + + function get_test_name(func, name) + { + if (name) { + return name; + } + + if (func) { + var func_code = func.toString(); + + // Try and match with brackets, but fallback to matching without + var arrow = func_code.match(/^\(\)\s*=>\s*(?:{(.*)}\s*|(.*))$/); + + // Check for JS line separators + if (arrow !== null && !/[\u000A\u000D\u2028\u2029]/.test(func_code)) { + var trimmed = (arrow[1] !== undefined ? arrow[1] : arrow[2]).trim(); + // drop trailing ; if there's no earlier ones + trimmed = trimmed.replace(/^([^;]*)(;\s*)+$/, "$1"); + + if (trimmed) { + let name = trimmed; + if (seen_func_name[trimmed]) { + // This subtest name already exists, so add a suffix. + name += " " + seen_func_name[trimmed]; + } else { + seen_func_name[trimmed] = 0; + } + seen_func_name[trimmed] += 1; + return name; + } + } + } + + return test_environment.next_default_test_name(); + } + + /** + * @callback TestFunction + * @param {Test} test - The test currnetly being run. + * @param {Any[]} args - Additional args to pass to function. + * + */ + + /** + * Create a synchronous test + * + * @param {TestFunction} func - Test function. This is executed + * immediately. If it returns without error, the test status is + * set to ``PASS``. If it throws an :js:class:`AssertionError`, or + * any other exception, the test status is set to ``FAIL`` + * (typically from an `assert` function). + * @param {String} name - Test name. This must be unique in a + * given file and must be invariant between runs. + */ + function test(func, name, properties) + { + if (tests.promise_setup_called) { + tests.status.status = tests.status.ERROR; + tests.status.message = '`test` invoked after `promise_setup`'; + tests.complete(); + } + var test_name = get_test_name(func, name); + var test_obj = new Test(test_name, properties); + var value = test_obj.step(func, test_obj, test_obj); + + if (value !== undefined) { + var msg = 'Test named "' + test_name + + '" passed a function to `test` that returned a value.'; + + try { + if (value && typeof value.then === 'function') { + msg += ' Consider using `promise_test` instead when ' + + 'using Promises or async/await.'; + } + } catch (err) {} + + tests.status.status = tests.status.ERROR; + tests.status.message = msg; + } + + if (test_obj.phase === test_obj.phases.STARTED) { + test_obj.done(); + } + } + + /** + * Create an asynchronous test + * + * @param {TestFunction|string} funcOrName - Initial step function + * to call immediately with the test name as an argument (if any), + * or name of the test. + * @param {String} name - Test name (if a test function was + * provided). This must be unique in a given file and must be + * invariant between runs. + * @returns {Test} An object representing the ongoing test. + */ + function async_test(func, name, properties) + { + if (tests.promise_setup_called) { + tests.status.status = tests.status.ERROR; + tests.status.message = '`async_test` invoked after `promise_setup`'; + tests.complete(); + } + if (typeof func !== "function") { + properties = name; + name = func; + func = null; + } + var test_name = get_test_name(func, name); + var test_obj = new Test(test_name, properties); + if (func) { + var value = test_obj.step(func, test_obj, test_obj); + + // Test authors sometimes return values to async_test, expecting us + // to handle the value somehow. Make doing so a harness error to be + // clear this is invalid, and point authors to promise_test if it + // may be appropriate. + // + // Note that we only perform this check on the initial function + // passed to async_test, not on any later steps - we haven't seen a + // consistent problem with those (and it's harder to check). + if (value !== undefined) { + var msg = 'Test named "' + test_name + + '" passed a function to `async_test` that returned a value.'; + + try { + if (value && typeof value.then === 'function') { + msg += ' Consider using `promise_test` instead when ' + + 'using Promises or async/await.'; + } + } catch (err) {} + + tests.set_status(tests.status.ERROR, msg); + tests.complete(); + } + } + return test_obj; + } + + /** + * Create a promise test. + * + * Promise tests are tests which are represented by a promise + * object. If the promise is fulfilled the test passes, if it's + * rejected the test fails, otherwise the test passes. + * + * @param {TestFunction} func - Test function. This must return a + * promise. The test is automatically marked as complete once the + * promise settles. + * @param {String} name - Test name. This must be unique in a + * given file and must be invariant between runs. + */ + function promise_test(func, name, properties) { + if (typeof func !== "function") { + properties = name; + name = func; + func = null; + } + var test_name = get_test_name(func, name); + var test = new Test(test_name, properties); + test._is_promise_test = true; + + // If there is no promise tests queue make one. + if (!tests.promise_tests) { + tests.promise_tests = Promise.resolve(); + } + tests.promise_tests = tests.promise_tests.then(function() { + return new Promise(function(resolve) { + var promise = test.step(func, test, test); + + test.step(function() { + assert(!!promise, "promise_test", null, + "test body must return a 'thenable' object (received ${value})", + {value:promise}); + assert(typeof promise.then === "function", "promise_test", null, + "test body must return a 'thenable' object (received an object with no `then` method)", + null); + }); + + // Test authors may use the `step` method within a + // `promise_test` even though this reflects a mixture of + // asynchronous control flow paradigms. The "done" callback + // should be registered prior to the resolution of the + // user-provided Promise to avoid timeouts in cases where the + // Promise does not settle but a `step` function has thrown an + // error. + add_test_done_callback(test, resolve); + + Promise.resolve(promise) + .catch(test.step_func( + function(value) { + if (value instanceof AssertionError) { + throw value; + } + assert(false, "promise_test", null, + "Unhandled rejection with value: ${value}", {value:value}); + })) + .then(function() { + test.done(); + }); + }); + }); + } + + /** + * Make a copy of a Promise in the current realm. + * + * @param {Promise} promise the given promise that may be from a different + * realm + * @returns {Promise} + * + * An arbitrary promise provided by the caller may have originated + * in another frame that have since navigated away, rendering the + * frame's document inactive. Such a promise cannot be used with + * `await` or Promise.resolve(), as microtasks associated with it + * may be prevented from being run. See `issue + * 5319`_ for a + * particular case. + * + * In functions we define here, there is an expectation from the caller + * that the promise is from the current realm, that can always be used with + * `await`, etc. We therefore create a new promise in this realm that + * inherit the value and status from the given promise. + */ + + function bring_promise_to_current_realm(promise) { + return new Promise(promise.then.bind(promise)); + } + + /** + * Assert that a Promise is rejected with the right ECMAScript exception. + * + * @param {Test} test - the `Test` to use for the assertion. + * @param {Function} constructor - The expected exception constructor. + * @param {Promise} promise - The promise that's expected to + * reject with the given exception. + * @param {string} [description] Error message to add to assert in case of + * failure. + */ + function promise_rejects_js(test, constructor, promise, description) { + return bring_promise_to_current_realm(promise) + .then(test.unreached_func("Should have rejected: " + description)) + .catch(function(e) { + assert_throws_js_impl(constructor, function() { throw e; }, + description, "promise_rejects_js"); + }); + } + + /** + * Assert that a Promise is rejected with the right DOMException. + * + * For the remaining arguments, there are two ways of calling + * promise_rejects_dom: + * + * 1) If the DOMException is expected to come from the current global, the + * third argument should be the promise expected to reject, and a fourth, + * optional, argument is the assertion description. + * + * 2) If the DOMException is expected to come from some other global, the + * third argument should be the DOMException constructor from that global, + * the fourth argument the promise expected to reject, and the fifth, + * optional, argument the assertion description. + * + * @param {Test} test - the `Test` to use for the assertion. + * @param {number|string} type - See documentation for + * `assert_throws_dom <#assert_throws_dom>`_. + * @param {Function} promiseOrConstructor - Either the constructor + * for the expected exception (if the exception comes from another + * global), or the promise that's expected to reject (if the + * exception comes from the current global). + * @param {Function|string} descriptionOrPromise - Either the + * promise that's expected to reject (if the exception comes from + * another global), or the optional description of the condition + * being tested (if the exception comes from the current global). + * @param {string} [description] - Description of the condition + * being tested (if the exception comes from another global). + * + */ + function promise_rejects_dom(test, type, promiseOrConstructor, descriptionOrPromise, maybeDescription) { + let constructor, promise, description; + if (typeof promiseOrConstructor === "function" && + promiseOrConstructor.name === "DOMException") { + constructor = promiseOrConstructor; + promise = descriptionOrPromise; + description = maybeDescription; + } else { + constructor = self.DOMException; + promise = promiseOrConstructor; + description = descriptionOrPromise; + assert(maybeDescription === undefined, + "Too many args passed to no-constructor version of promise_rejects_dom, or accidentally explicitly passed undefined"); + } + return bring_promise_to_current_realm(promise) + .then(test.unreached_func("Should have rejected: " + description)) + .catch(function(e) { + assert_throws_dom_impl(type, function() { throw e; }, description, + "promise_rejects_dom", constructor); + }); + } + +/** + * Assert that a `Promise` is rejected with a `QuotaExceededError` with the + * expected values. + * + * For the remaining arguments, there are two ways of calling + * `promise_rejects_quotaexceedederror`: + * + * 1) If the `QuotaExceededError` is expected to come from the + * current global, the second argument should be the promise + * expected to reject, the third and a fourth the expected + * `requested` and `quota` property values, and the fifth, + * optional, argument is the assertion description. + * + * 2) If the `QuotaExceededError` is expected to come from some + * other global, the second argument should be the + * `QuotaExceededError` constructor from that global, the third + * argument should be the promise expected to reject, the fourth + * and fifth the expected `requested` and `quota` property + * values, and the sixth, optional, argument is the assertion + * description. + * + */ + function promise_rejects_quotaexceedederror(test, promiseOrConstructor, requestedOrPromise, quotaOrRequested, descriptionOrQuota, maybeDescription) + { + let constructor, promise, requested, quota, description; + if (typeof promiseOrConstructor === "function" && + promiseOrConstructor.name === "QuotaExceededError") { + constructor = promiseOrConstructor; + promise = requestedOrPromise; + requested = quotaOrRequested; + quota = descriptionOrQuota; + description = maybeDescription; + } else { + constructor = self.QuotaExceededError; + promise = promiseOrConstructor; + requested = requestedOrPromise; + quota = quotaOrRequested; + description = descriptionOrQuota; + assert(maybeDescription === undefined, + "Too many args passed to no-constructor version of promise_rejects_quotaexceedederror"); + } + return bring_promise_to_current_realm(promise) + .then(test.unreached_func("Should have rejected: " + description)) + .catch(function(e) { + assert_throws_quotaexceedederror_impl(function() { throw e; }, requested, quota, description, "promise_rejects_quotaexceedederror", constructor); + }); + } + + /** + * Assert that a Promise is rejected with the provided value. + * + * @param {Test} test - the `Test` to use for the assertion. + * @param {Any} exception - The expected value of the rejected promise. + * @param {Promise} promise - The promise that's expected to + * reject. + * @param {string} [description] Error message to add to assert in case of + * failure. + */ + function promise_rejects_exactly(test, exception, promise, description) { + return bring_promise_to_current_realm(promise) + .then(test.unreached_func("Should have rejected: " + description)) + .catch(function(e) { + assert_throws_exactly_impl(exception, function() { throw e; }, + description, "promise_rejects_exactly"); + }); + } + + /** + * Allow DOM events to be handled using Promises. + * + * This can make it a lot easier to test a very specific series of events, + * including ensuring that unexpected events are not fired at any point. + * + * `EventWatcher` will assert if an event occurs while there is no `wait_for` + * created Promise waiting to be fulfilled, or if the event is of a different type + * to the type currently expected. This ensures that only the events that are + * expected occur, in the correct order, and with the correct timing. + * + * @constructor + * @param {Test} test - The `Test` to use for the assertion. + * @param {EventTarget} watchedNode - The target expected to receive the events. + * @param {string[]} eventTypes - List of events to watch for. + * @param {Promise} timeoutPromise - Promise that will cause the + * test to be set to `TIMEOUT` once fulfilled. + * + */ + function EventWatcher(test, watchedNode, eventTypes, timeoutPromise) + { + if (typeof eventTypes === 'string') { + eventTypes = [eventTypes]; + } + + var waitingFor = null; + + // This is null unless we are recording all events, in which case it + // will be an Array object. + var recordedEvents = null; + + var eventHandler = test.step_func(function(evt) { + assert_true(!!waitingFor, + 'Not expecting event, but got ' + evt.type + ' event'); + assert_equals(evt.type, waitingFor.types[0], + 'Expected ' + waitingFor.types[0] + ' event, but got ' + + evt.type + ' event instead'); + + if (Array.isArray(recordedEvents)) { + recordedEvents.push(evt); + } + + if (waitingFor.types.length > 1) { + // Pop first event from array + waitingFor.types.shift(); + return; + } + // We need to null out waitingFor before calling the resolve function + // since the Promise's resolve handlers may call wait_for() which will + // need to set waitingFor. + var resolveFunc = waitingFor.resolve; + waitingFor = null; + // Likewise, we should reset the state of recordedEvents. + var result = recordedEvents || evt; + recordedEvents = null; + resolveFunc(result); + }); + + for (var i = 0; i < eventTypes.length; i++) { + watchedNode.addEventListener(eventTypes[i], eventHandler, false); + } + + /** + * Returns a Promise that will resolve after the specified event or + * series of events has occurred. + * + * @param {Object} options An optional options object. If the 'record' property + * on this object has the value 'all', when the Promise + * returned by this function is resolved, *all* Event + * objects that were waited for will be returned as an + * array. + * + * @example + * const watcher = new EventWatcher(t, div, [ 'animationstart', + * 'animationiteration', + * 'animationend' ]); + * return watcher.wait_for([ 'animationstart', 'animationend' ], + * { record: 'all' }).then(evts => { + * assert_equals(evts[0].elapsedTime, 0.0); + * assert_equals(evts[1].elapsedTime, 2.0); + * }); + */ + this.wait_for = function(types, options) { + if (waitingFor) { + return Promise.reject('Already waiting for an event or events'); + } + if (typeof types === 'string') { + types = [types]; + } + if (options && options.record && options.record === 'all') { + recordedEvents = []; + } + return new Promise(function(resolve, reject) { + var timeout = test.step_func(function() { + // If the timeout fires after the events have been received + // or during a subsequent call to wait_for, ignore it. + if (!waitingFor || waitingFor.resolve !== resolve) + return; + + // This should always fail, otherwise we should have + // resolved the promise. + assert_true(waitingFor.types.length === 0, + 'Timed out waiting for ' + waitingFor.types.join(', ')); + var result = recordedEvents; + recordedEvents = null; + var resolveFunc = waitingFor.resolve; + waitingFor = null; + resolveFunc(result); + }); + + if (timeoutPromise) { + timeoutPromise().then(timeout); + } + + waitingFor = { + types: types, + resolve: resolve, + reject: reject + }; + }); + }; + + /** + * Stop listening for events + */ + this.stop_watching = function() { + for (var i = 0; i < eventTypes.length; i++) { + watchedNode.removeEventListener(eventTypes[i], eventHandler, false); + } + }; + + test._add_cleanup(this.stop_watching); + + return this; + } + expose(EventWatcher, 'EventWatcher'); + + /** + * @typedef {Object} SettingsObject + * @property {bool} single_test - Use the single-page-test + * mode. In this mode the Document represents a single + * `async_test`. Asserts may be used directly without requiring + * `Test.step` or similar wrappers, and any exceptions set the + * status of the test rather than the status of the harness. + * @property {bool} allow_uncaught_exception - don't treat an + * uncaught exception as an error; needed when e.g. testing the + * `window.onerror` handler. + * @property {boolean} explicit_done - Wait for a call to `done()` + * before declaring all tests complete (this is always true for + * single-page tests). + * @property hide_test_state - hide the test state output while + * the test is running; This is helpful when the output of the test state + * may interfere the test results. + * @property {bool} explicit_timeout - disable file timeout; only + * stop waiting for results when the `timeout()` function is + * called This should typically only be set for manual tests, or + * by a test runner that providees its own timeout mechanism. + * @property {number} timeout_multiplier - Multiplier to apply to + * per-test timeouts. This should only be set by a test runner. + * @property {Document} output_document - The document to which + * results should be logged. By default this is the current + * document but could be an ancestor document in some cases e.g. a + * SVG test loaded in an HTML wrapper + * + */ + + /** + * Configure the harness + * + * @param {Function|SettingsObject} funcOrProperties - Either a + * setup function to run, or a set of properties. If this is a + * function that function is run synchronously. Any exception in + * the function will set the overall harness status to `ERROR`. + * @param {SettingsObject} maybeProperties - An object containing + * the settings to use, if the first argument is a function. + * + */ + function setup(func_or_properties, maybe_properties) + { + var func = null; + var properties = {}; + if (arguments.length === 2) { + func = func_or_properties; + properties = maybe_properties; + } else if (func_or_properties instanceof Function) { + func = func_or_properties; + } else { + properties = func_or_properties; + } + tests.setup(func, properties); + test_environment.on_new_harness_properties(properties); + } + + /** + * Configure the harness, waiting for a promise to resolve + * before running any `promise_test` tests. + * + * @param {Function} func - Function returning a promise that's + * run synchronously. Promise tests are not run until after this + * function has resolved. + * @param {SettingsObject} [properties] - An object containing + * the harness settings to use. + * + */ + function promise_setup(func, properties={}) + { + if (typeof func !== "function") { + tests.set_status(tests.status.ERROR, + "`promise_setup` invoked without a function"); + tests.complete(); + return; + } + tests.promise_setup_called = true; + + if (!tests.promise_tests) { + tests.promise_tests = Promise.resolve(); + } + + tests.promise_tests = tests.promise_tests + .then(function() + { + var result; + + tests.setup(null, properties); + result = func(); + test_environment.on_new_harness_properties(properties); + + if (!result || typeof result.then !== "function") { + throw "Non-thenable returned by function passed to `promise_setup`"; + } + return result; + }) + .catch(function(e) + { + tests.set_status(tests.status.ERROR, + String(e), + e && e.stack); + tests.complete(); + }); + } + + /** + * Mark test loading as complete. + * + * Typically this function is called implicitly on page load; it's + * only necessary for users to call this when either the + * ``explicit_done`` or ``single_test`` properties have been set + * via the :js:func:`setup` function. + * + * For single page tests this marks the test as complete and sets its status. + * For other tests, this marks test loading as complete, but doesn't affect ongoing tests. + */ + function done() { + if (tests.tests.length === 0) { + // `done` is invoked after handling uncaught exceptions, so if the + // harness status is already set, the corresponding message is more + // descriptive than the generic message defined here. + if (tests.status.status === null) { + tests.status.status = tests.status.ERROR; + tests.status.message = "done() was called without first defining any tests"; + } + + tests.complete(); + return; + } + if (tests.file_is_test) { + // file is test files never have asynchronous cleanup logic, + // meaning the fully-synchronous `done` function can be used here. + tests.tests[0].done(); + } + tests.end_wait(); + } + + /** + * @deprecated generate a list of tests from a function and list of arguments + * + * This is deprecated because it runs all the tests outside of the test functions + * and as a result any test throwing an exception will result in no tests being + * run. In almost all cases, you should simply call test within the loop you would + * use to generate the parameter list array. + * + * @param {Function} func - The function that will be called for each generated tests. + * @param {Any[][]} args - An array of arrays. Each nested array + * has the structure `[testName, ...testArgs]`. For each of these nested arrays + * array, a test is generated with name `testName` and test function equivalent to + * `func(..testArgs)`. + */ + function generate_tests(func, args, properties) { + forEach(args, function(x, i) + { + var name = x[0]; + test(function() + { + func.apply(this, x.slice(1)); + }, + name, + Array.isArray(properties) ? properties[i] : properties); + }); + } + + /** + * @deprecated + * + * Register a function as a DOM event listener to the + * given object for the event bubbling phase. + * + * @param {EventTarget} object - Event target + * @param {string} event - Event name + * @param {Function} callback - Event handler. + */ + function on_event(object, event, callback) + { + object.addEventListener(event, callback, false); + } + + // Internal helper function to provide timeout-like functionality in + // environments where there is no setTimeout(). (No timeout ID or + // clearTimeout().) + function fake_set_timeout(callback, delay) { + var p = Promise.resolve(); + var start = Date.now(); + var end = start + delay; + function check() { + if ((end - Date.now()) > 0) { + p.then(check); + } else { + callback(); + } + } + p.then(check); + } + + /** + * Global version of :js:func:`Test.step_timeout` for use in single page tests. + * + * @param {Function} func - Function to run after the timeout + * @param {number} timeout - Time in ms to wait before running the + * test step. The actual wait time is ``timeout`` x + * ``timeout_multiplier``. + */ + function step_timeout(func, timeout) { + var outer_this = this; + var args = Array.prototype.slice.call(arguments, 2); + var local_set_timeout = typeof global_scope.setTimeout === "undefined" ? fake_set_timeout : setTimeout; + return local_set_timeout(function() { + func.apply(outer_this, args); + }, timeout * tests.timeout_multiplier); + } + + expose(test, 'test'); + expose(async_test, 'async_test'); + expose(promise_test, 'promise_test'); + expose(promise_rejects_js, 'promise_rejects_js'); + expose(promise_rejects_dom, 'promise_rejects_dom'); + expose(promise_rejects_quotaexceedederror, 'promise_rejects_quotaexceedederror'); + expose(promise_rejects_exactly, 'promise_rejects_exactly'); + expose(generate_tests, 'generate_tests'); + expose(setup, 'setup'); + expose(promise_setup, 'promise_setup'); + expose(done, 'done'); + expose(on_event, 'on_event'); + expose(step_timeout, 'step_timeout'); + + /* + * Return a string truncated to the given length, with ... added at the end + * if it was longer. + */ + function truncate(s, len) + { + if (s.length > len) { + return s.substring(0, len - 3) + "..."; + } + return s; + } + + /* + * Return true if object is probably a Node object. + */ + function is_node(object) + { + // I use duck-typing instead of instanceof, because + // instanceof doesn't work if the node is from another window (like an + // iframe's contentWindow): + // http://www.w3.org/Bugs/Public/show_bug.cgi?id=12295 + try { + var has_node_properties = ("nodeType" in object && + "nodeName" in object && + "nodeValue" in object && + "childNodes" in object); + } catch (e) { + // We're probably cross-origin, which means we aren't a node + return false; + } + + if (has_node_properties) { + try { + object.nodeType; + } catch (e) { + // The object is probably Node.prototype or another prototype + // object that inherits from it, and not a Node instance. + return false; + } + return true; + } + return false; + } + + var replacements = { + "0": "0", + "1": "x01", + "2": "x02", + "3": "x03", + "4": "x04", + "5": "x05", + "6": "x06", + "7": "x07", + "8": "b", + "9": "t", + "10": "n", + "11": "v", + "12": "f", + "13": "r", + "14": "x0e", + "15": "x0f", + "16": "x10", + "17": "x11", + "18": "x12", + "19": "x13", + "20": "x14", + "21": "x15", + "22": "x16", + "23": "x17", + "24": "x18", + "25": "x19", + "26": "x1a", + "27": "x1b", + "28": "x1c", + "29": "x1d", + "30": "x1e", + "31": "x1f", + "0xfffd": "ufffd", + "0xfffe": "ufffe", + "0xffff": "uffff", + }; + + const formatEscapeMap = { + "\\": "\\\\", + '"': '\\"' + }; + for (const p in replacements) { + formatEscapeMap[String.fromCharCode(p)] = "\\" + replacements[p]; + } + const formatEscapePattern = new RegExp(`[${Object.keys(formatEscapeMap).map(k => k === "\\" ? "\\\\" : k).join("")}]`, "g"); + + /** + * Convert a value to a nice, human-readable string + * + * When many JavaScript Object values are coerced to a String, the + * resulting value will be ``"[object Object]"``. This obscures + * helpful information, making the coerced value unsuitable for + * use in assertion messages, test names, and debugging + * statements. `format_value` produces more distinctive string + * representations of many kinds of objects, including arrays and + * the more important DOM Node types. It also translates String + * values containing control characters to include human-readable + * representations. + * + * @example + * // "Document node with 2 children" + * format_value(document); + * @example + * // "\"foo\\uffffbar\"" + * format_value("foo\uffffbar"); + * @example + * // "[-0, Infinity]" + * format_value([-0, Infinity]); + * @param {Any} val - The value to convert to a string. + * @returns {string} - A string representation of ``val``, optimised for human readability. + */ + function format_value(val, seen) + { + if (!seen) { + seen = []; + } + if (typeof val === "object" && val !== null) { + if (seen.indexOf(val) >= 0) { + return "[...]"; + } + seen.push(val); + } + if (Array.isArray(val)) { + let output = "["; + if (val.beginEllipsis !== undefined) { + output += "…, "; + } + output += val.map(function(x) {return format_value(x, seen);}).join(", "); + if (val.endEllipsis !== undefined) { + output += ", …"; + } + return output + "]"; + } + + switch (typeof val) { + case "string": + return '"' + val.replace(formatEscapePattern, match => formatEscapeMap[match]) + '"'; + case "boolean": + case "undefined": + return String(val); + case "number": + // In JavaScript, -0 === 0 and String(-0) == "0", so we have to + // special-case. + if (val === -0 && 1/val === -Infinity) { + return "-0"; + } + return String(val); + case "bigint": + return String(val) + 'n'; + case "object": + if (val === null) { + return "null"; + } + + // Special-case Node objects, since those come up a lot in my tests. I + // ignore namespaces. + if (is_node(val)) { + switch (val.nodeType) { + case Node.ELEMENT_NODE: + var ret = "<" + val.localName; + for (var i = 0; i < val.attributes.length; i++) { + ret += " " + val.attributes[i].name + '="' + val.attributes[i].value + '"'; + } + ret += ">" + val.innerHTML + ""; + return "Element node " + truncate(ret, 60); + case Node.TEXT_NODE: + return 'Text node "' + truncate(val.data, 60) + '"'; + case Node.PROCESSING_INSTRUCTION_NODE: + return "ProcessingInstruction node with target " + format_value(truncate(val.target, 60)) + " and data " + format_value(truncate(val.data, 60)); + case Node.COMMENT_NODE: + return "Comment node "; + case Node.DOCUMENT_NODE: + return "Document node with " + val.childNodes.length + (val.childNodes.length === 1 ? " child" : " children"); + case Node.DOCUMENT_TYPE_NODE: + return "DocumentType node"; + case Node.DOCUMENT_FRAGMENT_NODE: + return "DocumentFragment node with " + val.childNodes.length + (val.childNodes.length === 1 ? " child" : " children"); + default: + return "Node object of unknown type"; + } + } + + /* falls through */ + default: + try { + return typeof val + ' "' + truncate(String(val), 1000) + '"'; + } catch(e) { + return ("[stringifying object threw " + String(e) + + " with type " + String(typeof e) + "]"); + } + } + } + expose(format_value, "format_value"); + + /* + * Assertions + */ + + function expose_assert(f, name) { + function assert_wrapper(...args) { + let status = Test.statuses.TIMEOUT; + let stack = null; + let new_assert_index = null; + try { + if (settings.debug) { + console.debug("ASSERT", name, tests.current_test && tests.current_test.name, args); + } + if (tests.output) { + tests.set_assert(name, args); + // Remember the newly pushed assert's index, because `apply` + // below might push new asserts. + new_assert_index = tests.asserts_run.length - 1; + } + const rv = f.apply(undefined, args); + status = Test.statuses.PASS; + return rv; + } catch(e) { + status = Test.statuses.FAIL; + stack = e.stack ? e.stack : null; + throw e; + } finally { + if (tests.output && !stack) { + stack = get_stack(); + } + if (tests.output) { + tests.set_assert_status(new_assert_index, status, stack); + } + } + } + expose(assert_wrapper, name); + } + + /** + * Assert that ``actual`` is strictly true + * + * @param {Any} actual - Value that is asserted to be true + * @param {string} [description] - Description of the condition being tested + */ + function assert_true(actual, description) + { + assert(actual === true, "assert_true", description, + "expected true got ${actual}", {actual:actual}); + } + expose_assert(assert_true, "assert_true"); + + /** + * Assert that ``actual`` is strictly false + * + * @param {Any} actual - Value that is asserted to be false + * @param {string} [description] - Description of the condition being tested + */ + function assert_false(actual, description) + { + assert(actual === false, "assert_false", description, + "expected false got ${actual}", {actual:actual}); + } + expose_assert(assert_false, "assert_false"); + + function same_value(x, y) { + if (y !== y) { + //NaN case + return x !== x; + } + if (x === 0 && y === 0) { + //Distinguish +0 and -0 + return 1/x === 1/y; + } + return x === y; + } + + /** + * Assert that ``actual`` is the same value as ``expected``. + * + * For objects this compares by object identity; for primitives + * this distinguishes between 0 and -0, and has correct handling + * of NaN. + * + * @param {Any} actual - Test value. + * @param {Any} expected - Expected value. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_equals(actual, expected, description) + { + /* + * Test if two primitives are equal or two objects + * are the same object + */ + if (typeof actual != typeof expected) { + assert(false, "assert_equals", description, + "expected (" + typeof expected + ") ${expected} but got (" + typeof actual + ") ${actual}", + {expected:expected, actual:actual}); + return; + } + assert(same_value(actual, expected), "assert_equals", description, + "expected ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_equals, "assert_equals"); + + /** + * Assert that ``actual`` is not the same value as ``expected``. + * + * Comparison is as for :js:func:`assert_equals`. + * + * @param {Any} actual - Test value. + * @param {Any} expected - The value ``actual`` is expected to be different to. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_not_equals(actual, expected, description) + { + assert(!same_value(actual, expected), "assert_not_equals", description, + "got disallowed value ${actual}", + {actual:actual}); + } + expose_assert(assert_not_equals, "assert_not_equals"); + + /** + * Assert that ``expected`` is an array and ``actual`` is one of the members. + * This is implemented using ``indexOf``, so doesn't handle NaN or ±0 correctly. + * + * @param {Any} actual - Test value. + * @param {Array} expected - An array that ``actual`` is expected to + * be a member of. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_in_array(actual, expected, description) + { + assert(expected.indexOf(actual) != -1, "assert_in_array", description, + "value ${actual} not in array ${expected}", + {actual:actual, expected:expected}); + } + expose_assert(assert_in_array, "assert_in_array"); + + // This function was deprecated in July of 2015. + // See https://github.com/web-platform-tests/wpt/issues/2033 + /** + * @deprecated + * Recursively compare two objects for equality. + * + * See `Issue 2033 + * `_ for + * more information. + * + * @param {Object} actual - Test value. + * @param {Object} expected - Expected value. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_object_equals(actual, expected, description) + { + assert(typeof actual === "object" && actual !== null, "assert_object_equals", description, + "value is ${actual}, expected object", + {actual: actual}); + //This needs to be improved a great deal + function check_equal(actual, expected, stack) + { + stack.push(actual); + + var p; + for (p in actual) { + assert(expected.hasOwnProperty(p), "assert_object_equals", description, + "unexpected property ${p}", {p:p}); + + if (typeof actual[p] === "object" && actual[p] !== null) { + if (stack.indexOf(actual[p]) === -1) { + check_equal(actual[p], expected[p], stack); + } + } else { + assert(same_value(actual[p], expected[p]), "assert_object_equals", description, + "property ${p} expected ${expected} got ${actual}", + {p:p, expected:expected[p], actual:actual[p]}); + } + } + for (p in expected) { + assert(actual.hasOwnProperty(p), + "assert_object_equals", description, + "expected property ${p} missing", {p:p}); + } + stack.pop(); + } + check_equal(actual, expected, []); + } + expose_assert(assert_object_equals, "assert_object_equals"); + + /** + * Assert that ``actual`` and ``expected`` are both arrays, and that the array properties of + * ``actual`` and ``expected`` are all the same value (as for :js:func:`assert_equals`). + * + * @param {Array} actual - Test array. + * @param {Array} expected - Array that is expected to contain the same values as ``actual``. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_array_equals(actual, expected, description) + { + const max_array_length = 20; + function shorten_array(arr, offset = 0) { + // Make ", …" only show up when it would likely reduce the length, not accounting for + // fonts. + if (arr.length < max_array_length + 2) { + return arr; + } + // By default we want half the elements after the offset and half before + // But if that takes us past the end of the array, we have more before, and + // if it takes us before the start we have more after. + const length_after_offset = Math.floor(max_array_length / 2); + let upper_bound = Math.min(length_after_offset + offset, arr.length); + const lower_bound = Math.max(upper_bound - max_array_length, 0); + + if (lower_bound === 0) { + upper_bound = max_array_length; + } + + const output = arr.slice(lower_bound, upper_bound); + if (lower_bound > 0) { + output.beginEllipsis = true; + } + if (upper_bound < arr.length) { + output.endEllipsis = true; + } + return output; + } + + assert(typeof actual === "object" && actual !== null && "length" in actual, + "assert_array_equals", description, + "value is ${actual}, expected array", + {actual:actual}); + assert(actual.length === expected.length, + "assert_array_equals", description, + "lengths differ, expected array ${expected} length ${expectedLength}, got ${actual} length ${actualLength}", + {expected:shorten_array(expected, expected.length - 1), expectedLength:expected.length, + actual:shorten_array(actual, actual.length - 1), actualLength:actual.length + }); + + for (var i = 0; i < actual.length; i++) { + assert(actual.hasOwnProperty(i) === expected.hasOwnProperty(i), + "assert_array_equals", description, + "expected property ${i} to be ${expected} but was ${actual} (expected array ${arrayExpected} got ${arrayActual})", + {i:i, expected:expected.hasOwnProperty(i) ? "present" : "missing", + actual:actual.hasOwnProperty(i) ? "present" : "missing", + arrayExpected:shorten_array(expected, i), arrayActual:shorten_array(actual, i)}); + assert(same_value(expected[i], actual[i]), + "assert_array_equals", description, + "expected property ${i} to be ${expected} but got ${actual} (expected array ${arrayExpected} got ${arrayActual})", + {i:i, expected:expected[i], actual:actual[i], + arrayExpected:shorten_array(expected, i), arrayActual:shorten_array(actual, i)}); + } + } + expose_assert(assert_array_equals, "assert_array_equals"); + + /** + * Assert that each array property in ``actual`` is a number within + * ± `epsilon` of the corresponding property in `expected`. + * + * @param {Array} actual - Array of test values. + * @param {Array} expected - Array of values expected to be close to the values in ``actual``. + * @param {number} epsilon - Magnitude of allowed difference + * between each value in ``actual`` and ``expected``. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_array_approx_equals(actual, expected, epsilon, description) + { + /* + * Test if two primitive arrays are equal within +/- epsilon + */ + assert(actual.length === expected.length, + "assert_array_approx_equals", description, + "lengths differ, expected ${expected} got ${actual}", + {expected:expected.length, actual:actual.length}); + + for (var i = 0; i < actual.length; i++) { + assert(actual.hasOwnProperty(i) === expected.hasOwnProperty(i), + "assert_array_approx_equals", description, + "property ${i}, property expected to be ${expected} but was ${actual}", + {i:i, expected:expected.hasOwnProperty(i) ? "present" : "missing", + actual:actual.hasOwnProperty(i) ? "present" : "missing"}); + assert(typeof actual[i] === "number", + "assert_array_approx_equals", description, + "property ${i}, expected a number but got a ${type_actual}", + {i:i, type_actual:typeof actual[i]}); + assert(Math.abs(actual[i] - expected[i]) <= epsilon, + "assert_array_approx_equals", description, + "property ${i}, expected ${expected} +/- ${epsilon}, expected ${expected} but got ${actual}", + {i:i, expected:expected[i], actual:actual[i], epsilon:epsilon}); + } + } + expose_assert(assert_array_approx_equals, "assert_array_approx_equals"); + + /** + * Assert that ``actual`` is within ± ``epsilon`` of ``expected``. + * + * @param {number} actual - Test value. + * @param {number} expected - Value number is expected to be close to. + * @param {number} epsilon - Magnitude of allowed difference between ``actual`` and ``expected``. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_approx_equals(actual, expected, epsilon, description) + { + /* + * Test if two primitive numbers are equal within +/- epsilon + */ + assert(typeof actual === "number", + "assert_approx_equals", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + // The epsilon math below does not place nice with NaN and Infinity + // But in this case Infinity = Infinity and NaN = NaN + if (isFinite(actual) || isFinite(expected)) { + assert(Math.abs(actual - expected) <= epsilon, + "assert_approx_equals", description, + "expected ${expected} +/- ${epsilon} but got ${actual}", + {expected:expected, actual:actual, epsilon:epsilon}); + } else { + assert_equals(actual, expected); + } + } + expose_assert(assert_approx_equals, "assert_approx_equals"); + + /** + * Assert that ``actual`` is a number less than ``expected``. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} expected - Value that ``actual`` must be less than. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_less_than(actual, expected, description) + { + /* + * Test if a primitive number (or bigint) is less than another + */ + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_less_than", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof expected, + "assert_less_than", description, + "expected a ${type_expected} but got a ${type_actual}", + {type_expected:typeof expected, type_actual:typeof actual}); + + assert(actual < expected, + "assert_less_than", description, + "expected a number less than ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_less_than, "assert_less_than"); + + /** + * Assert that ``actual`` is a number greater than ``expected``. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} expected - Value that ``actual`` must be greater than. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_greater_than(actual, expected, description) + { + /* + * Test if a primitive number (or bigint) is greater than another + */ + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_greater_than", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof expected, + "assert_greater_than", description, + "expected a ${type_expected} but got a ${type_actual}", + {type_expected:typeof expected, type_actual:typeof actual}); + + assert(actual > expected, + "assert_greater_than", description, + "expected a number greater than ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_greater_than, "assert_greater_than"); + + /** + * Assert that ``actual`` is a number greater than ``lower`` and less + * than ``upper`` but not equal to either. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} lower - Value that ``actual`` must be greater than. + * @param {number|bigint} upper - Value that ``actual`` must be less than. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_between_exclusive(actual, lower, upper, description) + { + /* + * Test if a primitive number (or bigint) is between two others + */ + assert(typeof lower === typeof upper, + "assert_between_exclusive", description, + "expected lower (${type_lower}) and upper (${type_upper}) types to match (test error)", + {type_lower:typeof lower, type_upper:typeof upper}); + + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_between_exclusive", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof lower, + "assert_between_exclusive", description, + "expected a ${type_lower} but got a ${type_actual}", + {type_lower:typeof lower, type_actual:typeof actual}); + + assert(actual > lower && actual < upper, + "assert_between_exclusive", description, + "expected a number greater than ${lower} " + + "and less than ${upper} but got ${actual}", + {lower:lower, upper:upper, actual:actual}); + } + expose_assert(assert_between_exclusive, "assert_between_exclusive"); + + /** + * Assert that ``actual`` is a number less than or equal to ``expected``. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} expected - Value that ``actual`` must be less + * than or equal to. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_less_than_equal(actual, expected, description) + { + /* + * Test if a primitive number (or bigint) is less than or equal to another + */ + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_less_than_equal", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof expected, + "assert_less_than_equal", description, + "expected a ${type_expected} but got a ${type_actual}", + {type_expected:typeof expected, type_actual:typeof actual}); + + assert(actual <= expected, + "assert_less_than_equal", description, + "expected a number less than or equal to ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_less_than_equal, "assert_less_than_equal"); + + /** + * Assert that ``actual`` is a number greater than or equal to ``expected``. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} expected - Value that ``actual`` must be greater + * than or equal to. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_greater_than_equal(actual, expected, description) + { + /* + * Test if a primitive number (or bigint) is greater than or equal to another + */ + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_greater_than_equal", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof expected, + "assert_greater_than_equal", description, + "expected a ${type_expected} but got a ${type_actual}", + {type_expected:typeof expected, type_actual:typeof actual}); + + assert(actual >= expected, + "assert_greater_than_equal", description, + "expected a number greater than or equal to ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_greater_than_equal, "assert_greater_than_equal"); + + /** + * Assert that ``actual`` is a number greater than or equal to ``lower`` and less + * than or equal to ``upper``. + * + * @param {number|bigint} actual - Test value. + * @param {number|bigint} lower - Value that ``actual`` must be greater than or equal to. + * @param {number|bigint} upper - Value that ``actual`` must be less than or equal to. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_between_inclusive(actual, lower, upper, description) + { + /* + * Test if a primitive number (or bigint) is between to two others or equal to either of them + */ + assert(typeof lower === typeof upper, + "assert_between_inclusive", description, + "expected lower (${type_lower}) and upper (${type_upper}) types to match (test error)", + {type_lower:typeof lower, type_upper:typeof upper}); + + assert(typeof actual === "number" || typeof actual === "bigint", + "assert_between_inclusive", description, + "expected a number but got a ${type_actual}", + {type_actual:typeof actual}); + + assert(typeof actual === typeof lower, + "assert_between_inclusive", description, + "expected a ${type_lower} but got a ${type_actual}", + {type_lower:typeof lower, type_actual:typeof actual}); + + assert(actual >= lower && actual <= upper, + "assert_between_inclusive", description, + "expected a number greater than or equal to ${lower} " + + "and less than or equal to ${upper} but got ${actual}", + {lower:lower, upper:upper, actual:actual}); + } + expose_assert(assert_between_inclusive, "assert_between_inclusive"); + + /** + * Assert that ``actual`` matches the RegExp ``expected``. + * + * @param {String} actual - Test string. + * @param {RegExp} expected - RegExp ``actual`` must match. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_regexp_match(actual, expected, description) { + /* + * Test if a string (actual) matches a regexp (expected) + */ + assert(expected.test(actual), + "assert_regexp_match", description, + "expected ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_regexp_match, "assert_regexp_match"); + + /** + * Assert that the class string of ``object`` as returned in + * ``Object.prototype.toString`` is equal to ``class_name``. + * + * @param {Object} object - Object to stringify. + * @param {string} class_string - Expected class string for ``object``. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_class_string(object, class_string, description) { + var actual = {}.toString.call(object); + var expected = "[object " + class_string + "]"; + assert(same_value(actual, expected), "assert_class_string", description, + "expected ${expected} but got ${actual}", + {expected:expected, actual:actual}); + } + expose_assert(assert_class_string, "assert_class_string"); + + /** + * Assert that ``object`` has an own property with name ``property_name``. + * + * @param {Object} object - Object that should have the given property. + * @param {string} property_name - Expected property name. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_own_property(object, property_name, description) { + assert(object.hasOwnProperty(property_name), + "assert_own_property", description, + "expected property ${p} missing", {p:property_name}); + } + expose_assert(assert_own_property, "assert_own_property"); + + /** + * Assert that ``object`` does not have an own property with name ``property_name``. + * + * @param {Object} object - Object that should not have the given property. + * @param {string} property_name - Property name to test. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_not_own_property(object, property_name, description) { + assert(!object.hasOwnProperty(property_name), + "assert_not_own_property", description, + "unexpected property ${p} is found on object", {p:property_name}); + } + expose_assert(assert_not_own_property, "assert_not_own_property"); + + function _assert_inherits(name) { + return function (object, property_name, description) + { + assert((typeof object === "object" && object !== null) || + typeof object === "function" || + // Or has [[IsHTMLDDA]] slot + String(object) === "[object HTMLAllCollection]", + name, description, + "provided value is not an object"); + + assert("hasOwnProperty" in object, + name, description, + "provided value is an object but has no hasOwnProperty method"); + + assert(!object.hasOwnProperty(property_name), + name, description, + "property ${p} found on object expected in prototype chain", + {p:property_name}); + + assert(property_name in object, + name, description, + "property ${p} not found in prototype chain", + {p:property_name}); + }; + } + + /** + * Assert that ``object`` does not have an own property with name + * ``property_name``, but inherits one through the prototype chain. + * + * @param {Object} object - Object that should have the given property in its prototype chain. + * @param {string} property_name - Expected property name. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_inherits(object, property_name, description) { + return _assert_inherits("assert_inherits")(object, property_name, description); + } + expose_assert(assert_inherits, "assert_inherits"); + + /** + * Alias for :js:func:`insert_inherits`. + * + * @param {Object} object - Object that should have the given property in its prototype chain. + * @param {string} property_name - Expected property name. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_idl_attribute(object, property_name, description) { + return _assert_inherits("assert_idl_attribute")(object, property_name, description); + } + expose_assert(assert_idl_attribute, "assert_idl_attribute"); + + + /** + * Assert that ``object`` has a property named ``property_name`` and that the property is not writable or has no setter. + * + * @param {Object} object - Object that should have the given (not necessarily own) property. + * @param {string} property_name - Expected property name. + * @param {string} [description] - Description of the condition being tested. + */ + function assert_readonly(object, property_name, description) + { + assert(property_name in object, + "assert_readonly", description, + "property ${p} not found", + {p:property_name}); + + let desc; + while (object && (desc = Object.getOwnPropertyDescriptor(object, property_name)) === undefined) { + object = Object.getPrototypeOf(object); + } + + assert(desc !== undefined, + "assert_readonly", description, + "could not find a descriptor for property ${p}", + {p:property_name}); + + if (desc.hasOwnProperty("value")) { + // We're a data property descriptor + assert(desc.writable === false, "assert_readonly", description, + "descriptor [[Writable]] expected false got ${actual}", {actual:desc.writable}); + } else if (desc.hasOwnProperty("get") || desc.hasOwnProperty("set")) { + // We're an accessor property descriptor + assert(desc.set === undefined, "assert_readonly", description, + "property ${p} is an accessor property with a [[Set]] attribute, cannot test readonly-ness", + {p:property_name}); + } else { + // We're a generic property descriptor + // This shouldn't happen, because Object.getOwnPropertyDescriptor + // forwards the return value of [[GetOwnProperty]] (P), which must + // be a fully populated Property Descriptor or Undefined. + assert(false, "assert_readonly", description, + "Object.getOwnPropertyDescriptor must return a fully populated property descriptor"); + } + } + expose_assert(assert_readonly, "assert_readonly"); + + /** + * Assert a JS Error with the expected constructor is thrown. + * + * @param {object} constructor The expected exception constructor. + * @param {Function} func Function which should throw. + * @param {string} [description] Error description for the case that the error is not thrown. + */ + function assert_throws_js(constructor, func, description) + { + assert_throws_js_impl(constructor, func, description, + "assert_throws_js"); + } + expose_assert(assert_throws_js, "assert_throws_js"); + + /** + * Like assert_throws_js but allows specifying the assertion type + * (assert_throws_js or promise_rejects_js, in practice). + */ + function assert_throws_js_impl(constructor, func, description, + assertion_type) + { + try { + func.call(this); + assert(false, assertion_type, description, + "${func} did not throw", {func:func}); + } catch (e) { + if (e instanceof AssertionError) { + throw e; + } + + // Basic sanity-checks on the thrown exception. + assert(typeof e === "object", + assertion_type, description, + "${func} threw ${e} with type ${type}, not an object", + {func:func, e:e, type:typeof e}); + + assert(e !== null, + assertion_type, description, + "${func} threw null, not an object", + {func:func}); + + // Basic sanity-check on the passed-in constructor + assert(typeof constructor === "function", + assertion_type, description, + "${constructor} is not a constructor", + {constructor:constructor}); + var obj = constructor; + while (obj) { + if (typeof obj === "function" && + obj.name === "Error") { + break; + } + obj = Object.getPrototypeOf(obj); + } + assert(obj != null, + assertion_type, description, + "${constructor} is not an Error subtype", + {constructor:constructor}); + + // And checking that our exception is reasonable + assert(e.constructor === constructor && + e.name === constructor.name, + assertion_type, description, + "${func} threw ${actual} (${actual_name}) expected instance of ${expected} (${expected_name})", + {func:func, actual:e, actual_name:e.name, + expected:constructor, + expected_name:constructor.name}); + } + } + + // TODO: Figure out how to document the overloads better. + // sphinx-js doesn't seem to handle @variation correctly, + // and only expects a single JSDoc entry per function. + /** + * Assert a DOMException with the expected type is thrown. + * + * There are two ways of calling assert_throws_dom: + * + * 1) If the DOMException is expected to come from the current global, the + * second argument should be the function expected to throw and a third, + * optional, argument is the assertion description. + * + * 2) If the DOMException is expected to come from some other global, the + * second argument should be the DOMException constructor from that global, + * the third argument the function expected to throw, and the fourth, optional, + * argument the assertion description. + * + * @param {number|string} type - The expected exception name or + * code. See the `table of names and codes + * `_. If a + * number is passed it should be one of the numeric code values in + * that table (e.g. 3, 4, etc). If a string is passed it can + * either be an exception name (e.g. "HierarchyRequestError", + * "WrongDocumentError") or the name of the corresponding error + * code (e.g. "``HIERARCHY_REQUEST_ERR``", "``WRONG_DOCUMENT_ERR``"). + * @param {Function} descriptionOrFunc - The function expected to + * throw (if the exception comes from another global), or the + * optional description of the condition being tested (if the + * exception comes from the current global). + * @param {string} [description] - Description of the condition + * being tested (if the exception comes from another global). + * + */ + function assert_throws_dom(type, funcOrConstructor, descriptionOrFunc, maybeDescription) + { + let constructor, func, description; + if (funcOrConstructor.name === "DOMException") { + constructor = funcOrConstructor; + func = descriptionOrFunc; + description = maybeDescription; + } else { + constructor = self.DOMException; + func = funcOrConstructor; + description = descriptionOrFunc; + assert(maybeDescription === undefined, + "Too many args passed to no-constructor version of assert_throws_dom, or accidentally explicitly passed undefined"); + } + assert_throws_dom_impl(type, func, description, "assert_throws_dom", constructor); + } + expose_assert(assert_throws_dom, "assert_throws_dom"); + + /** + * Similar to assert_throws_dom but allows specifying the assertion type + * (assert_throws_dom or promise_rejects_dom, in practice). The + * "constructor" argument must be the DOMException constructor from the + * global we expect the exception to come from. + */ + function assert_throws_dom_impl(type, func, description, assertion_type, constructor) + { + try { + func.call(this); + assert(false, assertion_type, description, + "${func} did not throw", {func:func}); + } catch (e) { + if (e instanceof AssertionError) { + throw e; + } + + // Basic sanity-checks on the thrown exception. + assert(typeof e === "object", + assertion_type, description, + "${func} threw ${e} with type ${type}, not an object", + {func:func, e:e, type:typeof e}); + + assert(e !== null, + assertion_type, description, + "${func} threw null, not an object", + {func:func}); + + // Sanity-check our type + assert(typeof type === "number" || + typeof type === "string", + assertion_type, description, + "${type} is not a number or string", + {type:type}); + + var codename_name_map = { + INDEX_SIZE_ERR: 'IndexSizeError', + HIERARCHY_REQUEST_ERR: 'HierarchyRequestError', + WRONG_DOCUMENT_ERR: 'WrongDocumentError', + INVALID_CHARACTER_ERR: 'InvalidCharacterError', + NO_MODIFICATION_ALLOWED_ERR: 'NoModificationAllowedError', + NOT_FOUND_ERR: 'NotFoundError', + NOT_SUPPORTED_ERR: 'NotSupportedError', + INUSE_ATTRIBUTE_ERR: 'InUseAttributeError', + INVALID_STATE_ERR: 'InvalidStateError', + SYNTAX_ERR: 'SyntaxError', + INVALID_MODIFICATION_ERR: 'InvalidModificationError', + NAMESPACE_ERR: 'NamespaceError', + INVALID_ACCESS_ERR: 'InvalidAccessError', + TYPE_MISMATCH_ERR: 'TypeMismatchError', + SECURITY_ERR: 'SecurityError', + NETWORK_ERR: 'NetworkError', + ABORT_ERR: 'AbortError', + URL_MISMATCH_ERR: 'URLMismatchError', + TIMEOUT_ERR: 'TimeoutError', + INVALID_NODE_TYPE_ERR: 'InvalidNodeTypeError', + DATA_CLONE_ERR: 'DataCloneError' + }; + + var name_code_map = { + IndexSizeError: 1, + HierarchyRequestError: 3, + WrongDocumentError: 4, + InvalidCharacterError: 5, + NoModificationAllowedError: 7, + NotFoundError: 8, + NotSupportedError: 9, + InUseAttributeError: 10, + InvalidStateError: 11, + SyntaxError: 12, + InvalidModificationError: 13, + NamespaceError: 14, + InvalidAccessError: 15, + TypeMismatchError: 17, + SecurityError: 18, + NetworkError: 19, + AbortError: 20, + URLMismatchError: 21, + TimeoutError: 23, + InvalidNodeTypeError: 24, + DataCloneError: 25, + + EncodingError: 0, + NotReadableError: 0, + UnknownError: 0, + ConstraintError: 0, + DataError: 0, + TransactionInactiveError: 0, + ReadOnlyError: 0, + VersionError: 0, + OperationError: 0, + NotAllowedError: 0, + OptOutError: 0 + }; + + var code_name_map = {}; + for (var key in name_code_map) { + if (name_code_map[key] > 0) { + code_name_map[name_code_map[key]] = key; + } + } + + var required_props = {}; + var name; + + if (typeof type === "number") { + if (type === 0) { + throw new AssertionError('Test bug: ambiguous DOMException code 0 passed to assert_throws_dom()'); + } + if (type === 22) { + throw new AssertionError('Test bug: QuotaExceededError needs to be tested for using assert_throws_quotaexceedederror()'); + } + if (!(type in code_name_map)) { + throw new AssertionError('Test bug: unrecognized DOMException code "' + type + '" passed to assert_throws_dom()'); + } + name = code_name_map[type]; + required_props.code = type; + } else if (typeof type === "string") { + if (name === "QuotaExceededError") { + throw new AssertionError('Test bug: QuotaExceededError needs to be tested for using assert_throws_quotaexceedederror()'); + } + name = type in codename_name_map ? codename_name_map[type] : type; + if (!(name in name_code_map)) { + throw new AssertionError('Test bug: unrecognized DOMException code name or name "' + type + '" passed to assert_throws_dom()'); + } + + required_props.code = name_code_map[name]; + } + + if (required_props.code === 0 || + ("name" in e && + e.name !== e.name.toUpperCase() && + e.name !== "DOMException")) { + // New style exception: also test the name property. + required_props.name = name; + } + + for (var prop in required_props) { + assert(prop in e && e[prop] == required_props[prop], + assertion_type, description, + "${func} threw ${e} that is not a DOMException " + type + ": property ${prop} is equal to ${actual}, expected ${expected}", + {func:func, e:e, prop:prop, actual:e[prop], expected:required_props[prop]}); + } + + // Check that the exception is from the right global. This check is last + // so more specific, and more informative, checks on the properties can + // happen in case a totally incorrect exception is thrown. + assert(e.constructor === constructor, + assertion_type, description, + "${func} threw an exception from the wrong global", + {func}); + + } + } + + /** + * Assert a `QuotaExceededError` with the expected values is thrown. + * + * There are two ways of calling `assert_throws_quotaexceedederror`: + * + * 1) If the `QuotaExceededError` is expected to come from the + * current global, the first argument should be the function + * expected to throw, the second and a third the expected + * `requested` and `quota` property values, and the fourth, + * optional, argument is the assertion description. + * + * 2) If the `QuotaExceededError` is expected to come from some + * other global, the first argument should be the + * `QuotaExceededError` constructor from that global, the second + * argument should be the function expected to throw, the third + * and fourth the expected `requested` and `quota` property + * values, and the fifth, optional, argument is the assertion + * description. + * + * For the `requested` and `quota` values, instead of `null` or a + * number, the caller can provide a function which determines + * whether the value is acceptable by returning a boolean. + * + */ + function assert_throws_quotaexceedederror(funcOrConstructor, requestedOrFunc, quotaOrRequested, descriptionOrQuota, maybeDescription) + { + let constructor, func, requested, quota, description; + if (funcOrConstructor.name === "QuotaExceededError") { + constructor = funcOrConstructor; + func = requestedOrFunc; + requested = quotaOrRequested; + quota = descriptionOrQuota; + description = maybeDescription; + } else { + constructor = self.QuotaExceededError; + func = funcOrConstructor; + requested = requestedOrFunc; + quota = quotaOrRequested; + description = descriptionOrQuota; + assert(maybeDescription === undefined, + "Too many args passed to no-constructor version of assert_throws_quotaexceedederror"); + } + assert_throws_quotaexceedederror_impl(func, requested, quota, description, "assert_throws_quotaexceedederror", constructor); + } + expose_assert(assert_throws_quotaexceedederror, "assert_throws_quotaexceedederror"); + + /** + * Similar to `assert_throws_quotaexceedederror` but allows + * specifying the assertion type + * (`"assert_throws_quotaexceedederror"` or + * `"promise_rejects_quotaexceedederror"`, in practice). The + * `constructor` argument must be the `QuotaExceededError` + * constructor from the global we expect the exception to come from. + */ + function assert_throws_quotaexceedederror_impl(func, requested, quota, description, assertion_type, constructor) + { + try { + func.call(this); + assert(false, assertion_type, description, "${func} did not throw", + {func}); + } catch (e) { + if (e instanceof AssertionError) { + throw e; + } + + // Basic sanity-checks on the thrown exception. + assert(typeof e === "object", + assertion_type, description, + "${func} threw ${e} with type ${type}, not an object", + {func, e, type:typeof e}); + + assert(e !== null, + assertion_type, description, + "${func} threw null, not an object", + {func}); + + // Sanity-check our requested and quota. + assert(requested === null || + typeof requested === "number" || + typeof requested === "function", + assertion_type, description, + "${requested} is not null, a number, or a function", + {requested}); + assert(quota === null || + typeof quota === "number" || + typeof quota === "function", + assertion_type, description, + "${quota} is not null or a number", + {quota}); + + const required_props = { + code: 22, + name: "QuotaExceededError" + }; + if (typeof requested !== "function") { + required_props.requested = requested; + } + if (typeof quota !== "function") { + required_props.quota = quota; + } + + for (const [prop, expected] of Object.entries(required_props)) { + assert(prop in e && e[prop] == expected, + assertion_type, description, + "${func} threw ${e} that is not a correct QuotaExceededError: property ${prop} is equal to ${actual}, expected ${expected}", + {func, e, prop, actual:e[prop], expected}); + } + + if (typeof requested === "function") { + assert(requested(e.requested), + assertion_type, description, + "${func} threw ${e} that is not a correct QuotaExceededError: requested value ${requested} did not pass the requested predicate", + {func, e, requested}); + } + if (typeof quota === "function") { + assert(quota(e.quota), + assertion_type, description, + "${func} threw ${e} that is not a correct QuotaExceededError: quota value ${quota} did not pass the quota predicate", + {func, e, quota}); + } + + // Check that the exception is from the right global. This check is last + // so more specific, and more informative, checks on the properties can + // happen in case a totally incorrect exception is thrown. + assert(e.constructor === constructor, + assertion_type, description, + "${func} threw an exception from the wrong global", + {func}); + } + } + + /** + * Assert the provided value is thrown. + * + * @param {value} exception The expected exception. + * @param {Function} func Function which should throw. + * @param {string} [description] Error description for the case that the error is not thrown. + */ + function assert_throws_exactly(exception, func, description) + { + assert_throws_exactly_impl(exception, func, description, + "assert_throws_exactly"); + } + expose_assert(assert_throws_exactly, "assert_throws_exactly"); + + /** + * Like assert_throws_exactly but allows specifying the assertion type + * (assert_throws_exactly or promise_rejects_exactly, in practice). + */ + function assert_throws_exactly_impl(exception, func, description, + assertion_type) + { + try { + func.call(this); + assert(false, assertion_type, description, + "${func} did not throw", {func:func}); + } catch (e) { + if (e instanceof AssertionError) { + throw e; + } + + assert(same_value(e, exception), assertion_type, description, + "${func} threw ${e} but we expected it to throw ${exception}", + {func:func, e:e, exception:exception}); + } + } + + /** + * Asserts if called. Used to ensure that a specific codepath is + * not taken e.g. that an error event isn't fired. + * + * @param {string} [description] - Description of the condition being tested. + */ + function assert_unreached(description) { + assert(false, "assert_unreached", description, + "Reached unreachable code"); + } + expose_assert(assert_unreached, "assert_unreached"); + + /** + * @callback AssertFunc + * @param {Any} actual + * @param {Any} expected + * @param {Any[]} args + */ + + /** + * Asserts that ``actual`` matches at least one value of ``expected`` + * according to a comparison defined by ``assert_func``. + * + * Note that tests with multiple allowed pass conditions are bad + * practice unless the spec specifically allows multiple + * behaviours. Test authors should not use this method simply to + * hide UA bugs. + * + * @param {AssertFunc} assert_func - Function to compare actual + * and expected. It must throw when the comparison fails and + * return when the comparison passes. + * @param {Any} actual - Test value. + * @param {Array} expected_array - Array of possible expected values. + * @param {Any[]} args - Additional arguments to pass to ``assert_func``. + */ + function assert_any(assert_func, actual, expected_array, ...args) + { + var errors = []; + var passed = false; + forEach(expected_array, + function(expected) + { + try { + assert_func.apply(this, [actual, expected].concat(args)); + passed = true; + } catch (e) { + errors.push(e.message); + } + }); + if (!passed) { + throw new AssertionError(errors.join("\n\n")); + } + } + // FIXME: assert_any cannot use expose_assert, because assert_wrapper does + // not support nested assert calls (e.g. to assert_func). We need to + // support bypassing assert_wrapper for the inner asserts here. + expose(assert_any, "assert_any"); + + /** + * Assert that a feature is implemented, based on a 'truthy' condition. + * + * This function should be used to early-exit from tests in which there is + * no point continuing without support for a non-optional spec or spec + * feature. For example: + * + * assert_implements(window.Foo, 'Foo is not supported'); + * + * @param {object} condition The truthy value to test + * @param {string} [description] Error description for the case that the condition is not truthy. + */ + function assert_implements(condition, description) { + assert(!!condition, "assert_implements", description); + } + expose_assert(assert_implements, "assert_implements"); + + /** + * Assert that an optional feature is implemented, based on a 'truthy' condition. + * + * This function should be used to early-exit from tests in which there is + * no point continuing without support for an explicitly optional spec or + * spec feature. For example: + * + * assert_implements_optional(video.canPlayType("video/webm"), + * "webm video playback not supported"); + * + * @param {object} condition The truthy value to test + * @param {string} [description] Error description for the case that the condition is not truthy. + */ + function assert_implements_optional(condition, description) { + if (!condition) { + throw new OptionalFeatureUnsupportedError(description); + } + } + expose_assert(assert_implements_optional, "assert_implements_optional"); + + /** + * @class + * + * A single subtest. A Test is not constructed directly but via the + * :js:func:`test`, :js:func:`async_test` or :js:func:`promise_test` functions. + * + * @param {string} name - This must be unique in a given file and must be + * invariant between runs. + * + */ + function Test(name, properties) + { + if (tests.file_is_test && tests.tests.length) { + throw new Error("Tried to create a test with file_is_test"); + } + /** The test name. */ + this.name = name; + + this.phase = (tests.is_aborted || tests.phase === tests.phases.COMPLETE) ? + this.phases.COMPLETE : this.phases.INITIAL; + + /** The test status code.*/ + this.status = this.NOTRUN; + this.timeout_id = null; + this.index = null; + + this.properties = properties || {}; + this.timeout_length = settings.test_timeout; + if (this.timeout_length !== null) { + this.timeout_length *= tests.timeout_multiplier; + } + + /** A message indicating the reason for test failure. */ + this.message = null; + /** Stack trace in case of failure. */ + this.stack = null; + + this.steps = []; + this._is_promise_test = false; + + this.cleanup_callbacks = []; + this._user_defined_cleanup_count = 0; + this._done_callbacks = []; + + if (typeof AbortController === "function") { + this._abortController = new AbortController(); + } + + // Tests declared following harness completion are likely an indication + // of a programming error, but they cannot be reported + // deterministically. + if (tests.phase === tests.phases.COMPLETE) { + return; + } + + tests.push(this); + } + + /** + * Enum of possible test statuses. + * + * :values: + * - ``PASS`` + * - ``FAIL`` + * - ``TIMEOUT`` + * - ``NOTRUN`` + * - ``PRECONDITION_FAILED`` + */ + Test.statuses = { + PASS:0, + FAIL:1, + TIMEOUT:2, + NOTRUN:3, + PRECONDITION_FAILED:4 + }; + + Test.prototype = merge({}, Test.statuses); + + Test.prototype.phases = { + INITIAL:0, + STARTED:1, + HAS_RESULT:2, + CLEANING:3, + COMPLETE:4 + }; + + Test.prototype.status_formats = { + 0: "Pass", + 1: "Fail", + 2: "Timeout", + 3: "Not Run", + 4: "Optional Feature Unsupported", + }; + + Test.prototype.format_status = function() { + return this.status_formats[this.status]; + }; + + Test.prototype.structured_clone = function() + { + if (!this._structured_clone) { + var msg = this.message; + msg = msg ? String(msg) : msg; + this._structured_clone = merge({ + name:String(this.name), + properties:merge({}, this.properties), + phases:merge({}, this.phases) + }, Test.statuses); + } + this._structured_clone.status = this.status; + this._structured_clone.message = this.message; + this._structured_clone.stack = this.stack; + this._structured_clone.index = this.index; + this._structured_clone.phase = this.phase; + return this._structured_clone; + }; + + /** + * Run a single step of an ongoing test. + * + * @param {string} func - Callback function to run as a step. If + * this throws an :js:func:`AssertionError`, or any other + * exception, the :js:class:`Test` status is set to ``FAIL``. + * @param {Object} [this_obj] - The object to use as the this + * value when calling ``func``. Defaults to the :js:class:`Test` object. + */ + Test.prototype.step = function(func, this_obj) + { + if (this.phase > this.phases.STARTED) { + return; + } + + if (settings.debug && this.phase !== this.phases.STARTED) { + console.log("TEST START", this.name); + } + this.phase = this.phases.STARTED; + //If we don't get a result before the harness times out that will be a test timeout + this.set_status(this.TIMEOUT, "Test timed out"); + + tests.started = true; + tests.current_test = this; + tests.notify_test_state(this); + + if (this.timeout_id === null) { + this.set_timeout(); + } + + this.steps.push(func); + + if (arguments.length === 1) { + this_obj = this; + } + + if (settings.debug) { + console.debug("TEST STEP", this.name); + } + + try { + return func.apply(this_obj, Array.prototype.slice.call(arguments, 2)); + } catch (e) { + if (this.phase >= this.phases.HAS_RESULT) { + return; + } + var status = e instanceof OptionalFeatureUnsupportedError ? this.PRECONDITION_FAILED : this.FAIL; + var message = String((typeof e === "object" && e !== null) ? e.message : e); + var stack = e.stack ? e.stack : null; + + this.set_status(status, message, stack); + this.phase = this.phases.HAS_RESULT; + this.done(); + } finally { + this.current_test = null; + } + }; + + /** + * Wrap a function so that it runs as a step of the current test. + * + * This allows creating a callback function that will run as a + * test step. + * + * @example + * let t = async_test("Example"); + * onload = t.step_func(e => { + * assert_equals(e.name, "load"); + * // Mark the test as complete. + * t.done(); + * }) + * + * @param {string} func - Function to run as a step. If this + * throws an :js:func:`AssertionError`, or any other exception, + * the :js:class:`Test` status is set to ``FAIL``. + * @param {Object} [this_obj] - The object to use as the this + * value when calling ``func``. Defaults to the :js:class:`Test` object. + */ + Test.prototype.step_func = function(func, this_obj) + { + var test_this = this; + + if (arguments.length === 1) { + this_obj = test_this; + } + + return function() + { + return test_this.step.apply(test_this, [func, this_obj].concat( + Array.prototype.slice.call(arguments))); + }; + }; + + /** + * Wrap a function so that it runs as a step of the current test, + * and automatically marks the test as complete if the function + * returns without error. + * + * @param {string} func - Function to run as a step. If this + * throws an :js:func:`AssertionError`, or any other exception, + * the :js:class:`Test` status is set to ``FAIL``. If it returns + * without error the status is set to ``PASS``. + * @param {Object} [this_obj] - The object to use as the this + * value when calling `func`. Defaults to the :js:class:`Test` object. + */ + Test.prototype.step_func_done = function(func, this_obj) + { + var test_this = this; + + if (arguments.length === 1) { + this_obj = test_this; + } + + return function() + { + if (func) { + test_this.step.apply(test_this, [func, this_obj].concat( + Array.prototype.slice.call(arguments))); + } + test_this.done(); + }; + }; + + /** + * Return a function that automatically sets the current test to + * ``FAIL`` if it's called. + * + * @param {string} [description] - Error message to add to assert + * in case of failure. + * + */ + Test.prototype.unreached_func = function(description) + { + return this.step_func(function() { + assert_unreached(description); + }); + }; + + /** + * Run a function as a step of the test after a given timeout. + * + * This multiplies the timeout by the global timeout multiplier to + * account for the expected execution speed of the current test + * environment. For example ``test.step_timeout(f, 2000)`` with a + * timeout multiplier of 2 will wait for 4000ms before calling ``f``. + * + * In general it's encouraged to use :js:func:`Test.step_wait` or + * :js:func:`step_wait_func` in preference to this function where possible, + * as they provide better test performance. + * + * @param {Function} func - Function to run as a test + * step. + * @param {number} timeout - Time in ms to wait before running the + * test step. The actual wait time is ``timeout`` x + * ``timeout_multiplier``. + * + */ + Test.prototype.step_timeout = function(func, timeout) { + var test_this = this; + var args = Array.prototype.slice.call(arguments, 2); + var local_set_timeout = typeof global_scope.setTimeout === "undefined" ? fake_set_timeout : setTimeout; + return local_set_timeout(this.step_func(function() { + return func.apply(test_this, args); + }), timeout * tests.timeout_multiplier); + }; + + /** + * Poll for a function to return true, and call a callback + * function once it does, or assert if a timeout is + * reached. This is preferred over a simple step_timeout + * whenever possible since it allows the timeout to be longer + * to reduce intermittents without compromising test execution + * speed when the condition is quickly met. + * + * @param {Function} cond A function taking no arguments and + * returning a boolean or a Promise. The callback is + * called when this function returns true, or the + * returned Promise is resolved with true. + * @param {Function} func A function taking no arguments to call once + * the condition is met. + * @param {string} [description] Error message to add to assert in case of + * failure. + * @param {number} timeout Timeout in ms. This is multiplied by the global + * timeout_multiplier + * @param {number} interval Polling interval in ms + * + */ + Test.prototype.step_wait_func = function(cond, func, description, + timeout=3000, interval=100) { + var timeout_full = timeout * tests.timeout_multiplier; + var remaining = Math.ceil(timeout_full / interval); + var test_this = this; + var local_set_timeout = typeof global_scope.setTimeout === 'undefined' ? fake_set_timeout : setTimeout; + + const step = test_this.step_func((result) => { + if (result) { + func(); + } else { + if (remaining === 0) { + assert(false, "step_wait_func", description, + "Timed out waiting on condition"); + } + remaining--; + local_set_timeout(wait_for_inner, interval); + } + }); + + var wait_for_inner = test_this.step_func(() => { + Promise.resolve(cond()).then( + step, + test_this.unreached_func("step_wait_func")); + }); + + wait_for_inner(); + }; + + /** + * Poll for a function to return true, and invoke a callback + * followed by this.done() once it does, or assert if a timeout + * is reached. This is preferred over a simple step_timeout + * whenever possible since it allows the timeout to be longer + * to reduce intermittents without compromising test execution speed + * when the condition is quickly met. + * + * @example + * async_test(t => { + * const popup = window.open("resources/coop-coep.py?coop=same-origin&coep=&navigate=about:blank"); + * t.add_cleanup(() => popup.close()); + * assert_equals(window, popup.opener); + * + * popup.onload = t.step_func(() => { + * assert_true(popup.location.href.endsWith("&navigate=about:blank")); + * // Use step_wait_func_done as about:blank cannot message back. + * t.step_wait_func_done(() => popup.location.href === "about:blank"); + * }); + * }, "Navigating a popup to about:blank"); + * + * @param {Function} cond A function taking no arguments and + * returning a boolean or a Promise. The callback is + * called when this function returns true, or the + * returned Promise is resolved with true. + * @param {Function} func A function taking no arguments to call once + * the condition is met. + * @param {string} [description] Error message to add to assert in case of + * failure. + * @param {number} timeout Timeout in ms. This is multiplied by the global + * timeout_multiplier + * @param {number} interval Polling interval in ms + * + */ + Test.prototype.step_wait_func_done = function(cond, func, description, + timeout=3000, interval=100) { + this.step_wait_func(cond, () => { + if (func) { + func(); + } + this.done(); + }, description, timeout, interval); + }; + + /** + * Poll for a function to return true, and resolve a promise + * once it does, or assert if a timeout is reached. This is + * preferred over a simple step_timeout whenever possible + * since it allows the timeout to be longer to reduce + * intermittents without compromising test execution speed + * when the condition is quickly met. + * + * @example + * promise_test(async t => { + * // … + * await t.step_wait(() => frame.contentDocument === null, "Frame navigated to a cross-origin document"); + * // … + * }, ""); + * + * @param {Function} cond A function taking no arguments and + * returning a boolean or a Promise. + * @param {string} [description] Error message to add to assert in case of + * failure. + * @param {number} timeout Timeout in ms. This is multiplied by the global + * timeout_multiplier + * @param {number} interval Polling interval in ms + * @returns {Promise} Promise resolved once cond is met. + * + */ + Test.prototype.step_wait = function(cond, description, timeout=3000, interval=100) { + return new Promise(resolve => { + this.step_wait_func(cond, resolve, description, timeout, interval); + }); + }; + + /* + * Private method for registering cleanup functions. `testharness.js` + * internals should use this method instead of the public `add_cleanup` + * method in order to hide implementation details from the harness status + * message in the case errors. + */ + Test.prototype._add_cleanup = function(callback) { + this.cleanup_callbacks.push(callback); + }; + + /** + * Schedule a function to be run after the test result is known, regardless + * of passing or failing state. + * + * The behavior of this function will not + * influence the result of the test, but if an exception is thrown, the + * test harness will report an error. + * + * @param {Function} callback - The cleanup function to run. This + * is called with no arguments. + */ + Test.prototype.add_cleanup = function(callback) { + this._user_defined_cleanup_count += 1; + this._add_cleanup(callback); + }; + + Test.prototype.set_timeout = function() + { + if (this.timeout_length !== null) { + var this_obj = this; + this.timeout_id = setTimeout(function() + { + this_obj.timeout(); + }, this.timeout_length); + } + }; + + Test.prototype.set_status = function(status, message, stack) + { + this.status = status; + this.message = message; + this.stack = stack ? stack : null; + }; + + /** + * Manually set the test status to ``TIMEOUT``. + */ + Test.prototype.timeout = function() + { + this.timeout_id = null; + this.set_status(this.TIMEOUT, "Test timed out"); + this.phase = this.phases.HAS_RESULT; + this.done(); + }; + + /** + * Manually set the test status to ``TIMEOUT``. + * + * Alias for `Test.timeout <#Test.timeout>`_. + */ + Test.prototype.force_timeout = function() { + return this.timeout(); + }; + + /** + * Mark the test as complete. + * + * This sets the test status to ``PASS`` if no other status was + * already recorded. Any subsequent attempts to run additional + * test steps will be ignored. + * + * After setting the test status any test cleanup functions will + * be run. + */ + Test.prototype.done = function() + { + if (this.phase >= this.phases.CLEANING) { + return; + } + + if (this.phase <= this.phases.STARTED) { + this.set_status(this.PASS, null); + } + + if (global_scope.clearTimeout) { + clearTimeout(this.timeout_id); + } + + if (settings.debug) { + console.log("TEST DONE", + this.status, + this.name); + } + + this.cleanup(); + }; + + function add_test_done_callback(test, callback) + { + if (test.phase === test.phases.COMPLETE) { + callback(); + return; + } + + test._done_callbacks.push(callback); + } + + /* + * Invoke all specified cleanup functions. If one or more produce an error, + * the context is in an unpredictable state, so all further testing should + * be cancelled. + */ + Test.prototype.cleanup = function() { + var errors = []; + var bad_value_count = 0; + function on_error(e) { + errors.push(e); + // Abort tests immediately so that tests declared within subsequent + // cleanup functions are not run. + tests.abort(); + } + var this_obj = this; + var results = []; + + this.phase = this.phases.CLEANING; + + if (this._abortController) { + this._abortController.abort("Test cleanup"); + } + + forEach(this.cleanup_callbacks, + function(cleanup_callback) { + var result; + + try { + result = cleanup_callback(); + } catch (e) { + on_error(e); + return; + } + + if (!is_valid_cleanup_result(this_obj, result)) { + bad_value_count += 1; + // Abort tests immediately so that tests declared + // within subsequent cleanup functions are not run. + tests.abort(); + } + + results.push(result); + }); + + if (!this._is_promise_test) { + cleanup_done(this_obj, errors, bad_value_count); + } else { + all_async(results, + function(result, done) { + if (result && typeof result.then === "function") { + result + .then(null, on_error) + .then(done); + } else { + done(); + } + }, + function() { + cleanup_done(this_obj, errors, bad_value_count); + }); + } + }; + + /* + * Determine if the return value of a cleanup function is valid for a given + * test. Any test may return the value `undefined`. Tests created with + * `promise_test` may alternatively return "thenable" object values. + */ + function is_valid_cleanup_result(test, result) { + if (result === undefined) { + return true; + } + + if (test._is_promise_test) { + return result && typeof result.then === "function"; + } + + return false; + } + + function cleanup_done(test, errors, bad_value_count) { + if (errors.length || bad_value_count) { + var total = test._user_defined_cleanup_count; + + tests.status.status = tests.status.ERROR; + tests.status.stack = null; + tests.status.message = "Test named '" + test.name + + "' specified " + total + + " 'cleanup' function" + (total > 1 ? "s" : ""); + + if (errors.length) { + tests.status.message += ", and " + errors.length + " failed"; + tests.status.stack = ((typeof errors[0] === "object" && + errors[0].hasOwnProperty("stack")) ? + errors[0].stack : null); + } + + if (bad_value_count) { + var type = test._is_promise_test ? + "non-thenable" : "non-undefined"; + tests.status.message += ", and " + bad_value_count + + " returned a " + type + " value"; + } + + tests.status.message += "."; + } + + test.phase = test.phases.COMPLETE; + tests.result(test); + forEach(test._done_callbacks, + function(callback) { + callback(); + }); + test._done_callbacks.length = 0; + } + + /** + * Gives an AbortSignal that will be aborted when the test finishes. + */ + Test.prototype.get_signal = function() { + if (!this._abortController) { + throw new Error("AbortController is not supported in this browser"); + } + return this._abortController.signal; + }; + + /** + * A RemoteTest object mirrors a Test object on a remote worker. The + * associated RemoteWorker updates the RemoteTest object in response to + * received events. In turn, the RemoteTest object replicates these events + * on the local document. This allows listeners (test result reporting + * etc..) to transparently handle local and remote events. + */ + function RemoteTest(clone) { + var this_obj = this; + Object.keys(clone).forEach( + function(key) { + this_obj[key] = clone[key]; + }); + this.index = null; + this.phase = this.phases.INITIAL; + this.update_state_from(clone); + this._done_callbacks = []; + tests.push(this); + } + + RemoteTest.prototype.structured_clone = function() { + var clone = {}; + Object.keys(this).forEach( + (function(key) { + var value = this[key]; + // `RemoteTest` instances are responsible for managing + // their own "done" callback functions, so those functions + // are not relevant in other execution contexts. Because of + // this (and because Function values cannot be serialized + // for cross-realm transmittance), the property should not + // be considered when cloning instances. + if (key === '_done_callbacks' ) { + return; + } + + if (typeof value === "object" && value !== null) { + clone[key] = merge({}, value); + } else { + clone[key] = value; + } + }).bind(this)); + clone.phases = merge({}, this.phases); + return clone; + }; + + /** + * `RemoteTest` instances are objects which represent tests running in + * another realm. They do not define "cleanup" functions (if necessary, + * such functions are defined on the associated `Test` instance within the + * external realm). However, `RemoteTests` may have "done" callbacks (e.g. + * as attached by the `Tests` instance responsible for tracking the overall + * test status in the parent realm). The `cleanup` method delegates to + * `done` in order to ensure that such callbacks are invoked following the + * completion of the `RemoteTest`. + */ + RemoteTest.prototype.cleanup = function() { + this.done(); + }; + RemoteTest.prototype.phases = Test.prototype.phases; + RemoteTest.prototype.update_state_from = function(clone) { + this.status = clone.status; + this.message = clone.message; + this.stack = clone.stack; + if (this.phase === this.phases.INITIAL) { + this.phase = this.phases.STARTED; + } + }; + RemoteTest.prototype.done = function() { + this.phase = this.phases.COMPLETE; + + forEach(this._done_callbacks, + function(callback) { + callback(); + }); + }; + + RemoteTest.prototype.format_status = function() { + return Test.prototype.status_formats[this.status]; + }; + + /* + * A RemoteContext listens for test events from a remote test context, such + * as another window or a worker. These events are then used to construct + * and maintain RemoteTest objects that mirror the tests running in the + * remote context. + * + * An optional third parameter can be used as a predicate to filter incoming + * MessageEvents. + */ + function RemoteContext(remote, message_target, message_filter) { + this.running = true; + this.started = false; + this.tests = new Array(); + this.early_exception = null; + + var this_obj = this; + // If remote context is cross origin assigning to onerror is not + // possible, so silently catch those errors. + try { + remote.onerror = function(error) { this_obj.remote_error(error); }; + } catch (e) { + // Ignore. + } + + // Keeping a reference to the remote object and the message handler until + // remote_done() is seen prevents the remote object and its message channel + // from going away before all the messages are dispatched. + this.remote = remote; + this.message_target = message_target; + this.message_handler = function(message) { + var passesFilter = !message_filter || message_filter(message); + // The reference to the `running` property in the following + // condition is unnecessary because that value is only set to + // `false` after the `message_handler` function has been + // unsubscribed. + // TODO: Simplify the condition by removing the reference. + if (this_obj.running && message.data && passesFilter && + (message.data.type in this_obj.message_handlers)) { + this_obj.message_handlers[message.data.type].call(this_obj, message.data); + } + }; + + if (self.Promise) { + this.done = new Promise(function(resolve) { + this_obj.doneResolve = resolve; + }); + } + + this.message_target.addEventListener("message", this.message_handler); + } + + RemoteContext.prototype.remote_error = function(error) { + if (error.preventDefault) { + error.preventDefault(); + } + + // Defer interpretation of errors until the testing protocol has + // started and the remote test's `allow_uncaught_exception` property + // is available. + if (!this.started) { + this.early_exception = error; + } else if (!this.allow_uncaught_exception) { + this.report_uncaught(error); + } + }; + + RemoteContext.prototype.report_uncaught = function(error) { + var message = error.message || String(error); + var filename = (error.filename ? " " + error.filename: ""); + // FIXME: Display remote error states separately from main document + // error state. + tests.set_status(tests.status.ERROR, + "Error in remote" + filename + ": " + message, + error.stack); + }; + + RemoteContext.prototype.start = function(data) { + this.started = true; + this.allow_uncaught_exception = data.properties.allow_uncaught_exception; + + if (this.early_exception && !this.allow_uncaught_exception) { + this.report_uncaught(this.early_exception); + } + }; + + RemoteContext.prototype.test_state = function(data) { + var remote_test = this.tests[data.test.index]; + if (!remote_test) { + remote_test = new RemoteTest(data.test); + this.tests[data.test.index] = remote_test; + } + remote_test.update_state_from(data.test); + tests.notify_test_state(remote_test); + }; + + RemoteContext.prototype.test_done = function(data) { + var remote_test = this.tests[data.test.index]; + remote_test.update_state_from(data.test); + remote_test.done(); + tests.result(remote_test); + }; + + RemoteContext.prototype.remote_done = function(data) { + if (tests.status.status === null && + data.status.status !== data.status.OK) { + tests.set_status(data.status.status, data.status.message, data.status.stack); + } + + for (let assert of data.asserts) { + var record = new AssertRecord(); + record.assert_name = assert.assert_name; + record.args = assert.args; + record.test = assert.test != null ? this.tests[assert.test.index] : null; + record.status = assert.status; + record.stack = assert.stack; + tests.asserts_run.push(record); + } + + this.message_target.removeEventListener("message", this.message_handler); + this.running = false; + + // If remote context is cross origin assigning to onerror is not + // possible, so silently catch those errors. + try { + this.remote.onerror = null; + } catch (e) { + // Ignore. + } + + this.remote = null; + this.message_target = null; + if (this.doneResolve) { + this.doneResolve(); + } + + if (tests.all_done()) { + tests.complete(); + } + }; + + RemoteContext.prototype.message_handlers = { + start: RemoteContext.prototype.start, + test_state: RemoteContext.prototype.test_state, + result: RemoteContext.prototype.test_done, + complete: RemoteContext.prototype.remote_done + }; + + /** + * @class + * Status of the overall harness + */ + function TestsStatus() + { + /** The status code */ + this.status = null; + /** Message in case of failure */ + this.message = null; + /** Stack trace in case of an exception. */ + this.stack = null; + } + + /** + * Enum of possible harness statuses. + * + * :values: + * - ``OK`` + * - ``ERROR`` + * - ``TIMEOUT`` + * - ``PRECONDITION_FAILED`` + */ + TestsStatus.statuses = { + OK:0, + ERROR:1, + TIMEOUT:2, + PRECONDITION_FAILED:3 + }; + + TestsStatus.prototype = merge({}, TestsStatus.statuses); + + TestsStatus.prototype.formats = { + 0: "OK", + 1: "Error", + 2: "Timeout", + 3: "Optional Feature Unsupported" + }; + + TestsStatus.prototype.structured_clone = function() + { + if (!this._structured_clone) { + var msg = this.message; + msg = msg ? String(msg) : msg; + this._structured_clone = merge({ + status:this.status, + message:msg, + stack:this.stack + }, TestsStatus.statuses); + } + return this._structured_clone; + }; + + TestsStatus.prototype.format_status = function() { + return this.formats[this.status]; + }; + + /** + * @class + * Record of an assert that ran. + * + * @param {Test} test - The test which ran the assert. + * @param {string} assert_name - The function name of the assert. + * @param {Any} args - The arguments passed to the assert function. + */ + function AssertRecord(test, assert_name, args = []) { + /** Name of the assert that ran */ + this.assert_name = assert_name; + /** Test that ran the assert */ + this.test = test; + // Avoid keeping complex objects alive + /** Stringification of the arguments that were passed to the assert function */ + this.args = args.map(x => format_value(x).replace(/\n/g, " ")); + /** Status of the assert */ + this.status = null; + } + + AssertRecord.prototype.structured_clone = function() { + return { + assert_name: this.assert_name, + test: this.test ? this.test.structured_clone() : null, + args: this.args, + status: this.status, + }; + }; + + function Tests() + { + this.tests = []; + this.num_pending = 0; + + this.phases = { + INITIAL:0, + SETUP:1, + HAVE_TESTS:2, + HAVE_RESULTS:3, + COMPLETE:4 + }; + this.phase = this.phases.INITIAL; + + this.properties = {}; + + this.wait_for_finish = false; + this.processing_callbacks = false; + + this.allow_uncaught_exception = false; + + this.file_is_test = false; + // This value is lazily initialized in order to avoid introducing a + // dependency on ECMAScript 2015 Promises to all tests. + this.promise_tests = null; + this.promise_setup_called = false; + + this.timeout_multiplier = 1; + this.timeout_length = test_environment.test_timeout(); + this.timeout_id = null; + + this.start_callbacks = []; + this.test_state_callbacks = []; + this.test_done_callbacks = []; + this.all_done_callbacks = []; + + this.hide_test_state = false; + this.remotes = []; + + this.current_test = null; + this.asserts_run = []; + + // Track whether output is enabled, and thus whether or not we should + // track asserts. + // + // On workers we don't get properties set from testharnessreport.js, so + // we don't know whether or not to track asserts. To avoid the + // resulting performance hit, we assume we are not meant to. This means + // that assert tracking does not function on workers. + this.output = settings.output && 'document' in global_scope; + + this.status = new TestsStatus(); + + var this_obj = this; + + test_environment.add_on_loaded_callback(function() { + if (this_obj.all_done()) { + this_obj.complete(); + } + }); + + this.set_timeout(); + } + + Tests.prototype.setup = function(func, properties) + { + if (this.phase >= this.phases.HAVE_RESULTS) { + return; + } + + if (this.phase < this.phases.SETUP) { + this.phase = this.phases.SETUP; + } + + this.properties = properties; + + for (var p in properties) { + if (properties.hasOwnProperty(p)) { + var value = properties[p]; + if (p === "allow_uncaught_exception") { + this.allow_uncaught_exception = value; + } else if (p === "explicit_done" && value) { + this.wait_for_finish = true; + } else if (p === "explicit_timeout" && value) { + this.timeout_length = null; + if (this.timeout_id) + { + clearTimeout(this.timeout_id); + } + } else if (p === "single_test" && value) { + this.set_file_is_test(); + } else if (p === "timeout_multiplier") { + this.timeout_multiplier = value; + if (this.timeout_length) { + this.timeout_length *= this.timeout_multiplier; + } + } else if (p === "hide_test_state") { + this.hide_test_state = value; + } else if (p === "output") { + this.output = value; + } else if (p === "debug") { + settings.debug = value; + } + } + } + + if (func) { + try { + func(); + } catch (e) { + this.status.status = e instanceof OptionalFeatureUnsupportedError ? this.status.PRECONDITION_FAILED : this.status.ERROR; + this.status.message = String(e); + this.status.stack = e.stack ? e.stack : null; + this.complete(); + } + } + this.set_timeout(); + }; + + Tests.prototype.set_file_is_test = function() { + if (this.tests.length > 0) { + throw new Error("Tried to set file as test after creating a test"); + } + this.wait_for_finish = true; + this.file_is_test = true; + // Create the test, which will add it to the list of tests + tests.current_test = async_test(); + }; + + Tests.prototype.set_status = function(status, message, stack) + { + this.status.status = status; + this.status.message = message; + this.status.stack = stack ? stack : null; + }; + + Tests.prototype.set_timeout = function() { + if (global_scope.clearTimeout) { + var this_obj = this; + clearTimeout(this.timeout_id); + if (this.timeout_length !== null) { + this.timeout_id = setTimeout(function() { + this_obj.timeout(); + }, this.timeout_length); + } + } + }; + + Tests.prototype.timeout = function() { + var test_in_cleanup = null; + + if (this.status.status === null) { + forEach(this.tests, + function(test) { + // No more than one test is expected to be in the + // "CLEANUP" phase at any time + if (test.phase === test.phases.CLEANING) { + test_in_cleanup = test; + } + + test.phase = test.phases.COMPLETE; + }); + + // Timeouts that occur while a test is in the "cleanup" phase + // indicate that some global state was not properly reverted. This + // invalidates the overall test execution, so the timeout should be + // reported as an error and cancel the execution of any remaining + // tests. + if (test_in_cleanup) { + this.status.status = this.status.ERROR; + this.status.message = "Timeout while running cleanup for " + + "test named \"" + test_in_cleanup.name + "\"."; + tests.status.stack = null; + } else { + this.status.status = this.status.TIMEOUT; + } + } + + this.complete(); + }; + + Tests.prototype.end_wait = function() + { + this.wait_for_finish = false; + if (this.all_done()) { + this.complete(); + } + }; + + Tests.prototype.push = function(test) + { + if (this.phase === this.phases.COMPLETE) { + return; + } + if (this.phase < this.phases.HAVE_TESTS) { + this.start(); + } + this.num_pending++; + test.index = this.tests.push(test) - 1; + this.notify_test_state(test); + }; + + Tests.prototype.notify_test_state = function(test) { + var this_obj = this; + forEach(this.test_state_callbacks, + function(callback) { + callback(test, this_obj); + }); + }; + + Tests.prototype.all_done = function() { + return (this.tests.length > 0 || this.remotes.length > 0) && + test_environment.all_loaded && + (this.num_pending === 0 || this.is_aborted) && !this.wait_for_finish && + !this.processing_callbacks && + !this.remotes.some(function(w) { return w.running; }); + }; + + Tests.prototype.start = function() { + this.phase = this.phases.HAVE_TESTS; + this.notify_start(); + }; + + Tests.prototype.notify_start = function() { + var this_obj = this; + forEach (this.start_callbacks, + function(callback) + { + callback(this_obj.properties); + }); + }; + + Tests.prototype.result = function(test) + { + // If the harness has already transitioned beyond the `HAVE_RESULTS` + // phase, subsequent tests should not cause it to revert. + if (this.phase <= this.phases.HAVE_RESULTS) { + this.phase = this.phases.HAVE_RESULTS; + } + this.num_pending--; + this.notify_result(test); + }; + + Tests.prototype.notify_result = function(test) { + var this_obj = this; + this.processing_callbacks = true; + forEach(this.test_done_callbacks, + function(callback) + { + callback(test, this_obj); + }); + this.processing_callbacks = false; + if (this_obj.all_done()) { + this_obj.complete(); + } + }; + + Tests.prototype.complete = function() { + if (this.phase === this.phases.COMPLETE) { + return; + } + var this_obj = this; + var all_complete = function() { + this_obj.phase = this_obj.phases.COMPLETE; + this_obj.notify_complete(); + }; + var incomplete = filter(this.tests, + function(test) { + return test.phase < test.phases.COMPLETE; + }); + + /** + * To preserve legacy behavior, overall test completion must be + * signaled synchronously. + */ + if (incomplete.length === 0) { + all_complete(); + return; + } + + all_async(incomplete, + function(test, testDone) + { + if (test.phase === test.phases.INITIAL) { + test.phase = test.phases.HAS_RESULT; + test.done(); + testDone(); + } else { + add_test_done_callback(test, testDone); + test.cleanup(); + } + }, + all_complete); + }; + + Tests.prototype.set_assert = function(assert_name, args) { + this.asserts_run.push(new AssertRecord(this.current_test, assert_name, args)); + }; + + Tests.prototype.set_assert_status = function(index, status, stack) { + let assert_record = this.asserts_run[index]; + assert_record.status = status; + assert_record.stack = stack; + }; + + /** + * Update the harness status to reflect an unrecoverable harness error that + * should cancel all further testing. Update all previously-defined tests + * which have not yet started to indicate that they will not be executed. + */ + Tests.prototype.abort = function() { + this.status.status = this.status.ERROR; + this.is_aborted = true; + + forEach(this.tests, + function(test) { + if (test.phase === test.phases.INITIAL) { + test.phase = test.phases.COMPLETE; + } + }); + }; + + /* + * Determine if any tests share the same `name` property. Return an array + * containing the names of any such duplicates. + */ + Tests.prototype.find_duplicates = function() { + var names = Object.create(null); + var duplicates = []; + + forEach (this.tests, + function(test) + { + if (test.name in names && duplicates.indexOf(test.name) === -1) { + duplicates.push(test.name); + } + names[test.name] = true; + }); + + return duplicates; + }; + + function code_unit_str(char) { + return 'U+' + char.charCodeAt(0).toString(16); + } + + function sanitize_unpaired_surrogates(str) { + return str.replace( + /([\ud800-\udbff]+)(?![\udc00-\udfff])|(^|[^\ud800-\udbff])([\udc00-\udfff]+)/g, + function(_, low, prefix, high) { + var output = prefix || ""; // prefix may be undefined + var string = low || high; // only one of these alternates can match + for (var i = 0; i < string.length; i++) { + output += code_unit_str(string[i]); + } + return output; + }); + } + + function sanitize_all_unpaired_surrogates(tests) { + forEach (tests, + function (test) + { + var sanitized = sanitize_unpaired_surrogates(test.name); + + if (test.name !== sanitized) { + test.name = sanitized; + delete test._structured_clone; + } + }); + } + + Tests.prototype.notify_complete = function() { + var this_obj = this; + var duplicates; + + if (this.status.status === null) { + duplicates = this.find_duplicates(); + + // Some transports adhere to UTF-8's restriction on unpaired + // surrogates. Sanitize the titles so that the results can be + // consistently sent via all transports. + sanitize_all_unpaired_surrogates(this.tests); + + // Test names are presumed to be unique within test files--this + // allows consumers to use them for identification purposes. + // Duplicated names violate this expectation and should therefore + // be reported as an error. + if (duplicates.length) { + this.status.status = this.status.ERROR; + this.status.message = + duplicates.length + ' duplicate test name' + + (duplicates.length > 1 ? 's' : '') + ': "' + + duplicates.join('", "') + '"'; + } else { + this.status.status = this.status.OK; + } + } + + forEach (this.all_done_callbacks, + function(callback) + { + callback(this_obj.tests, this_obj.status, this_obj.asserts_run); + }); + }; + + /* + * Constructs a RemoteContext that tracks tests from a specific worker. + */ + Tests.prototype.create_remote_worker = function(worker) { + var message_port; + + if (is_service_worker(worker)) { + message_port = navigator.serviceWorker; + worker.postMessage({type: "connect"}); + } else if (is_shared_worker(worker)) { + message_port = worker.port; + message_port.start(); + } else { + message_port = worker; + } + + return new RemoteContext(worker, message_port); + }; + + /* + * Constructs a RemoteContext that tracks tests from a specific window. + */ + Tests.prototype.create_remote_window = function(remote) { + remote.postMessage({type: "getmessages"}, "*"); + return new RemoteContext( + remote, + window, + function(msg) { + return msg.source === remote; + } + ); + }; + + Tests.prototype.fetch_tests_from_worker = function(worker) { + if (this.phase >= this.phases.COMPLETE) { + return; + } + + var remoteContext = this.create_remote_worker(worker); + this.remotes.push(remoteContext); + return remoteContext.done; + }; + + /** + * Get test results from a worker and include them in the current test. + * + * @param {Worker|SharedWorker|ServiceWorker|MessagePort} port - + * Either a worker object or a port connected to a worker which is + * running tests.. + * @returns {Promise} - A promise that's resolved once all the remote tests are complete. + */ + function fetch_tests_from_worker(port) { + return tests.fetch_tests_from_worker(port); + } + expose(fetch_tests_from_worker, 'fetch_tests_from_worker'); + + Tests.prototype.fetch_tests_from_window = function(remote) { + if (this.phase >= this.phases.COMPLETE) { + return; + } + + var remoteContext = this.create_remote_window(remote); + this.remotes.push(remoteContext); + return remoteContext.done; + }; + + /** + * Aggregate tests from separate windows or iframes + * into the current document as if they were all part of the same test file. + * + * The document of the second window (or iframe) should include + * ``testharness.js``, but not ``testharnessreport.js``, and use + * :js:func:`test`, :js:func:`async_test`, and :js:func:`promise_test` in + * the usual manner. + * + * @param {Window} window - The window to fetch tests from. + */ + function fetch_tests_from_window(window) { + return tests.fetch_tests_from_window(window); + } + expose(fetch_tests_from_window, 'fetch_tests_from_window'); + + /** + * Get test results from a shadow realm and include them in the current test. + * + * @param {ShadowRealm} realm - A shadow realm also running the test harness + * @returns {Promise} - A promise that's resolved once all the remote tests are complete. + */ + function fetch_tests_from_shadow_realm(realm) { + var chan = new MessageChannel(); + function receiveMessage(msg_json) { + chan.port1.postMessage(JSON.parse(msg_json)); + } + var done = tests.fetch_tests_from_worker(chan.port2); + realm.evaluate("begin_shadow_realm_tests")(receiveMessage); + chan.port2.start(); + return done; + } + expose(fetch_tests_from_shadow_realm, 'fetch_tests_from_shadow_realm'); + + /** + * Begin running tests in this shadow realm test harness. + * + * To be called after all tests have been loaded; it is an error to call + * this more than once or in a non-Shadow Realm environment + * + * @param {Function} postMessage - A function to send test updates to the + * incubating realm-- accepts JSON-encoded messages in the format used by + * RemoteContext + */ + function begin_shadow_realm_tests(postMessage) { + if (!(test_environment instanceof ShadowRealmTestEnvironment)) { + throw new Error("begin_shadow_realm_tests called in non-Shadow Realm environment"); + } + + test_environment.begin(function (msg) { + postMessage(JSON.stringify(msg)); + }); + } + expose(begin_shadow_realm_tests, 'begin_shadow_realm_tests'); + + /** + * Timeout the tests. + * + * This only has an effect when ``explicit_timeout`` has been set + * in :js:func:`setup`. In other cases any call is a no-op. + * + */ + function timeout() { + if (tests.timeout_length === null) { + tests.timeout(); + } + } + expose(timeout, 'timeout'); + + /** + * Add a callback that's triggered when the first :js:class:`Test` is created. + * + * @param {Function} callback - Callback function. This is called + * without arguments. + */ + function add_start_callback(callback) { + tests.start_callbacks.push(callback); + } + + /** + * Add a callback that's triggered when a test state changes. + * + * @param {Function} callback - Callback function, called with the + * :js:class:`Test` as the only argument. + */ + function add_test_state_callback(callback) { + tests.test_state_callbacks.push(callback); + } + + /** + * Add a callback that's triggered when a test result is received. + * + * @param {Function} callback - Callback function, called with the + * :js:class:`Test` as the only argument. + */ + function add_result_callback(callback) { + tests.test_done_callbacks.push(callback); + } + + /** + * Add a callback that's triggered when all tests are complete. + * + * @param {Function} callback - Callback function, called with an + * array of :js:class:`Test` objects, a :js:class:`TestsStatus` + * object and an array of :js:class:`AssertRecord` objects. If the + * debug setting is ``false`` the final argument will be an empty + * array. + * + * For performance reasons asserts are only tracked when the debug + * setting is ``true``. In other cases the array of asserts will be + * empty. + */ + function add_completion_callback(callback) { + tests.all_done_callbacks.push(callback); + } + + expose(add_start_callback, 'add_start_callback'); + expose(add_test_state_callback, 'add_test_state_callback'); + expose(add_result_callback, 'add_result_callback'); + expose(add_completion_callback, 'add_completion_callback'); + + function remove(array, item) { + var index = array.indexOf(item); + if (index > -1) { + array.splice(index, 1); + } + } + + function remove_start_callback(callback) { + remove(tests.start_callbacks, callback); + } + + function remove_test_state_callback(callback) { + remove(tests.test_state_callbacks, callback); + } + + function remove_result_callback(callback) { + remove(tests.test_done_callbacks, callback); + } + + function remove_completion_callback(callback) { + remove(tests.all_done_callbacks, callback); + } + + /* + * Output listener + */ + + function Output() { + this.output_document = document; + this.output_node = null; + this.enabled = settings.output; + this.phase = this.INITIAL; + } + + Output.prototype.INITIAL = 0; + Output.prototype.STARTED = 1; + Output.prototype.HAVE_RESULTS = 2; + Output.prototype.COMPLETE = 3; + + Output.prototype.setup = function(properties) { + if (this.phase > this.INITIAL) { + return; + } + + //If output is disabled in testharnessreport.js the test shouldn't be + //able to override that + this.enabled = this.enabled && (properties.hasOwnProperty("output") ? + properties.output : settings.output); + }; + + Output.prototype.init = function(properties) { + if (this.phase >= this.STARTED) { + return; + } + if (properties.output_document) { + this.output_document = properties.output_document; + } else { + this.output_document = document; + } + this.phase = this.STARTED; + }; + + Output.prototype.resolve_log = function() { + var output_document; + if (this.output_node) { + return; + } + if (typeof this.output_document === "function") { + output_document = this.output_document.apply(undefined); + } else { + output_document = this.output_document; + } + if (!output_document) { + return; + } + var node = output_document.getElementById("log"); + if (!node) { + if (output_document.readyState === "loading") { + return; + } + node = output_document.createElementNS("http://www.w3.org/1999/xhtml", "div"); + node.id = "log"; + if (output_document.body) { + output_document.body.appendChild(node); + } else { + var root = output_document.documentElement; + var is_html = (root && + root.namespaceURI === "http://www.w3.org/1999/xhtml" && + root.localName === "html"); + var is_svg = (output_document.defaultView && + "SVGSVGElement" in output_document.defaultView && + root instanceof output_document.defaultView.SVGSVGElement); + if (is_svg) { + var foreignObject = output_document.createElementNS("http://www.w3.org/2000/svg", "foreignObject"); + foreignObject.setAttribute("width", "100%"); + foreignObject.setAttribute("height", "100%"); + root.appendChild(foreignObject); + foreignObject.appendChild(node); + } else if (is_html) { + root.appendChild(output_document.createElementNS("http://www.w3.org/1999/xhtml", "body")) + .appendChild(node); + } else { + root.appendChild(node); + } + } + } + this.output_document = output_document; + this.output_node = node; + }; + + Output.prototype.show_status = function() { + if (this.phase < this.STARTED) { + this.init({}); + } + if (!this.enabled || this.phase === this.COMPLETE) { + return; + } + this.resolve_log(); + if (this.phase < this.HAVE_RESULTS) { + this.phase = this.HAVE_RESULTS; + } + var done_count = tests.tests.length - tests.num_pending; + if (this.output_node && !tests.hide_test_state) { + if (done_count < 100 || + (done_count < 1000 && done_count % 100 === 0) || + done_count % 1000 === 0) { + this.output_node.textContent = "Running, " + + done_count + " complete, " + + tests.num_pending + " remain"; + } + } + }; + + Output.prototype.show_results = function (tests, harness_status, asserts_run) { + if (this.phase >= this.COMPLETE) { + return; + } + if (!this.enabled) { + return; + } + if (!this.output_node) { + this.resolve_log(); + } + this.phase = this.COMPLETE; + + var log = this.output_node; + if (!log) { + return; + } + var output_document = this.output_document; + + while (log.lastChild) { + log.removeChild(log.lastChild); + } + + var stylesheet = output_document.createElementNS(xhtml_ns, "style"); + stylesheet.textContent = stylesheetContent; + var heads = output_document.getElementsByTagName("head"); + if (heads.length) { + heads[0].appendChild(stylesheet); + } + + var status_number = {}; + forEach(tests, + function(test) { + var status = test.format_status(); + if (status_number.hasOwnProperty(status)) { + status_number[status] += 1; + } else { + status_number[status] = 1; + } + }); + + function status_class(status) + { + return status.replace(/\s/g, '').toLowerCase(); + } + + var summary_template = ["section", {"id":"summary"}, + ["h2", {}, "Summary"], + function() + { + var status = harness_status.format_status(); + var rv = [["section", {}, + ["p", {}, + "Harness status: ", + ["span", {"class":status_class(status)}, + status + ], + ], + ["button", {"id":"rerun"}, "Rerun"] + ]]; + + if (harness_status.status === harness_status.ERROR) { + rv[0].push(["pre", {}, harness_status.message]); + if (harness_status.stack) { + rv[0].push(["pre", {}, harness_status.stack]); + } + } + return rv; + }, + ["p", {}, "Found ${num_tests} tests"], + function() { + var rv = [["div", {}]]; + var i = 0; + while (Test.prototype.status_formats.hasOwnProperty(i)) { + if (status_number.hasOwnProperty(Test.prototype.status_formats[i])) { + var status = Test.prototype.status_formats[i]; + rv[0].push(["div", {}, + ["label", {}, + ["input", {type:"checkbox", checked:"checked"}], + status_number[status] + " ", + ["span", {"class":status_class(status)}, status]]]); + } + i++; + } + return rv; + }, + ]; + + log.appendChild(render(summary_template, {num_tests:tests.length}, output_document)); + + output_document.getElementById("rerun").addEventListener("click", + function() { + let evt = new Event('__test_restart'); + let canceled = !window.dispatchEvent(evt); + if (!canceled) { location.reload(); } + }); + + forEach(output_document.querySelectorAll("section#summary label"), + function(element) + { + on_event(element, "click", + function(e) + { + if (output_document.getElementById("results") === null) { + e.preventDefault(); + return; + } + var result_class = element.querySelector("span[class]").getAttribute("class"); + var style_element = output_document.querySelector("style#hide-" + result_class); + var input_element = element.querySelector("input"); + if (!style_element && !input_element.checked) { + style_element = output_document.createElementNS(xhtml_ns, "style"); + style_element.id = "hide-" + result_class; + style_element.textContent = "table#results > tbody > tr.overall-"+result_class+"{display:none}"; + output_document.body.appendChild(style_element); + } else if (style_element && input_element.checked) { + style_element.parentNode.removeChild(style_element); + } + }); + }); + + function has_assertions() + { + for (var i = 0; i < tests.length; i++) { + if (tests[i].properties.hasOwnProperty("assert")) { + return true; + } + } + return false; + } + + function get_assertion(test) + { + if (test.properties.hasOwnProperty("assert")) { + if (Array.isArray(test.properties.assert)) { + return test.properties.assert.join(' '); + } + return test.properties.assert; + } + return ''; + } + + var asserts_run_by_test = new Map(); + asserts_run.forEach(assert => { + if (!asserts_run_by_test.has(assert.test)) { + asserts_run_by_test.set(assert.test, []); + } + asserts_run_by_test.get(assert.test).push(assert); + }); + + function get_asserts_output(test) { + const asserts_output = render( + ["details", {}, + ["summary", {}, "Asserts run"], + ["table", {}, ""] ]); + + var asserts = asserts_run_by_test.get(test); + if (!asserts) { + asserts_output.querySelector("summary").insertAdjacentText("afterend", "No asserts ran"); + return asserts_output; + } + + const table = asserts_output.querySelector("table"); + for (const assert of asserts) { + const status_class_name = status_class(Test.prototype.status_formats[assert.status]); + var output_fn = "(" + assert.args.join(", ") + ")"; + if (assert.stack) { + output_fn += "\n"; + output_fn += assert.stack.split("\n", 1)[0].replace(/@?\w+:\/\/[^ "\/]+(?::\d+)?/g, " "); + } + table.appendChild(render( + ["tr", {"class":"overall-" + status_class_name}, + ["td", {"class":status_class_name}, Test.prototype.status_formats[assert.status]], + ["td", {}, ["pre", {}, ["strong", {}, assert.assert_name], output_fn]] ])); + } + return asserts_output; + } + + var assertions = has_assertions(); + const section = render( + ["section", {}, + ["h2", {}, "Details"], + ["table", {"id":"results", "class":(assertions ? "assertions" : "")}, + ["thead", {}, + ["tr", {}, + ["th", {}, "Result"], + ["th", {}, "Test Name"], + (assertions ? ["th", {}, "Assertion"] : ""), + ["th", {}, "Message" ]]], + ["tbody", {}]]]); + + const tbody = section.querySelector("tbody"); + for (const test of tests) { + const status = test.format_status(); + const status_class_name = status_class(status); + tbody.appendChild(render( + ["tr", {"class":"overall-" + status_class_name}, + ["td", {"class":status_class_name}, status], + ["td", {}, test.name], + (assertions ? ["td", {}, get_assertion(test)] : ""), + ["td", {}, + test.message ?? "", + ["pre", {}, test.stack ?? ""]]])); + if (!(test instanceof RemoteTest)) { + tbody.lastChild.lastChild.appendChild(get_asserts_output(test)); + } + } + log.appendChild(section); + }; + + /* + * Template code + * + * A template is just a JavaScript structure. An element is represented as: + * + * [tag_name, {attr_name:attr_value}, child1, child2] + * + * the children can either be strings (which act like text nodes), other templates or + * functions (see below) + * + * A text node is represented as + * + * ["{text}", value] + * + * String values have a simple substitution syntax; ${foo} represents a variable foo. + * + * It is possible to embed logic in templates by using a function in a place where a + * node would usually go. The function must either return part of a template or null. + * + * In cases where a set of nodes are required as output rather than a single node + * with children it is possible to just use a list + * [node1, node2, node3] + * + * Usage: + * + * render(template, substitutions) - take a template and an object mapping + * variable names to parameters and return either a DOM node or a list of DOM nodes + * + * substitute(template, substitutions) - take a template and variable mapping object, + * make the variable substitutions and return the substituted template + * + */ + + function is_single_node(template) + { + return typeof template[0] === "string"; + } + + function substitute(template, substitutions) + { + if (typeof template === "function") { + var replacement = template(substitutions); + if (!replacement) { + return null; + } + + return substitute(replacement, substitutions); + } + + if (is_single_node(template)) { + return substitute_single(template, substitutions); + } + + return filter(map(template, function(x) { + return substitute(x, substitutions); + }), function(x) {return x !== null;}); + } + + function substitute_single(template, substitutions) + { + var substitution_re = /\$\{([^ }]*)\}/g; + + function do_substitution(input) + { + var components = input.split(substitution_re); + var rv = []; + if (components.length === 1) { + rv = components; + } else if (substitutions) { + for (var i = 0; i < components.length; i += 2) { + if (components[i]) { + rv.push(components[i]); + } + if (substitutions[components[i + 1]]) { + rv.push(String(substitutions[components[i + 1]])); + } + } + } + return rv; + } + + function substitute_attrs(attrs, rv) + { + rv[1] = {}; + for (var name in template[1]) { + if (attrs.hasOwnProperty(name)) { + var new_name = do_substitution(name).join(""); + var new_value = do_substitution(attrs[name]).join(""); + rv[1][new_name] = new_value; + } + } + } + + function substitute_children(children, rv) + { + for (var i = 0; i < children.length; i++) { + if (children[i] instanceof Object) { + var replacement = substitute(children[i], substitutions); + if (replacement !== null) { + if (is_single_node(replacement)) { + rv.push(replacement); + } else { + extend(rv, replacement); + } + } + } else { + extend(rv, do_substitution(String(children[i]))); + } + } + return rv; + } + + var rv = []; + rv.push(do_substitution(String(template[0])).join("")); + + if (template[0] === "{text}") { + substitute_children(template.slice(1), rv); + } else { + substitute_attrs(template[1], rv); + substitute_children(template.slice(2), rv); + } + + return rv; + } + + function make_dom_single(template, doc) + { + var output_document = doc || document; + var element; + if (template[0] === "{text}") { + element = output_document.createTextNode(""); + for (var i = 1; i < template.length; i++) { + element.data += template[i]; + } + } else { + element = output_document.createElementNS(xhtml_ns, template[0]); + for (var name in template[1]) { + if (template[1].hasOwnProperty(name)) { + element.setAttribute(name, template[1][name]); + } + } + for (var i = 2; i < template.length; i++) { + if (template[i] instanceof Object) { + var sub_element = make_dom(template[i]); + element.appendChild(sub_element); + } else { + var text_node = output_document.createTextNode(template[i]); + element.appendChild(text_node); + } + } + } + + return element; + } + + function make_dom(template, substitutions, output_document) + { + if (is_single_node(template)) { + return make_dom_single(template, output_document); + } + + return map(template, function(x) { + return make_dom_single(x, output_document); + }); + } + + function render(template, substitutions, output_document) + { + return make_dom(substitute(template, substitutions), output_document); + } + + /* + * Utility functions + */ + function assert(expected_true, function_name, description, error, substitutions) + { + if (expected_true !== true) { + var msg = make_message(function_name, description, + error, substitutions); + throw new AssertionError(msg); + } + } + + /** + * @class + * Exception type that represents a failing assert. + * + * @param {string} message - Error message. + */ + function AssertionError(message) + { + if (typeof message === "string") { + message = sanitize_unpaired_surrogates(message); + } + this.message = message; + this.stack = get_stack(); + } + expose(AssertionError, "AssertionError"); + + AssertionError.prototype = Object.create(Error.prototype); + + const get_stack = function() { + var stack = new Error().stack; + + // 'Error.stack' is not supported in all browsers/versions + if (!stack) { + return "(Stack trace unavailable)"; + } + + var lines = stack.split("\n"); + + // Create a pattern to match stack frames originating within testharness.js. These include the + // script URL, followed by the line/col (e.g., '/resources/testharness.js:120:21'). + // Escape the URL per http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript + // in case it contains RegExp characters. + var script_url = get_script_url(); + var re_text = script_url ? script_url.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') : "\\btestharness.js"; + var re = new RegExp(re_text + ":\\d+:\\d+"); + + // Some browsers include a preamble that specifies the type of the error object. Skip this by + // advancing until we find the first stack frame originating from testharness.js. + var i = 0; + while (!re.test(lines[i]) && i < lines.length) { + i++; + } + + // Then skip the top frames originating from testharness.js to begin the stack at the test code. + while (re.test(lines[i]) && i < lines.length) { + i++; + } + + // Paranoid check that we didn't skip all frames. If so, return the original stack unmodified. + if (i >= lines.length) { + return stack; + } + + return lines.slice(i).join("\n"); + }; + + function OptionalFeatureUnsupportedError(message) + { + AssertionError.call(this, message); + } + OptionalFeatureUnsupportedError.prototype = Object.create(AssertionError.prototype); + expose(OptionalFeatureUnsupportedError, "OptionalFeatureUnsupportedError"); + + function make_message(function_name, description, error, substitutions) + { + for (var p in substitutions) { + if (substitutions.hasOwnProperty(p)) { + substitutions[p] = format_value(substitutions[p]); + } + } + var node_form = substitute(["{text}", "${function_name}: ${description}" + error], + merge({function_name:function_name, + description:(description?description + " ":"")}, + substitutions)); + return node_form.slice(1).join(""); + } + + function filter(array, callable, thisObj) { + var rv = []; + for (var i = 0; i < array.length; i++) { + if (array.hasOwnProperty(i)) { + var pass = callable.call(thisObj, array[i], i, array); + if (pass) { + rv.push(array[i]); + } + } + } + return rv; + } + + function map(array, callable, thisObj) + { + var rv = []; + rv.length = array.length; + for (var i = 0; i < array.length; i++) { + if (array.hasOwnProperty(i)) { + rv[i] = callable.call(thisObj, array[i], i, array); + } + } + return rv; + } + + function extend(array, items) + { + Array.prototype.push.apply(array, items); + } + + function forEach(array, callback, thisObj) + { + for (var i = 0; i < array.length; i++) { + if (array.hasOwnProperty(i)) { + callback.call(thisObj, array[i], i, array); + } + } + } + + /** + * Immediately invoke a "iteratee" function with a series of values in + * parallel and invoke a final "done" function when all of the "iteratee" + * invocations have signaled completion. + * + * If all callbacks complete synchronously (or if no callbacks are + * specified), the ``done_callback`` will be invoked synchronously. It is the + * responsibility of the caller to ensure asynchronicity in cases where + * that is desired. + * + * @param {array} value Zero or more values to use in the invocation of + * ``iter_callback`` + * @param {function} iter_callback A function that will be invoked + * once for each of the values min + * ``value``. Two arguments will + * be available in each + * invocation: the value from + * ``value`` and a function that + * must be invoked to signal + * completion + * @param {function} done_callback A function that will be invoked after + * all operations initiated by the + * ``iter_callback`` function have signaled + * completion + */ + function all_async(values, iter_callback, done_callback) + { + var remaining = values.length; + + if (remaining === 0) { + done_callback(); + } + + forEach(values, + function(element) { + var invoked = false; + var elDone = function() { + if (invoked) { + return; + } + + invoked = true; + remaining -= 1; + + if (remaining === 0) { + done_callback(); + } + }; + + iter_callback(element, elDone); + }); + } + + function merge(a,b) + { + var rv = {}; + var p; + for (p in a) { + rv[p] = a[p]; + } + for (p in b) { + rv[p] = b[p]; + } + return rv; + } + + function expose(object, name) + { + var components = name.split("."); + var target = global_scope; + for (var i = 0; i < components.length - 1; i++) { + if (!(components[i] in target)) { + target[components[i]] = {}; + } + target = target[components[i]]; + } + target[components[components.length - 1]] = object; + } + + function is_same_origin(w) { + try { + 'random_prop' in w; + return true; + } catch (e) { + return false; + } + } + + /** Returns the 'src' URL of the first