node-api: added SharedArrayBuffer api

PR-URL: #59071 Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
aduh95 · Oct 20, 2025 · Oct 7, 2025 · Oct 7, 2025 · Oct 7, 2025 · Oct 7, 2025
commit 6d24b88fbc21596391bd34745ae8555f94720926
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
@@ -3293,6 +3293,10 @@ Specification.
 <!-- YAML
 added: v8.0.0
 napiVersion: 1
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/59071
+    description: Added support for `SharedArrayBuffer`.
 -->
 
 ```c
@@ -3303,21 +3307,20 @@ napi_status napi_get_arraybuffer_info(napi_env env,
 ```
 
 * `[in] env`: The environment that the API is invoked under.
-* `[in] arraybuffer`: `napi_value` representing the `ArrayBuffer` being queried.
-* `[out] data`: The underlying data buffer of the `ArrayBuffer`. If byte\_length
+* `[in] arraybuffer`: `napi_value` representing the `ArrayBuffer` or `SharedArrayBuffer` being queried.
+* `[out] data`: The underlying data buffer of the `ArrayBuffer` or `SharedArrayBuffer`
   is `0`, this may be `NULL` or any other pointer value.
 * `[out] byte_length`: Length in bytes of the underlying data buffer.
 
 Returns `napi_ok` if the API succeeded.
 
-This API is used to retrieve the underlying data buffer of an `ArrayBuffer` and
-its length.
+This API is used to retrieve the underlying data buffer of an `ArrayBuffer` or `SharedArrayBuffer` and its length.
 
 _WARNING_: Use caution while using this API. The lifetime of the underlying data
-buffer is managed by the `ArrayBuffer` even after it's returned. A
+buffer is managed by the `ArrayBuffer` or `SharedArrayBuffer` even after it's returned. A
 possible safe way to use this API is in conjunction with
 [`napi_create_reference`][], which can be used to guarantee control over the
-lifetime of the `ArrayBuffer`. It's also safe to use the returned data buffer
+lifetime of the `ArrayBuffer` or `SharedArrayBuffer`. It's also safe to use the returned data buffer
 within the same callback as long as there are no calls to other APIs that might
 trigger a GC.
 
@@ -4272,6 +4275,63 @@ This API represents the invocation of the `ArrayBuffer` `IsDetachedBuffer`
 operation as defined in [Section isDetachedBuffer][] of the ECMAScript Language
 Specification.
 
+### `node_api_is_sharedarraybuffer`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```c
+napi_status node_api_is_sharedarraybuffer(napi_env env, napi_value value, bool* result)
+```
+
+* `[in] env`: The environment that the API is invoked under.
+* `[in] value`: The JavaScript value to check.
+* `[out] result`: Whether the given `napi_value` represents a `SharedArrayBuffer`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passed in is a `SharedArrayBuffer`.
+
+### `node_api_create_sharedarraybuffer`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```c
+napi_status node_api_create_sharedarraybuffer(napi_env env,
+                                             size_t byte_length,
+                                             void** data,
+                                             napi_value* result)
+```
+
+* `[in] env`: The environment that the API is invoked under.
+* `[in] byte_length`: The length in bytes of the shared array buffer to create.
+* `[out] data`: Pointer to the underlying byte buffer of the `SharedArrayBuffer`.
+  `data` can optionally be ignored by passing `NULL`.
+* `[out] result`: A `napi_value` representing a JavaScript `SharedArrayBuffer`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns a Node-API value corresponding to a JavaScript `SharedArrayBuffer`.
+`SharedArrayBuffer`s are used to represent fixed-length binary data buffers that
+can be shared across multiple workers.
+
+The `SharedArrayBuffer` allocated will have an underlying byte buffer whose size is
+determined by the `byte_length` parameter that's passed in.
+The underlying buffer is optionally returned back to the caller in case the
+caller wants to directly manipulate the buffer. This buffer can only be
+written to directly from native code. To write to this buffer from JavaScript,
+a typed array or `DataView` object would need to be created.
+
+JavaScript `SharedArrayBuffer` objects are described in
+[Section SharedArrayBuffer objects][] of the ECMAScript Language Specification.
+
 ## Working with JavaScript properties
 
 Node-API exposes a set of APIs to get and set properties on JavaScript
@@ -6785,6 +6845,7 @@ the add-on's file name during loading.
 [Section IsArray]: https://tc39.es/ecma262/#sec-isarray
 [Section IsStrctEqual]: https://tc39.es/ecma262/#sec-strict-equality-comparison
 [Section Promise objects]: https://tc39.es/ecma262/#sec-promise-objects
+[Section SharedArrayBuffer objects]: https://tc39.es/ecma262/#sec-sharedarraybuffer-objects
 [Section ToBoolean]: https://tc39.es/ecma262/#sec-toboolean
 [Section ToNumber]: https://tc39.es/ecma262/#sec-tonumber
 [Section ToObject]: https://tc39.es/ecma262/#sec-toobject

diff --git a/src/js_native_api.h b/src/js_native_api.h
@@ -474,6 +474,14 @@ napi_get_dataview_info(napi_env env,
                        napi_value* arraybuffer,
                        size_t* byte_offset);
 
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_is_sharedarraybuffer(napi_env env, napi_value value, bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_sharedarraybuffer(
+    napi_env env, size_t byte_length, void** data, napi_value* result);
+#endif  // NAPI_EXPERIMENTAL
+
 // version management
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);

diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc
@@ -3075,21 +3075,68 @@ napi_status NAPI_CDECL napi_get_arraybuffer_info(napi_env env,
   CHECK_ARG(env, arraybuffer);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
-  RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
 
-  v8::Local<v8::ArrayBuffer> ab = value.As<v8::ArrayBuffer>();
+  if (value->IsArrayBuffer()) {
+    v8::Local<v8::ArrayBuffer> ab = value.As<v8::ArrayBuffer>();
 
-  if (data != nullptr) {
-    *data = ab->Data();
-  }
+    if (data != nullptr) {
+      *data = ab->Data();
+    }
 
-  if (byte_length != nullptr) {
-    *byte_length = ab->ByteLength();
+    if (byte_length != nullptr) {
+      *byte_length = ab->ByteLength();
+    }
+  } else if (value->IsSharedArrayBuffer()) {
+    v8::Local<v8::SharedArrayBuffer> sab = value.As<v8::SharedArrayBuffer>();
+
+    if (data != nullptr) {
+      *data = sab->Data();
+    }
+
+    if (byte_length != nullptr) {
+      *byte_length = sab->ByteLength();
+    }
+  } else {
+    return napi_set_last_error(env, napi_invalid_arg);
   }
 
   return napi_clear_last_error(env);
 }
 
+napi_status NAPI_CDECL node_api_is_sharedarraybuffer(napi_env env,
+                                                     napi_value value,
+                                                     bool* result) {
+  CHECK_ENV_NOT_IN_GC(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  *result = val->IsSharedArrayBuffer();
+
+  return napi_clear_last_error(env);
+}
+
+napi_status NAPI_CDECL node_api_create_sharedarraybuffer(napi_env env,
+                                                         size_t byte_length,
+                                                         void** data,
+                                                         napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, result);
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::SharedArrayBuffer> buffer =
+      v8::SharedArrayBuffer::New(isolate, byte_length);
+
+  // Optionally return a pointer to the buffer's data, to avoid another call to
+  // retrieve it.
+  if (data != nullptr) {
+    *data = buffer->Data();
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(buffer);
+  return GET_RETURN_STATUS(env);
+}
+
 napi_status NAPI_CDECL napi_is_typedarray(napi_env env,
                                           napi_value value,
                                           bool* result) {

diff --git a/test/js-native-api/test_sharedarraybuffer/binding.gyp b/test/js-native-api/test_sharedarraybuffer/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_sharedarraybuffer",
+      "sources": [ "test_sharedarraybuffer.c" ]
+    }
+  ]
+}
diff --git a/test/js-native-api/test_sharedarraybuffer/test.js b/test/js-native-api/test_sharedarraybuffer/test.js
@@ -0,0 +1,67 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const test_sharedarraybuffer = require(`./build/${common.buildType}/test_sharedarraybuffer`);
+
+{
+  const sab = new SharedArrayBuffer(16);
+  const ab = new ArrayBuffer(16);
+  const obj = {};
+  const arr = [];
+
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(sab), true);
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(ab), false);
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(obj), false);
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(arr), false);
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(null), false);
+  assert.strictEqual(test_sharedarraybuffer.TestIsSharedArrayBuffer(undefined), false);
+}
+
+// Test node_api_create_sharedarraybuffer
+{
+  const sab = test_sharedarraybuffer.TestCreateSharedArrayBuffer(16);
+  assert(sab instanceof SharedArrayBuffer);
+  assert.strictEqual(sab.byteLength, 16);
+}
+
+// Test node_api_create_get_sharedarraybuffer_info
+{
+  const sab = new SharedArrayBuffer(32);
+  const byteLength = test_sharedarraybuffer.TestGetSharedArrayBufferInfo(sab);
+  assert.strictEqual(byteLength, 32);
+}
+
+// Test data access
+{
+  const sab = new SharedArrayBuffer(8);
+  const result = test_sharedarraybuffer.TestSharedArrayBufferData(sab);
+  assert.strictEqual(result, true);
+
+  // Check if data was written correctly
+  const view = new Uint8Array(sab);
+  for (let i = 0; i < 8; i++) {
+    assert.strictEqual(view[i], i % 256);
+  }
+}
+
+// Test data pointer from existing SharedArrayBuffer
+{
+  const sab = new SharedArrayBuffer(16);
+  const result = test_sharedarraybuffer.TestSharedArrayBufferData(sab);
+  assert.strictEqual(result, true);
+}
+
+// Test zero-length SharedArrayBuffer
+{
+  const sab = test_sharedarraybuffer.TestCreateSharedArrayBuffer(0);
+  assert(sab instanceof SharedArrayBuffer);
+  assert.strictEqual(sab.byteLength, 0);
+}
+
+// Test invalid arguments
+{
+  assert.throws(() => {
+    test_sharedarraybuffer.TestGetSharedArrayBufferInfo({});
+  }, { name: 'Error', message: 'Invalid argument' });
+}