@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.20

package/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp

@@ -4,7 +4,7 @@
 
 #include "GPUAdapterImpl.h"
 #include "Caches.h"
-
+#include "GPULabel.h"
 GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
 
 const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
@@ -61,7 +61,6 @@ v8::Local<v8::FunctionTemplate> GPUAdapterImpl::GetCtor(v8::Isolate *isolate) {
             GetLimits
     );
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "requestAdapterInfo"),
             v8::FunctionTemplate::New(isolate, &RequestAdapterInfo));
@@ -90,19 +89,19 @@ GPUAdapterImpl::GetFeatures(v8::Local<v8::Name> name,
 
         auto len = canvas_native_string_buffer_get_length(features);
 
-        auto map = v8::Map::New(isolate);
+        auto set = v8::Set::New(isolate);
         for (int i = 0; i < len; ++i) {
             auto item = canvas_native_string_buffer_get_value_at(features, i);
             if (item != nullptr) {
-                auto keyValue = ConvertToV8OneByteString(isolate, (char *) item);
-                map->Set(context, keyValue, keyValue);
+                auto keyValue = ConvertToV8String(isolate, (char *) item);
+                set->Add(context, keyValue);
                 canvas_native_string_destroy(item);
             }
 
         }
         canvas_native_string_buffer_release(features);
 
-        info.GetReturnValue().Set(map);
+        info.GetReturnValue().Set(set);
 
         return;
     }
@@ -158,6 +157,27 @@ void GPUAdapterImpl::RequestAdapterInfo(const v8::FunctionCallbackInfo<v8::Value
 
 }
 
+struct RequestData {
+    char *error_;
+    const CanvasGPUDevice *device_;
+    char **required_features_data_;
+    size_t required_features_data_size;
+
+    ~RequestData() {
+        if (required_features_data_ != nullptr) {
+            for (size_t i = 0; i < required_features_data_size; ++i) {
+                    delete[] required_features_data_[i];
+                }
+                delete[] required_features_data_;
+        }
+
+        if (error_ != nullptr) {
+            canvas_native_string_destroy(error_);
+            error_ = nullptr;
+        }
+    }
+};
+
 void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUAdapterImpl *ptr = GetPointer(args.This());
     auto isolate = args.GetIsolate();
@@ -170,9 +190,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         return;
     }
 
-    v8::Global<v8::Function> func(isolate, cb.As<v8::Function>());
+    auto func = cb.As<v8::Function>();
 
-    std::string label;
+    GPULabel label;
 
     std::vector<std::string> required_features_buf;
 
@@ -183,10 +203,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         v8::Local<v8::Value> labelValue;
         options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(
                 &labelValue);
+        
+        label = GPULabel(isolate, labelValue);
 
-        if (!labelValue.IsEmpty() && labelValue->IsString()) {
-            label = ConvertFromV8String(isolate, labelValue);
-        }
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
@@ -194,11 +213,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                 &requiredFeaturesValue);
 
 
-        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsSet()) {
-            v8::Local<v8::Set> requiredFeaturesSet = requiredFeaturesValue.As<v8::Set>();
-            v8::Local<v8::Array> requiredFeatures = requiredFeaturesSet->AsArray();
+        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsArray()) {
+            v8::Local<v8::Array> requiredFeatures = requiredFeaturesValue.As<v8::Array>();
             auto len = requiredFeatures->Length();
-
             for (int i = 0; i < len; i++) {
                 auto item = requiredFeatures->Get(context, i);
                 if (!item.IsEmpty()) {
@@ -210,7 +227,6 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
             }
         }
 
-
         v8::Local<v8::Value> limitsValue;
 
         options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
@@ -228,75 +244,128 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
     size_t required_features_data_length = required_features_buf.size();
 
     if (required_features_data_length > 0) {
-        required_features_data = new char *[required_features_data_length + 1];
+        required_features_data = new char *[required_features_data_length];
 
         for (size_t i = 0; i < required_features_data_length; ++i) {
-            std::strcpy(required_features_data[i], required_features_buf[i].c_str());
+            required_features_data[i] = new char[required_features_buf[i].size() + 1];
+            auto src = required_features_buf[i].c_str();
+            std::strcpy(required_features_data[i], src);
         }
     }
 
-
     auto callback = new AsyncCallback{
             isolate,
-            std::move(func),
-            static_cast<void *>(required_features_data)
+            func,
+            [](bool done, void *data) {
+                if (data != nullptr) {
+                    auto async_data = static_cast<AsyncCallback *>(data);
+                    auto func = async_data->inner_.get();
+                    if (func != nullptr && func->isolate_ != nullptr) {
+                        v8::Isolate *isolate = func->isolate_;
+                        v8::Locker locker(isolate);
+                        v8::Isolate::Scope isolate_scope(isolate);
+                        v8::HandleScope handle_scope(isolate);
+                        v8::Local<v8::Function> callback = func->callback_.Get(
+                                isolate);
+                        v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                        v8::Context::Scope context_scope(context);
+
+                        RequestData *requestData = nullptr;
+                        if (func->data != nullptr) {
+                            requestData = static_cast<RequestData *>(func->data);
+                        }
+
+                        if (requestData == nullptr) {
+                            // Should never happen
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Exception::Error(
+                                            ConvertToV8String(isolate, "Internal Error"))};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            delete static_cast<AsyncCallback *>(data);
+
+                            return;
+                        }
+
+                        if (requestData->error_ != nullptr) {
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Exception::Error(
+                                            ConvertToV8String(isolate,
+                                                              requestData->error_))};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            
+                            
+                        } else {
+
+                            auto impl = new GPUDeviceImpl(requestData->device_);
+                            auto ret = GPUDeviceImpl::NewInstance(
+                                    isolate, impl);
+
+                            v8::Local<v8::Value> args[2] = {
+                                    v8::Null(isolate), ret};
+
+
+                            callback->Call(context, context->Global(),
+                                           2,
+                                           args);  // ignore JS return value
+                        }
+
+                        if (requestData != nullptr) {
+                            delete requestData;
+                            requestData = nullptr;
+                        }
+
+                        delete static_cast<AsyncCallback *>(data);
+                    }
+                }
+            }
     };
 
-    canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
-                                        label.empty() ? nullptr : label.c_str(),
-                                        required_features_data, required_features_data_length,
-                                        limits,
-                                        [](char *error, const CanvasGPUDevice *device, void *data) {
-                                            if (data != nullptr) {
-                                                auto func = static_cast<AsyncCallback *>(data);
-                                                if (func->isolate != nullptr) {
-                                                    v8::Isolate *isolate = func->isolate;
-                                                    v8::Locker locker(isolate);
-                                                    v8::Isolate::Scope isolate_scope(isolate);
-                                                    v8::HandleScope handle_scope(isolate);
-                                                    v8::Local<v8::Function> callback = func->callback.Get(
-                                                            isolate);
-                                                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                    v8::Context::Scope context_scope(context);
-
-                                                    if (func->data != nullptr) {
-                                                        delete[] static_cast<char **>(func->data);
-                                                        func->data = nullptr;
-                                                    }
-
-                                                    if (error != nullptr) {
-                                                        v8::Local<v8::Value> args[1] = {
-                                                                v8::Exception::Error(
-                                                                        ConvertToV8String(isolate,
-                                                                                          error))};
-
-                                                        canvas_native_string_destroy(error);
-
-                                                        callback->Call(context, context->Global(),
-                                                                       1,
-                                                                       args);  // ignore JS return value
-                                                        delete static_cast<AsyncCallback *>(data);
-                                                    } else {
+    auto inner = callback->inner_.get();
 
-                                                        auto impl = new GPUDeviceImpl(device);
-                                                        auto ret = GPUDeviceImpl::NewInstance(
-                                                                isolate, impl);
-
-
-                                                        v8::Local<v8::Value> args[2] = {
-                                                                v8::Null(isolate), ret};
-
-
-                                                        callback->Call(context, context->Global(),
-                                                                       2,
-                                                                       args);  // ignore JS return value
+    if (required_features_data != nullptr) {
+        inner->data = new RequestData{
+                nullptr,
+                nullptr,
+                required_features_data,
+                required_features_data_length
+        };
+    }
 
-                                                        delete static_cast<AsyncCallback *>(data);
+    callback->prepare();
 
+    canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
+                                                *label,
+                                                required_features_data,
+                                                required_features_data_length,
+                                                limits,
+                                                [](char *error, const CanvasGPUDevice *device,
+                                                   void *data) {
+                                                    if (data != nullptr) {
+                                                        auto async_data = static_cast<AsyncCallback *>(data);
+                                                        auto inner = async_data->inner_.get();
+                                                        if (inner != nullptr) {
+                                                            if (inner->data == nullptr) {
+                                                                inner->data = new RequestData{
+                                                                        error,
+                                                                        device
+                                                                };
+                                                            } else {
+                                                                auto request_data = static_cast<RequestData *>(inner->data);
+                                                                request_data->error_ = error;
+                                                                request_data->device_ = device;
+                                                                delete request_data->required_features_data_;
+                                                                request_data->required_features_data_ = nullptr;
+                                                            }
+
+                                                            async_data->execute(true);
+                                                        }
                                                     }
-                                                }
-                                            }
-                                        }, callback);
-
+                                                }, callback);
 
 }

package/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.h

@@ -33,7 +33,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUAdapterImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUAdapter);
+        SetNativeType(adapter, NativeType::GPUAdapter);
         object->SetAlignedPointerInInternalField(0, adapter);
         adapter->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp

@@ -21,7 +21,7 @@ void GPUAdapterInfoImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *i
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapterInfo"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapterInfo"), func).FromJust();
 }
 
 GPUAdapterInfoImpl *GPUAdapterInfoImpl::GetPointer(const v8::Local<v8::Object> &object) {

package/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h

@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUAdapterInfoImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUAdapterInfo);
+        SetNativeType(info, NativeType::GPUAdapterInfo);
         object->SetAlignedPointerInInternalField(0, info);
         info->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp

@@ -13,7 +13,7 @@ const CanvasGPUBindGroup *GPUBindGroupImpl::GetBindGroup() {
 }
 
 
-void GPUBindGroupImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *isolate) {
+void GPUBindGroupImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
@@ -22,10 +22,10 @@ void GPUBindGroupImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *is
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroup"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroup"), func).FromJust();
 }
 
-GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &object) {
+GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local<v8::Object> &object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
         return nullptr;
@@ -33,21 +33,47 @@ GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &obj
     return static_cast<GPUBindGroupImpl *>(ptr);
 }
 
-v8::Local <v8::FunctionTemplate> GPUBindGroupImpl::GetCtor(v8::Isolate *isolate) {
+v8::Local<v8::FunctionTemplate> GPUBindGroupImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->GPUBindGroupTmpl.get();
     if (ctor != nullptr) {
         return ctor->Get(isolate);
     }
 
-    v8::Local <v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUBindGroup"));
 
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUBindGroupTmpl =
-            std::make_unique < v8::Persistent < v8::FunctionTemplate >> (isolate, ctorTmpl);
+            std::make_unique<v8::Persistent<v8::FunctionTemplate >>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUBindGroupImpl::GetLabel(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_bind_group_get_label(ptr->group_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

package/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h

@@ -11,7 +11,7 @@
 
 class GPUBindGroupImpl : ObjectWrapperImpl {
 public:
-    GPUBindGroupImpl(const CanvasGPUBindGroup *group);
+    explicit GPUBindGroupImpl(const CanvasGPUBindGroup *group);
 
     ~GPUBindGroupImpl() {
         canvas_native_webgpu_bind_group_release(this->GetBindGroup());
@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUBindGroupImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUBindGroup);
+        SetNativeType(groupLayout, NativeType::GPUBindGroup);
         object->SetAlignedPointerInInternalField(0, groupLayout);
         groupLayout->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 private:
     const CanvasGPUBindGroup *group_;
 };

package/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp

@@ -22,7 +22,7 @@ void GPUBindGroupLayoutImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroupLayout"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroupLayout"), func).FromJust();
 }
 
 GPUBindGroupLayoutImpl *GPUBindGroupLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,7 +47,33 @@ v8::Local<v8::FunctionTemplate> GPUBindGroupLayoutImpl::GetCtor(v8::Isolate *iso
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUBindGroupLayoutTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUBindGroupLayoutImpl::GetLabel(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_bind_group_layout_get_label(ptr->groupLayout_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

package/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUBindGroupLayoutImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUBindGroupLayout);
+        SetNativeType(groupLayout, NativeType::GPUBindGroupLayout);
         object->SetAlignedPointerInInternalField(0, groupLayout);
         groupLayout->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 private:
     const CanvasGPUBindGroupLayout *groupLayout_;
 };

package/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp

@@ -21,7 +21,7 @@ void GPUBufferImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBuffer"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBuffer"), func).FromJust();
 }
 
 GPUBufferImpl *GPUBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -75,6 +75,11 @@ v8::Local<v8::FunctionTemplate> GPUBufferImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "getMappedRange"),
             v8::FunctionTemplate::New(isolate, &GetMappedRange));
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -127,12 +132,17 @@ void GPUBufferImpl::UnMap(const v8::FunctionCallbackInfo<v8::Value> &args) {
     canvas_native_webgpu_buffer_unmap(ptr->GetGPUBuffer());
 }
 
+struct MapAsyncData {
+    enum CanvasGPUErrorType type;
+    char* error;
+};
 
 void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUBufferImpl *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
     }
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
     auto mode = args[0]->Int32Value(context).ToChecked();
@@ -154,42 +164,59 @@ void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocalChecked();
     args.GetReturnValue().Set(resolver->GetPromise());
 
-    v8::Global<v8::Promise::Resolver> promise(isolate, resolver);
     auto callback = new PromiseCallback{
             isolate,
-            std::move(promise)
+            resolver,
+            [](bool done, void *data){
+                auto async_data = static_cast<PromiseCallback *>(data);
+                auto func = async_data->inner_.get();
+                if (func != nullptr && func->isolate_ != nullptr) {
+                    v8::Isolate *isolate = func->isolate_;
+                    v8::Locker locker(isolate);
+                    v8::Isolate::Scope isolate_scope(
+                            isolate);
+                    v8::HandleScope handle_scope(
+                            isolate);
+                    v8::Local<v8::Promise::Resolver> callback = func->callback_.Get(
+                            isolate);
+                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                    v8::Context::Scope context_scope(
+                            context);
+
+
+                    if (func->data == nullptr) {
+                        callback->Resolve(context, v8::Undefined(isolate));
+                    } else {
+                        auto errorData = static_cast<MapAsyncData*>(func->data);
+                        callback->Reject(context,
+                                         v8::Exception::Error(
+                                                 ConvertToV8String(
+                                                         isolate,
+                                                         errorData->error)));
+                        canvas_native_string_destroy(
+                                errorData->error);
+                        delete errorData;
+                        func->data = nullptr;
+                    }
+                }
+                delete static_cast<PromiseCallback *>(data);
+            }
     };
-    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), (GPUMapMode) mode, offset, size,
-                                          [](char *error, void *data) {
+    callback->prepare();
+
+
+    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), mode == 1 ? GPUMapMode::GPUMapModeRead : GPUMapMode::GPUMapModeWrite, offset, size,
+                                          [](enum CanvasGPUErrorType type, char *error, void *data) {
                                               if (data != nullptr) {
-                                                  auto func = static_cast<PromiseCallback *>(data);
-                                                  if (func->isolate != nullptr) {
-                                                      v8::Isolate *isolate = func->isolate;
-                                                      v8::Locker locker(isolate);
-                                                      v8::Isolate::Scope isolate_scope(
-                                                              isolate);
-                                                      v8::HandleScope handle_scope(
-                                                              isolate);
-                                                      v8::Local<v8::Promise::Resolver> callback = func->callback.Get(
-                                                              isolate);
-                                                      v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                      v8::Context::Scope context_scope(
-                                                              context);
-
-                                                      auto ret = v8::Object::New(
-                                                              isolate);
-                                                      if (error == nullptr) {
-                                                          callback->Resolve(context, ret);
-                                                      } else {
-                                                          callback->Reject(context,
-                                                                           v8::Exception::Error(
-                                                                                   ConvertToV8String(
-                                                                                           isolate,
-                                                                                           error)));
-                                                          canvas_native_string_destroy(
-                                                                  error);
+                                                  auto async_data = static_cast<PromiseCallback *>(data);
+                                                  auto inner = async_data->inner_.get();
+                                                  if (inner != nullptr) {
+                                                      if(error != nullptr){
+                                                          inner->data = new MapAsyncData {
+                                                              type, error
+                                                          };
                                                       }
-                                                      delete static_cast<PromiseCallback *>(data);
+                                                      async_data->execute(true);
                                                   }
                                               }
                                           }, callback);
@@ -227,3 +254,24 @@ void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &ar
         args.GetReturnValue().Set(ab);
     }
 }
+
+
+void
+GPUBufferImpl::GetLabel(v8::Local<v8::Name> name,
+                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_buffer_get_label(ptr->buffer_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}