@nativescript/canvas 2.0.0-webgpu.11 → 2.0.0-webgpu.12

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

@@ -11,9 +11,10 @@
 #include "GPURenderPassEncoderImpl.h"
 #include "GPUCommandBufferImpl.h"
 #include "GPUTextureImpl.h"
+#include "GPULabel.h"
 
 GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder) : encoder_(
-                                                                                                encoder) {}
+        encoder) {}
 
 const CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
     return this->encoder_;
@@ -23,11 +24,11 @@ void GPUCommandEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
-    
+
     auto ctor = GetCtor(isolate);
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
-    
+
     canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandEncoder"), func).FromJust();
 }
 
@@ -45,74 +46,74 @@ v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isol
     if (ctor != nullptr) {
         return ctor->Get(isolate);
     }
-    
+
     v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUCommandEncoder"));
-    
+
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
-    
+
     tmpl->SetLazyDataProperty(
-                              ConvertToV8String(isolate, "label"),
-                              GetLabel
-                              );
-    
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     tmpl->Set(
-              ConvertToV8String(isolate, "beginComputePass"),
-              v8::FunctionTemplate::New(isolate, &BeginComputePass));
-    
+            ConvertToV8String(isolate, "beginComputePass"),
+            v8::FunctionTemplate::New(isolate, &BeginComputePass));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "beginRenderPass"),
-              v8::FunctionTemplate::New(isolate, &BeginRenderPass));
-    
+            ConvertToV8String(isolate, "beginRenderPass"),
+            v8::FunctionTemplate::New(isolate, &BeginRenderPass));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "clearBuffer"),
-              v8::FunctionTemplate::New(isolate, &ClearBuffer));
-    
+            ConvertToV8String(isolate, "clearBuffer"),
+            v8::FunctionTemplate::New(isolate, &ClearBuffer));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "copyBufferToBuffer"),
-              v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
-    
+            ConvertToV8String(isolate, "copyBufferToBuffer"),
+            v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "copyBufferToTexture"),
-              v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
-    
+            ConvertToV8String(isolate, "copyBufferToTexture"),
+            v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "copyTextureToBuffer"),
-              v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
-    
+            ConvertToV8String(isolate, "copyTextureToBuffer"),
+            v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "copyTextureToTexture"),
-              v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
-    
+            ConvertToV8String(isolate, "copyTextureToTexture"),
+            v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "finish"),
-              v8::FunctionTemplate::New(isolate, &Finish));
-    
+            ConvertToV8String(isolate, "finish"),
+            v8::FunctionTemplate::New(isolate, &Finish));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "insertDebugMarker"),
-              v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
-    
+            ConvertToV8String(isolate, "insertDebugMarker"),
+            v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "popDebugGroup"),
-              v8::FunctionTemplate::New(isolate, &PopDebugGroup));
-    
+            ConvertToV8String(isolate, "popDebugGroup"),
+            v8::FunctionTemplate::New(isolate, &PopDebugGroup));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "pushDebugGroup"),
-              v8::FunctionTemplate::New(isolate, &PushDebugGroup));
-    
+            ConvertToV8String(isolate, "pushDebugGroup"),
+            v8::FunctionTemplate::New(isolate, &PushDebugGroup));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "resolveQuerySet"),
-              v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
-    
+            ConvertToV8String(isolate, "resolveQuerySet"),
+            v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
+
     tmpl->Set(
-              ConvertToV8String(isolate, "writeTimestamp"),
-              v8::FunctionTemplate::New(isolate, &WriteTimestamp));
-    
-    
+            ConvertToV8String(isolate, "writeTimestamp"),
+            v8::FunctionTemplate::New(isolate, &WriteTimestamp));
+
+
     cache->GPUCommandEncoderTmpl =
-    std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
@@ -127,12 +128,12 @@ GPUCommandEncoderImpl::GetLabel(v8::Local<v8::Name> name,
             return;
         }
         info.GetReturnValue().Set(
-                                  ConvertToV8String(info.GetIsolate(), label)
-                                  );
+                ConvertToV8String(info.GetIsolate(), label)
+        );
         canvas_native_string_destroy(label);
         return;
     }
-    
+
     info.GetReturnValue().SetEmptyString();
 }
 
@@ -142,88 +143,90 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto descVal = args[0];
-    
+
     const CanvasGPUComputePassEncoder *pass;
-    
+
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
-        
-        
+
+
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        
-        std::string label = ConvertFromV8String(isolate, labelVal);
-        
+
+        auto label = GPULabel(isolate, labelVal);
+
         const CanvasGPUQuerySet *querySet = nullptr;
-        
+
         int32_t beginningOfPassWriteIndex = -1;
-        
+
         int32_t endOfPassWriteIndex = -1;
-        
-        
+
+
         v8::Local<v8::Value> timestampWritesVal;
-        
+
         auto success = desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                                                                                                 &timestampWritesVal);
+                &timestampWritesVal);
         if (success && timestampWritesVal->IsObject()) {
             auto timestampWrites = timestampWritesVal.As<v8::Object>();
-            
+
             v8::Local<v8::Value> querySetVal;
             success = timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
-                                                                                          &querySetVal);
-            
-            
+                    &querySetVal);
+
+
             if (success && querySetVal->IsObject()) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
                 }
             }
-            
+
             v8::Local<v8::Value> beginningOfPassWriteIndexVal;
-            
-            
+
+
             v8::Local<v8::Value> endOfPassWriteIndexVal;
-            
-            
+
+
             success = timestampWrites->Get(context,
-                                 ConvertToV8String(isolate, "beginningOfPassWriteIndex")).ToLocal(
-                                                                                                  &beginningOfPassWriteIndexVal);
-            
+                                           ConvertToV8String(isolate,
+                                                             "beginningOfPassWriteIndex")).ToLocal(
+                    &beginningOfPassWriteIndexVal);
+
             if (success && beginningOfPassWriteIndexVal->IsInt32()) {
                 beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-            
+
             success = timestampWrites->Get(context,
-                                 ConvertToV8String(isolate, "endOfPassWriteIndex")).ToLocal(
-                                                                                            &endOfPassWriteIndexVal);
-            
-            
+                                           ConvertToV8String(isolate,
+                                                             "endOfPassWriteIndex")).ToLocal(
+                    &endOfPassWriteIndexVal);
+
+
             if (success && endOfPassWriteIndexVal->IsInt32()) {
                 endOfPassWriteIndex = endOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
         }
-        
-        
+
+
         pass = canvas_native_webgpu_command_encoder_begin_compute_pass(ptr->GetEncoder(),
-                                                                       querySet, label.c_str(),
+                                                                       querySet, *label,
                                                                        beginningOfPassWriteIndex,
                                                                        endOfPassWriteIndex);
-        
-        
+
+
     } else {
         pass = canvas_native_webgpu_command_encoder_begin_compute_pass(ptr->GetEncoder(),
                                                                        nullptr, nullptr, -1,
                                                                        -1);
-        
+
     }
-    
-    
+
+
     if (pass != nullptr) {
         auto value = new GPUComputePassEncoderImpl(pass);
         auto ret = GPUComputePassEncoderImpl::NewInstance(isolate, value);
@@ -231,7 +234,7 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
     } else {
         args.GetReturnValue().SetUndefined();
     }
-    
+
 }
 
 void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -239,47 +242,47 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto descVal = args[0];
-    
+
     const CanvasGPURenderPassEncoder *pass = nullptr;
-    
+
     std::vector<CanvasRenderPassColorAttachment> colorAttachments_;
-    
+
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
-        
+
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        
-        std::string label = ConvertFromV8String(isolate, labelVal);
-        
-        
+
+        auto label = GPULabel(isolate, labelVal);
+
+
         v8::Local<v8::Value> colorAttachmentsVal;
         desc->Get(context, ConvertToV8String(isolate, "colorAttachments")).ToLocal(
-                                                                                   &colorAttachmentsVal);
-        
+                &colorAttachmentsVal);
+
         auto colorAttachments = colorAttachmentsVal.As<v8::Array>();
         auto colorAttachmentsLength = colorAttachments->Length();
-        
+
         for (int i = 0; i < colorAttachmentsLength; i++) {
             auto colorAttachment = colorAttachments->Get(context,
                                                          i).ToLocalChecked().As<v8::Object>();
-            
+
             v8::Local<v8::Value> clearValueVal;
             colorAttachment->Get(context, ConvertToV8String(isolate, "clearValue")).ToLocal(
-                                                                                            &clearValueVal);
-            
+                    &clearValueVal);
+
             auto clearValue = ParseColor(isolate, clearValueVal);
-            
+
             const CanvasGPUTextureView *view = nullptr;
-            
+
             v8::Local<v8::Value> viewVal;
-            
-            
+
+
             if (colorAttachment->Get(context, ConvertToV8String(isolate,
                                                                 "view")).ToLocal(&viewVal)) {
                 auto type = GetNativeType(viewVal);
@@ -288,308 +291,307 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     view = viewPtr->GetTextureView();
                 }
             }
-            
-            
+
+
             const CanvasGPUTextureView *resolveTarget = nullptr;
-            
+
             v8::Local<v8::Value> resolveTargetVal;
-            
+
             colorAttachment->Get(context, ConvertToV8String(isolate, "resolveTarget")).ToLocal(
-                                                                                               &resolveTargetVal);
-            
+                    &resolveTargetVal);
+
             auto resolve_target_type = GetNativeType(resolveTargetVal);
-            
+
             if (resolve_target_type == NativeType::GPUTextureView) {
                 auto res = GPUTextureViewImpl::GetPointer(resolveTargetVal.As<v8::Object>());
                 resolveTarget = res->GetTextureView();
             }
-            
+
             v8::Local<v8::Value> loadVal;
             v8::Local<v8::Value> storeVal;
             colorAttachment->Get(context, ConvertToV8String(isolate,
                                                             "loadOp")).ToLocal(&loadVal);
-            
+
             colorAttachment->Get(context, ConvertToV8String(isolate,
                                                             "storeOp")).ToLocal(&storeVal);
-            
-            
+
+
             CanvasLoadOp load = ParseCanvasLoadOp(isolate, loadVal);
             CanvasStoreOp store = ParseCanvasStoreOp(isolate, storeVal);
-        
 
-            
+
             CanvasPassChannelColor channel{
-                load,
-                store,
-                clearValue,
-                false
+                    load,
+                    store,
+                    clearValue,
+                    false
             };
-            
+
             auto attachment = CanvasRenderPassColorAttachment{
-                view,
-                resolveTarget,
-                channel
+                    view,
+                    resolveTarget,
+                    channel
             };
-            
+
             colorAttachments_.push_back(attachment);
-            
+
         }
-        
-        
+
+
         // todo add when supported
         v8::Local<v8::Value> maxDrawCountVal;
         desc->Get(context, ConvertToV8String(isolate, "maxDrawCount")).ToLocal(&maxDrawCountVal);
-        
-        
+
+
         CanvasRenderPassDepthStencilAttachment *depthStencilAttachment = nullptr;
         v8::Local<v8::Value> depthStencilAttachmentVal;
-        
+
         desc->Get(context, ConvertToV8String(isolate, "depthStencilAttachment")).ToLocal(
-                                                                                         &depthStencilAttachmentVal);
-        
-        
+                &depthStencilAttachmentVal);
+
+
         if (!depthStencilAttachmentVal.IsEmpty() && depthStencilAttachmentVal->IsObject()) {
             auto depthStencilAttachmentObj = depthStencilAttachmentVal.As<v8::Object>();
             depthStencilAttachment = new CanvasRenderPassDepthStencilAttachment{};
-            
-            
+
+
             v8::Local<v8::Value> viewVal;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "view")).ToLocal(&viewVal);
-            
+
             auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
             depthStencilAttachment->view = viewPtr->GetTextureView();
-            
-            
+
+
             v8::Local<v8::Value> depthClearValue;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "depthClearValue")).ToLocal(
-                                                                                                  &depthClearValue);
-            
+                    &depthClearValue);
+
             depthStencilAttachment->depth_clear_value = 0;
-            
+
             if (!depthClearValue.IsEmpty() && depthClearValue->IsNumber()) {
                 depthStencilAttachment->depth_clear_value = (float) depthClearValue->NumberValue(
-                                                                                                 context).FromJust();
+                        context).FromJust();
             }
-            
+
             v8::Local<v8::Value> depthLoadOp;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "depthLoadOp")).ToLocal(
-                                                                                              &depthLoadOp);
-            
+                    &depthLoadOp);
+
             depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
-            
+
             if (!depthLoadOp.IsEmpty() && depthLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
-            
-            
+
+
             v8::Local<v8::Value> depthStoreOp;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "depthStoreOp")).ToLocal(
-                                                                                               &depthStoreOp);
-            
+                    &depthStoreOp);
+
             depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
-            
+
             if (!depthStoreOp.IsEmpty() && depthStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
-            
-            
+
+
             v8::Local<v8::Value> depthReadOnly;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "depthReadOnly")).ToLocal(
-                                                                                                &depthReadOnly);
-            
+                    &depthReadOnly);
+
             depthStencilAttachment->depth_read_only = false;
             if (!depthReadOnly.IsEmpty() && depthReadOnly->IsBoolean()) {
                 depthStencilAttachment->depth_read_only = depthReadOnly->BooleanValue(isolate);
             }
-            
-            
+
+
             v8::Local<v8::Value> stencilClearValue;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "stencilClearValue")).ToLocal(
-                                                                                                    &stencilClearValue);
-            
+                    &stencilClearValue);
+
             depthStencilAttachment->stencil_clear_value = 0;
-            
+
             if (!stencilClearValue.IsEmpty() && stencilClearValue->IsUint32()) {
                 depthStencilAttachment->stencil_clear_value = stencilClearValue->Uint32Value(
-                                                                                             context).FromJust();
+                        context).FromJust();
             }
-            
-            
+
+
             v8::Local<v8::Value> stencilLoadOp;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "stencilLoadOp")).ToLocal(
-                                                                                                &stencilLoadOp);
-            
+                    &stencilLoadOp);
+
             depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
-            
+
             if (!stencilLoadOp.IsEmpty() && stencilLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
-            
-            
+
+
             v8::Local<v8::Value> stencilStoreOp;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "stencilStoreOp")).ToLocal(
-                                                                                                 &stencilStoreOp);
-            
+                    &stencilStoreOp);
+
             depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
-            
+
             if (!stencilStoreOp.IsEmpty() && stencilStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
-            
-            
+
+
             v8::Local<v8::Value> stencilReadOnly;
             depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
                                                                       "stencilReadOnly")).ToLocal(
-                                                                                                  &stencilReadOnly);
-            
+                    &stencilReadOnly);
+
             depthStencilAttachment->stencil_read_only = false;
             if (!stencilReadOnly.IsEmpty() && stencilReadOnly->IsBoolean()) {
                 depthStencilAttachment->stencil_read_only = stencilReadOnly->BooleanValue(isolate);
             }
-            
+
         }
-        
+
         const CanvasGPUQuerySet *occlusion_query_set = nullptr;
         v8::Local<v8::Value> occlusionQuerySetVal;
-        
-        
+
+
         desc->Get(context, ConvertToV8String(isolate, "occlusionQuerySet")).ToLocal(
-                                                                                    &occlusionQuerySetVal);
-        
-        
+                &occlusionQuerySetVal);
+
+
         if (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
             auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
-                                                                 occlusionQuerySetVal.As<v8::Object>());
+                    occlusionQuerySetVal.As<v8::Object>());
             occlusion_query_set = occlusionQuerySet->GetQuerySet();
         }
-        
-        
+
+
         v8::Local<v8::Value> timestampWritesVal;
         desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                                                                                  &timestampWritesVal);
-        
-        
+                &timestampWritesVal);
+
+
         const CanvasGPUQuerySet *querySet = nullptr;
         int32_t beginningOfPassWriteIndex = -1;
         int32_t endOfPassWriteIndex = -1;
-        
+
         if (!timestampWritesVal.IsEmpty() && timestampWritesVal->IsObject()) {
             auto timestampWrites = timestampWritesVal.As<v8::Object>();
             v8::Local<v8::Value> querySetVal;
             timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
-                                                                                          &querySetVal);
-            
-            
+                    &querySetVal);
+
+
             if (GetNativeType(querySetVal) == NativeType::GPUQuerySet) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
                 }
             }
-            
+
             v8::Local<v8::Value> beginningOfPassWriteIndexVal;
-            
+
             v8::Local<v8::Value> endOfPassWriteIndexVal;
-            
-            
+
+
             auto beginningOfPassWriteIndexValSuccess = timestampWrites->Get(context,
                                                                             ConvertToV8String(
-                                                                                              isolate,
-                                                                                              "beginningOfPassWriteIndex")).ToLocal(
-                                                                                                                                    &beginningOfPassWriteIndexVal);
-            
+                                                                                    isolate,
+                                                                                    "beginningOfPassWriteIndex")).ToLocal(
+                    &beginningOfPassWriteIndexVal);
+
             auto endOfPassWriteIndexValSuccess = timestampWrites->Get(context,
                                                                       ConvertToV8String(isolate,
                                                                                         "endOfPassWriteIndex")).ToLocal(
-                                                                                                                        &endOfPassWriteIndexVal);
-            
-            
+                    &endOfPassWriteIndexVal);
+
+
             if (beginningOfPassWriteIndexValSuccess && beginningOfPassWriteIndexVal->IsInt32()) {
                 beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-            
+
             if (endOfPassWriteIndexValSuccess && endOfPassWriteIndexVal->IsInt32()) {
                 endOfPassWriteIndex = endOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-            
+
         }
-        
-        
+
+
         pass = canvas_native_webgpu_command_encoder_begin_render_pass(
-                                                                      ptr->GetEncoder(), label.c_str(), colorAttachments_.data(), colorAttachments_.size(),
-                                                                      depthStencilAttachment, occlusion_query_set,
-                                                                      querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
-                                                                      );
-        
+                ptr->GetEncoder(), *label, colorAttachments_.data(), colorAttachments_.size(),
+                depthStencilAttachment, occlusion_query_set,
+                querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
+        );
+
         if (depthStencilAttachment != nullptr) {
             delete depthStencilAttachment;
             depthStencilAttachment = nullptr;
         }
-        
-        
+
+
     }
-    
-    
+
+
     if (pass != nullptr) {
         auto value = new GPURenderPassEncoderImpl(pass);
         auto ret = GPURenderPassEncoderImpl::NewInstance(isolate, value);
@@ -597,7 +599,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     } else {
         args.GetReturnValue().SetUndefined();
     }
-    
+
 }
 
 void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -605,37 +607,37 @@ void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto bufferVal = args[0];
     const CanvasGPUBuffer *buffer = nullptr;
-    
+
     if (bufferVal->IsObject()) {
         auto bufferPtr = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
         if (bufferPtr != nullptr) {
             buffer = bufferPtr->GetGPUBuffer();
         }
     }
-    
+
     if (buffer == nullptr) {
         return;
     }
-    
+
     int64_t offset = -1;
     auto offsetVal = args[1];
-    
+
     if (offsetVal->IsNumber()) {
         offset = (int64_t) offsetVal.As<v8::Number>()->Value();
     }
-    
+
     int64_t size = -1;
     auto sizeVal = args[2];
-    
+
     if (sizeVal->IsNumber()) {
         size = (int64_t) sizeVal.As<v8::Number>()->Value();
     }
-    
+
     canvas_native_webgpu_command_encoder_clear_buffer(ptr->GetEncoder(), buffer, offset, size);
-    
+
 }
 
 void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -645,7 +647,7 @@ void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8
     }
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto source = args[0];
     auto sourceType = GetNativeType(source);
     auto sourceOffset = args[1];
@@ -653,22 +655,22 @@ void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8
     auto destinationType = GetNativeType(destination);
     auto destinationOffset = args[3];
     auto size = args[4];
-    
+
     if (sourceType == NativeType::GPUBuffer && destinationType == NativeType::GPUBuffer) {
         auto src = GPUBufferImpl::GetPointer(source.As<v8::Object>());
         auto dst = GPUBufferImpl::GetPointer(destination.As<v8::Object>());
         canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(ptr->GetEncoder(),
                                                                    src->GetGPUBuffer(),
                                                                    (int64_t) sourceOffset->NumberValue(
-                                                                                                       context).FromJust(),
+                                                                           context).FromJust(),
                                                                    dst->GetGPUBuffer(),
                                                                    (int64_t) destinationOffset->NumberValue(
-                                                                                                            context).FromJust(),
+                                                                           context).FromJust(),
                                                                    (uint64_t) size->NumberValue(
-                                                                                                context).FromJust()
-                                                                   );
+                                                                           context).FromJust()
+        );
     }
-    
+
 }
 
 void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -676,15 +678,15 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
     if (ptr == nullptr) {
         return;
     }
-    
-    
+
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto source = args[0];
     auto destination = args[1];
     auto copySize = args[2];
-    
+
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         const CanvasGPUBuffer *buffer = nullptr;
         auto src = source.As<v8::Object>();
@@ -695,73 +697,73 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
         }
         uint64_t offset = 0;
         int32_t rowsPerImage = -1;
-        
+
         v8::Local<v8::Value> rowsPerImageVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "rowsPerImage")).ToLocal(&rowsPerImageVal);
-        
+
         if (!rowsPerImageVal.IsEmpty() && rowsPerImageVal->IsInt32()) {
             rowsPerImage = rowsPerImageVal->Int32Value(context).FromJust();
         }
-        
-        
+
+
         v8::Local<v8::Value> offsetVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "offset")).ToLocal(&offsetVal);
-        
+
         if (!offsetVal.IsEmpty() && offsetVal->IsNumber()) {
             offset = (int64_t) offsetVal->NumberValue(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> bytesPerRowVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "bytesPerRow")).ToLocal(&bytesPerRowVal);
-        
+
         CanvasImageCopyBuffer copy{
-            buffer,
-            offset,
-            bytesPerRowVal->Int32Value(context).FromJust(),
-            rowsPerImage
+                buffer,
+                offset,
+                bytesPerRowVal->Int32Value(context).FromJust(),
+                rowsPerImage
         };
-        
-        
+
+
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-        
+
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-        
-        
+
+
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-        
-        
+
+
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-        
+
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-        
-        
+
+
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-            
-            
+
+
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-            
+
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -771,36 +773,36 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-            
+
         }
-        
-        
+
+
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-        
-        
+
+
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-        
+
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-        
+
         CanvasImageCopyTexture ct{
-            texture, mipLevel, origin, aspect
+                texture, mipLevel, origin, aspect
         };
-        
+
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
         canvas_native_webgpu_command_encoder_copy_buffer_to_texture(
-                                                                    ptr->GetEncoder(),
-                                                                    &copy,
-                                                                    &ct,
-                                                                    &cz
-                                                                    );
+                ptr->GetEncoder(),
+                &copy,
+                &ct,
+                &cz
+        );
     }
-    
-    
+
+
 }
 
 void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -808,20 +810,20 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
     if (ptr == nullptr) {
         return;
     }
-    
-    
+
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     // copying texture to buffer swapped the real source and dst
     auto source = args[1];
     auto destination = args[0];
     auto copySize = args[2];
-    
+
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         const CanvasGPUBuffer *buffer = nullptr;
         auto src = source.As<v8::Object>();
-        
+
         v8::Local<v8::Value> bufferVal;
         src->Get(context, ConvertToV8String(isolate, "buffer")).ToLocal(&bufferVal);
         if (GetNativeType(bufferVal) == NativeType::GPUBuffer) {
@@ -829,73 +831,73 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
         }
         uint64_t offset = 0;
         int32_t rowsPerImage = -1;
-        
+
         v8::Local<v8::Value> rowsPerImageVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "rowsPerImage")).ToLocal(&rowsPerImageVal);
-        
+
         if (!rowsPerImageVal.IsEmpty() && rowsPerImageVal->IsInt32()) {
             rowsPerImage = rowsPerImageVal->Int32Value(context).FromJust();
         }
-        
-        
+
+
         v8::Local<v8::Value> offsetVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "offset")).ToLocal(&offsetVal);
-        
+
         if (!offsetVal.IsEmpty() && offsetVal->IsNumber()) {
             offset = (int64_t) offsetVal->NumberValue(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> bytesPerRowVal;
-        
+
         src->Get(context, ConvertToV8String(isolate, "bytesPerRow")).ToLocal(&bytesPerRowVal);
-        
+
         CanvasImageCopyBuffer copy{
-            buffer,
-            offset,
-            bytesPerRowVal->Int32Value(context).FromJust(),
-            rowsPerImage
+                buffer,
+                offset,
+                bytesPerRowVal->Int32Value(context).FromJust(),
+                rowsPerImage
         };
-        
-        
+
+
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-        
+
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-        
-        
+
+
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-        
-        
+
+
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-        
+
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-        
-        
+
+
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-            
-            
+
+
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-            
+
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -905,36 +907,36 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-            
+
         }
-        
-        
+
+
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-        
-        
+
+
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-        
+
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-        
+
         CanvasImageCopyTexture ct{
-            texture, mipLevel, origin, aspect
+                texture, mipLevel, origin, aspect
         };
-        
+
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
         canvas_native_webgpu_command_encoder_copy_texture_to_buffer(
-                                                                    ptr->GetEncoder(),
-                                                                    &ct,
-                                                                    &copy,
-                                                                    &cz
-                                                                    );
+                ptr->GetEncoder(),
+                &ct,
+                &copy,
+                &cz
+        );
     }
-    
-    
+
+
 }
 
 void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -942,51 +944,51 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     // copying texture to buffer swapped the real source and dst
     auto source = args[0];
     auto destination = args[1];
     auto copySize = args[2];
-    
+
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         auto src = source.As<v8::Object>();
-        
+
         uint32_t mipLevelA = 0;
         CanvasOrigin3d originA{0, 0, 0};
         CanvasTextureAspect aspectA = CanvasTextureAspectAll;
-        
+
         const CanvasGPUTexture *textureA = nullptr;
-        
+
         v8::Local<v8::Value> srcTextureVal;
         src->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&srcTextureVal);
         if (GetNativeType(srcTextureVal) == NativeType::GPUTexture) {
             textureA = GPUTextureImpl::GetPointer(srcTextureVal.As<v8::Object>())->GetTexture();
         }
-        
+
         v8::Local<v8::Value> mipLevelAVal;
         src->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelAVal);
-        
+
         if (!mipLevelAVal.IsEmpty() && mipLevelAVal->IsUint32()) {
             mipLevelA = mipLevelAVal->Uint32Value(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> originAVal;
         src->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originAVal);
-        
-        
+
+
         if (!originAVal.IsEmpty() && originAVal->IsObject()) {
             auto originObj = originAVal.As<v8::Object>();
-            
+
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-            
+
             if (xVal->IsUint32()) {
                 originA.x = xVal->Uint32Value(context).FromJust();
             }
@@ -996,58 +998,58 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
             if (zVal->IsUint32()) {
                 originA.z = zVal->Uint32Value(context).FromJust();
             }
-            
+
         }
-        
+
         v8::Local<v8::Value> aspectAVal;
         src->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectAVal);
-        
+
         auto aspectAStr = ConvertFromV8String(isolate, aspectAVal);
-        
+
         if (aspectAStr == "stencil-only") {
             aspectA = CanvasTextureAspectStencilOnly;
         } else if (aspectAStr == "depth-only") {
             aspectA = CanvasTextureAspectDepthOnly;
         }
         CanvasImageCopyTexture copy{
-            textureA, mipLevelA, originA, aspectA
+                textureA, mipLevelA, originA, aspectA
         };
-        
+
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-        
+
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-        
-        
+
+
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-        
-        
+
+
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-        
+
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-        
+
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-        
+
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-            
+
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-            
+
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -1057,36 +1059,36 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-            
+
         }
-        
-        
+
+
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-        
+
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-        
+
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-        
+
         CanvasImageCopyTexture ct{
-            texture, mipLevel, origin, aspect
+                texture, mipLevel, origin, aspect
         };
-        
+
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
-        
+
         canvas_native_webgpu_command_encoder_copy_texture_to_texture(
-                                                                     ptr->GetEncoder(),
-                                                                     &copy,
-                                                                     &ct,
-                                                                     &cz
-                                                                     );
+                ptr->GetEncoder(),
+                &copy,
+                &ct,
+                &cz
+        );
     }
-    
-    
+
+
 }
 
 void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -1094,31 +1096,27 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto descVal = args[0];
-    std::string label;
-    bool didSet = false;
+    GPULabel label;
     if (descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
         v8::Local<v8::Value> labelVal;
-        didSet = desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        if (didSet && labelVal->IsString()) {
-            label = ConvertFromV8String(isolate, labelVal);
-        }
+        desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
+        label = GPULabel(isolate, labelVal);
     }
-    
-    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(),
-                                                             didSet ? label.c_str() : nullptr);
-    
+
+    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), *label);
+
     if (value != nullptr) {
         auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));
         args.GetReturnValue().Set(ret);
         return;
     }
-    
+
     args.GetReturnValue().SetUndefined();
 }
 
@@ -1128,9 +1126,9 @@ GPUCommandEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Valu
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
-    
+
     auto markerLabelVal = args[0];
     if (markerLabelVal->IsString()) {
         auto markerLabel = ConvertFromV8String(isolate, markerLabelVal);
@@ -1144,7 +1142,7 @@ void GPUCommandEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo<v8::Val
     if (ptr == nullptr) {
         return;
     }
-    
+
     canvas_native_webgpu_command_encoder_pop_debug_group(ptr->GetEncoder());
 }
 
@@ -1153,9 +1151,9 @@ void GPUCommandEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo<v8::Va
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
-    
+
     auto groupLabelVal = args[0];
     if (groupLabelVal->IsString()) {
         auto groupLabel = ConvertFromV8String(isolate, groupLabelVal);
@@ -1169,10 +1167,10 @@ void GPUCommandEncoderImpl::ResolveQuerySet(const v8::FunctionCallbackInfo<v8::V
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto querySet = args[0];
     auto queryType = GetNativeType(querySet);
     auto firstQuery = args[1];
@@ -1180,19 +1178,19 @@ void GPUCommandEncoderImpl::ResolveQuerySet(const v8::FunctionCallbackInfo<v8::V
     auto destination = args[3];
     auto destinationType = GetNativeType(destination);
     auto destinationOffset = args[4];
-    
-    
+
+
     if (queryType == NativeType::GPUQuerySet && destinationType == NativeType::GPUBuffer) {
         auto qs = GPUQuerySetImpl::GetPointer(querySet.As<v8::Object>());
         auto dest = GPUBufferImpl::GetPointer(destination.As<v8::Object>());
         canvas_native_webgpu_command_encoder_resolve_query_set(ptr->GetEncoder(), qs->GetQuerySet(),
                                                                firstQuery->Uint32Value(
-                                                                                       context).FromJust(),
+                                                                       context).FromJust(),
                                                                queryCount->Uint32Value(
-                                                                                       context).FromJust(),
+                                                                       context).FromJust(),
                                                                dest->GetGPUBuffer(),
                                                                (uint64_t) destinationOffset->NumberValue(
-                                                                                                         context).FromJust());
+                                                                       context).FromJust());
     }
 }
 
@@ -1201,20 +1199,20 @@ void GPUCommandEncoderImpl::WriteTimestamp(const v8::FunctionCallbackInfo<v8::Va
     if (ptr == nullptr) {
         return;
     }
-    
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    
+
     auto querySet = args[0];
     auto queryType = GetNativeType(querySet);
     auto queryIndex = args[1];
-    
+
     if (queryType == NativeType::GPUQuerySet) {
         auto qs = GPUQuerySetImpl::GetPointer(querySet.As<v8::Object>());
         canvas_native_webgpu_command_encoder_write_timestamp(ptr->GetEncoder(), qs->GetQuerySet(),
                                                              queryIndex->Uint32Value(
-                                                                                     context).FromJust());
+                                                                     context).FromJust());
     }
-    
-    
+
+
 }