diff --git a/crates/canvas-c/src/webgpu/gpu_canvas_context.rs b/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
index cc19b3eb..34fe7e14 100644
--- a/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
+++ b/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
@@ -1495,9 +1495,13 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_present_surface(
                             if error.is_none() {
                                 global.queue_submit(data.device.queue.queue.id, &[id]).ok();
                             }
+
+                            global.command_buffer_drop(id);
                         }
                         Err(_) => {}
                     }
+
+                    global.command_encoder_drop(encoder);
                 }
             }
         };
diff --git a/crates/canvas-c/src/webgpu/gpu_texture.rs b/crates/canvas-c/src/webgpu/gpu_texture.rs
index d0b30b5f..8bd5f808 100644
--- a/crates/canvas-c/src/webgpu/gpu_texture.rs
+++ b/crates/canvas-c/src/webgpu/gpu_texture.rs
@@ -45,28 +45,21 @@ impl Drop for CanvasGPUTexture {
         }
         match self.surface_id {
             Some(surface_id) => {
+                let global = self.instance.global();
                 let has_surface_presented = self
                     .has_surface_presented
                     .load(std::sync::atomic::Ordering::SeqCst);
 
+                // acquired but never presented: hand the image back to the swapchain
                 if !has_surface_presented {
-                    let global = self.instance.global();
-
-                    /*
-                    match global.surface_texture_discard(surface_id) {
-                        Ok(_) => {
-                            self.surface_id = None;
-                        }
-                        Err(cause) => {
-                            handle_error_fatal(
-                                global,
-                                cause,
-                                "canvas_native_webgpu_texture_release",
-                            )
-                        },
+                    if let Err(cause) = global.surface_texture_discard(surface_id) {
+                        log::warn!("surface_texture_discard failed: {cause:?}");
                     }
-                    */
                 }
+
+                // drop the hub ref so the surface texture and its clear_view are freed
+                global.texture_drop(self.texture);
+                self.surface_id = None;
             }
             None => {
                 let context = self.instance.global();
diff --git a/packages/canvas/WebGPU/Constants.ts b/packages/canvas/WebGPU/Constants.ts
index d459d1c6..9de38543 100644
--- a/packages/canvas/WebGPU/Constants.ts
+++ b/packages/canvas/WebGPU/Constants.ts
@@ -39,3 +39,5 @@ export const native_ = Symbol('[[native]]');
 export const mapState_ = Symbol('[[mapState]]');
 export const contextPtr_ = Symbol('[[contextPtr]]');
 export const adapter_ = Symbol('[[adapter]]');
+// owning GPUCanvasContext stamped on the getCurrentTexture() texture (for release at present)
+export const swapchainContext_ = Symbol('[[swapchainContext]]');
diff --git a/packages/canvas/WebGPU/GPUCanvasContext.ts b/packages/canvas/WebGPU/GPUCanvasContext.ts
index 24fbe736..ccb33aa7 100644
--- a/packages/canvas/WebGPU/GPUCanvasContext.ts
+++ b/packages/canvas/WebGPU/GPUCanvasContext.ts
@@ -1,7 +1,8 @@
 import { Helpers } from '../helpers';
-import { adapter_, contextPtr_, GPUTextureUsage, native_ } from './Constants';
+import { adapter_, contextPtr_, GPUTextureUsage, native_, swapchainContext_ } from './Constants';
 import type { GPUDevice } from './GPUDevice';
 import { GPUTexture } from './GPUTexture';
+import type { GPUTextureView } from './GPUTextureView';
 import type { GPUAdapter } from './GPUAdapter';
 import type { GPUCanvasAlphaMode, GPUCanvasPresentMode, GPUExtent3D, GPUTextureFormat } from './Types';
 import type { CanvasRenderingContext } from '../common';
@@ -18,6 +19,15 @@ export class GPUCanvasContext implements CanvasRenderingContext {
 	[native_] = null;
 	[contextPtr_] = null;
 
+	// per-frame swapchain views and textures, released at the next presentSurface()
+	private _swapchainViews: GPUTextureView[] = [];
+	private _swapchainTextures: GPUTexture[] = [];
+
+	/** @internal */
+	_registerSwapchainView(view: GPUTextureView) {
+		this._swapchainViews.push(view);
+	}
+
 	constructor(context: any, contextOptions: any = {}) {
 		let nativeContext = '0';
 		if (__ANDROID__) {
@@ -176,12 +186,39 @@ export class GPUCanvasContext implements CanvasRenderingContext {
 		const result = GPUTexture.fromNative(texture);
 		if (!result) {
 			console.error('GPUCanvasContext.getCurrentTexture: native texture wrapper contained no texture');
+		} else {
+			// mark as swapchain-owned and track for release at present
+			(result as any)[swapchainContext_] = this;
+			this._swapchainTextures.push(result);
 		}
 		return result;
 	}
 
 	presentSurface(_texture?: GPUTexture) {
 		this.native.presentSurface();
+		// release this frame's swapchain views and textures (their point of death)
+		const views = this._swapchainViews;
+		if (views.length > 0) {
+			this._swapchainViews = [];
+			for (let i = 0; i < views.length; i++) {
+				const view = views[i] as any;
+				view?.[native_]?.destroy?.();
+				if (view) {
+					view[native_] = null;
+				}
+			}
+		}
+		const texs = this._swapchainTextures;
+		if (texs.length > 0) {
+			this._swapchainTextures = [];
+			for (let i = 0; i < texs.length; i++) {
+				const tex = texs[i] as any;
+				tex?.[native_]?.__releaseHandle?.();
+				if (tex) {
+					tex[native_] = null;
+				}
+			}
+		}
 	}
 
 	getCapabilities(adapter: GPUAdapter): {
diff --git a/packages/canvas/WebGPU/GPUCommandEncoder.ts b/packages/canvas/WebGPU/GPUCommandEncoder.ts
index 387565e8..daea2a09 100644
--- a/packages/canvas/WebGPU/GPUCommandEncoder.ts
+++ b/packages/canvas/WebGPU/GPUCommandEncoder.ts
@@ -190,7 +190,11 @@ export class GPUCommandEncoder {
 
 	finish(descriptor?: { label?: string }) {
 		const ret = this[native_].finish(descriptor);
-		return GPUCommandBuffer.fromNative(ret);
+		const buffer = GPUCommandBuffer.fromNative(ret);
+		// finish() consumes the encoder; release it now instead of waiting for GC
+		this[native_]?.destroy?.();
+		this[native_] = null;
+		return buffer;
 	}
 
 	insertDebugMarker(markerLabel: string) {
diff --git a/packages/canvas/WebGPU/GPUComputePassEncoder.ts b/packages/canvas/WebGPU/GPUComputePassEncoder.ts
index 8821fc11..30eca504 100644
--- a/packages/canvas/WebGPU/GPUComputePassEncoder.ts
+++ b/packages/canvas/WebGPU/GPUComputePassEncoder.ts
@@ -19,7 +19,10 @@ export class GPUComputePassEncoder {
 	}
 
 	end() {
-		this[native_].end();
+		// end() consumes the pass; release it now instead of waiting for GC
+		const n = this[native_];
+		n?.end();
+		n?.destroy?.();
 		this[native_] = null;
 	}
 
diff --git a/packages/canvas/WebGPU/GPUQueue.ts b/packages/canvas/WebGPU/GPUQueue.ts
index 06e009b1..05e9849e 100644
--- a/packages/canvas/WebGPU/GPUQueue.ts
+++ b/packages/canvas/WebGPU/GPUQueue.ts
@@ -129,6 +129,14 @@ export class GPUQueue {
 					return command[native_];
 				}),
 			);
+			// submit() consumes the command buffers; release them now instead of via GC
+			for (let i = 0; i < commands.length; i++) {
+				const command = commands[i] as any;
+				command?.[native_]?.destroy?.();
+				if (command) {
+					command[native_] = null;
+				}
+			}
 		}
 	}
 
diff --git a/packages/canvas/WebGPU/GPURenderPassEncoder.ts b/packages/canvas/WebGPU/GPURenderPassEncoder.ts
index 5131b834..f54ae0ab 100644
--- a/packages/canvas/WebGPU/GPURenderPassEncoder.ts
+++ b/packages/canvas/WebGPU/GPURenderPassEncoder.ts
@@ -45,7 +45,11 @@ export class GPURenderPassEncoder {
 	}
 
 	end() {
-		this[native_].end();
+		// end() consumes the pass; release it now instead of waiting for GC
+		const n = this[native_];
+		n?.end();
+		n?.destroy?.();
+		this[native_] = null;
 	}
 
 	endOcclusionQuery() {
diff --git a/packages/canvas/WebGPU/GPUTexture.ts b/packages/canvas/WebGPU/GPUTexture.ts
index 2510d23d..8792b85d 100644
--- a/packages/canvas/WebGPU/GPUTexture.ts
+++ b/packages/canvas/WebGPU/GPUTexture.ts
@@ -1,4 +1,4 @@
-import { native_ } from './Constants';
+import { native_, swapchainContext_ } from './Constants';
 import { GPUTextureView } from './GPUTextureView';
 import type { GPUTextureViewDescriptor } from './Interfaces';
 
@@ -49,6 +49,12 @@ export class GPUTexture {
 
 	createView(desc?: GPUTextureViewDescriptor) {
 		const view = this[native_].createView(desc);
-		return GPUTextureView.fromNative(view);
+		const ret = GPUTextureView.fromNative(view);
+		// swapchain-texture views die at present; register them with the owning context
+		const ctx = (this as any)[swapchainContext_];
+		if (ret && ctx) {
+			ctx._registerSwapchainView(ret);
+		}
+		return ret;
 	}
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/ArcHandle.h b/packages/canvas/platforms/ios/src/cpp/webgpu/ArcHandle.h
new file mode 100644
index 00000000..1e8560fe
--- /dev/null
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/ArcHandle.h
@@ -0,0 +1,37 @@
+//
+// ArcHandle.h — RAII owner for the Rust Arc handles exposed across the canvas C ABI.
+//
+
+#ifndef CANVAS_WEBGPU_ARCHANDLE_H
+#define CANVAS_WEBGPU_ARCHANDLE_H
+
+#include <memory>
+
+// unique_ptr owner for a Rust Arc handle exposed across the C ABI. reset() runs the
+// matching ..._release once and nulls the pointer; the GC finalizer's later drop is
+// then a no-op. ArcHandle for const release fns, MutArcHandle for non-const.
+template <typename T, void (*Release)(const T *)>
+struct ArcDeleter {
+    void operator()(const T *ptr) const noexcept {
+        if (ptr != nullptr) {
+            Release(ptr);
+        }
+    }
+};
+
+template <typename T, void (*Release)(const T *)>
+using ArcHandle = std::unique_ptr<const T, ArcDeleter<T, Release>>;
+
+template <typename T, void (*Release)(T *)>
+struct MutArcDeleter {
+    void operator()(T *ptr) const noexcept {
+        if (ptr != nullptr) {
+            Release(ptr);
+        }
+    }
+};
+
+template <typename T, void (*Release)(T *)>
+using MutArcHandle = std::unique_ptr<T, MutArcDeleter<T, Release>>;
+
+#endif // CANVAS_WEBGPU_ARCHANDLE_H
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
index 4578af8d..4bced0e4 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
@@ -8,7 +8,7 @@
 GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
 
 const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
-    return this->adapter_;
+    return this->adapter_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.h
index a31e7335..d50fae43 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.h
@@ -8,6 +8,7 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 #include "GPUSupportedLimitsImpl.h"
 #include "GPUDeviceImpl.h"
 #include "GPUAdapterInfoImpl.h"
@@ -16,9 +17,7 @@ class GPUAdapterImpl : ObjectWrapperImpl {
 public:
     explicit GPUAdapterImpl(const CanvasGPUAdapter *adapter);
 
-    ~GPUAdapterImpl() {
-        canvas_native_webgpu_adapter_release(this->GetGPUAdapter());
-    }
+    ~GPUAdapterImpl() = default;
 
     const CanvasGPUAdapter *GetGPUAdapter();
 
@@ -56,7 +55,7 @@ class GPUAdapterImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUAdapter *adapter_;
+    ArcHandle<CanvasGPUAdapter, canvas_native_webgpu_adapter_release> adapter_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
index e5b68960..72965575 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
@@ -8,7 +8,7 @@
 GPUAdapterInfoImpl::GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info) : info_(info) {}
 
 const CanvasGPUAdapterInfo *GPUAdapterInfoImpl::GetInfo() {
-    return this->info_;
+    return this->info_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
index 84f21ae8..1a7597e1 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUAdapterInfoImpl : ObjectWrapperImpl {
 public:
     explicit GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info);
 
-    ~GPUAdapterInfoImpl() {
-        canvas_native_webgpu_adapter_info_release(this->GetInfo());
-    }
+    ~GPUAdapterInfoImpl() = default;
 
     const CanvasGPUAdapterInfo *GetInfo();
 
@@ -51,7 +50,7 @@ class GPUAdapterInfoImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUAdapterInfo *info_;
+    ArcHandle<CanvasGPUAdapterInfo, canvas_native_webgpu_adapter_info_release> info_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp
index 7bf32869..c18aa53f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp
@@ -9,7 +9,7 @@ GPUBindGroupImpl::GPUBindGroupImpl(const CanvasGPUBindGroup *groupLayout)
         : group_(groupLayout) {}
 
 const CanvasGPUBindGroup *GPUBindGroupImpl::GetBindGroup() {
-    return this->group_;
+    return this->group_.get();
 }
 
 
@@ -63,7 +63,7 @@ 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_);
+        auto label = canvas_native_webgpu_bind_group_get_label(ptr->group_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h
index 54717df1..c0231c0e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUBindGroupImpl : ObjectWrapperImpl {
 public:
     explicit GPUBindGroupImpl(const CanvasGPUBindGroup *group);
 
-    ~GPUBindGroupImpl() {
-        canvas_native_webgpu_bind_group_release(this->GetBindGroup());
-    }
+    ~GPUBindGroupImpl() = default;
 
     const CanvasGPUBindGroup *GetBindGroup();
 
@@ -41,7 +40,7 @@ class GPUBindGroupImpl : ObjectWrapperImpl {
                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    const CanvasGPUBindGroup *group_;
+    ArcHandle<CanvasGPUBindGroup, canvas_native_webgpu_bind_group_release> group_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
index 908e1394..9a306026 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
@@ -9,7 +9,7 @@ GPUBindGroupLayoutImpl::GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *g
         : groupLayout_(groupLayout) {}
 
 const CanvasGPUBindGroupLayout *GPUBindGroupLayoutImpl::GetBindGroupLayout() {
-    return this->groupLayout_;
+    return this->groupLayout_.get();
 }
 
 
@@ -63,7 +63,7 @@ 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_);
+        auto label = canvas_native_webgpu_bind_group_layout_get_label(ptr->groupLayout_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
index 58f93edf..e5287d4e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUBindGroupLayoutImpl : ObjectWrapperImpl {
 public:
     explicit GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *groupLayout);
 
-    ~GPUBindGroupLayoutImpl() {
-        canvas_native_webgpu_bind_group_layout_release(this->GetBindGroupLayout());
-    }
+    ~GPUBindGroupLayoutImpl() = default;
 
     const CanvasGPUBindGroupLayout *GetBindGroupLayout();
 
@@ -41,7 +40,7 @@ class GPUBindGroupLayoutImpl : ObjectWrapperImpl {
                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    const CanvasGPUBindGroupLayout *groupLayout_;
+    ArcHandle<CanvasGPUBindGroupLayout, canvas_native_webgpu_bind_group_layout_release> groupLayout_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
index 78aaad32..2e38ab9b 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
@@ -8,7 +8,7 @@
 GPUBufferImpl::GPUBufferImpl(const CanvasGPUBuffer *buffer) : buffer_(buffer) {}
 
 const CanvasGPUBuffer *GPUBufferImpl::GetGPUBuffer() {
-    return this->buffer_;
+    return this->buffer_.get();
 }
 
 
@@ -261,7 +261,7 @@ 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_);
+        auto label = canvas_native_webgpu_buffer_get_label(ptr->buffer_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
index 5794e23d..81ad9faa 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
@@ -7,15 +7,14 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 
 class GPUBufferImpl : ObjectWrapperImpl {
 public:
     explicit GPUBufferImpl(const CanvasGPUBuffer *buffer);
 
-    ~GPUBufferImpl() {
-        canvas_native_webgpu_buffer_release(this->GetGPUBuffer());
-    }
+    ~GPUBufferImpl() = default;
 
     const CanvasGPUBuffer *GetGPUBuffer();
 
@@ -56,7 +55,7 @@ class GPUBufferImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUBuffer *buffer_;
+    ArcHandle<CanvasGPUBuffer, canvas_native_webgpu_buffer_release> buffer_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
index 47e7a1e8..129109db 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
@@ -32,7 +32,7 @@ GPUCanvasContextImpl::GPUCanvasContextImpl(const CanvasGPUCanvasContext *context
 																																														 }
 
 const CanvasGPUCanvasContext *GPUCanvasContextImpl::GetContext() {
-	return this->context_;
+	return this->context_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
index 912f335d..ec846d60 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
@@ -10,6 +10,7 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 #include "GPUDeviceImpl.h"
 #include "GPUTextureImpl.h"
 
@@ -51,8 +52,9 @@ class GPUCanvasContextImpl : ObjectWrapperImpl {
 	}
 	
 	~GPUCanvasContextImpl() {
+		// raf_ first (its callback can reference the context), then context_ is
+		// released by its ArcHandle member as this object is destroyed.
 		this->raf_.reset();
-		canvas_native_webgpu_context_release(this->context_);
 	}
 	
 	const CanvasGPUCanvasContext *GetContext();
@@ -102,7 +104,7 @@ class GPUCanvasContextImpl : ObjectWrapperImpl {
 	static void Flush(intptr_t context);
 	
 private:
-	const CanvasGPUCanvasContext *context_;
+	ArcHandle<CanvasGPUCanvasContext, canvas_native_webgpu_context_release> context_;
 	std::shared_ptr<RafImpl> raf_;
 	
 	bool continuousRender_ = true;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
index a1226c1a..d83eab6e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
@@ -10,7 +10,7 @@ GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *command
         commandBuffer) {}
 
 const CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
-    return this->commandBuffer_;
+    return this->commandBuffer_.get();
 }
 
 
@@ -53,6 +53,10 @@ v8::Local<v8::FunctionTemplate> GPUCommandBufferImpl::GetCtor(v8::Isolate *isola
             GetLabel
     );
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
 
     cache->GPUCommandBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -60,12 +64,19 @@ v8::Local<v8::FunctionTemplate> GPUCommandBufferImpl::GetCtor(v8::Isolate *isola
 }
 
 
+void GPUCommandBufferImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        ptr->Release();
+    }
+}
+
 void
 GPUCommandBufferImpl::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_command_buffer_get_label(ptr->commandBuffer_);
+        auto label = canvas_native_webgpu_command_buffer_get_label(ptr->commandBuffer_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
index dd728598..5f8ba55e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
@@ -8,17 +8,19 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUCommandBufferImpl : ObjectWrapperImpl {
 public:
     explicit GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer);
 
-    ~GPUCommandBufferImpl() {
-        canvas_native_webgpu_command_buffer_release(this->commandBuffer_);
-    }
+    // Deterministic dispose, called from Destroy() at queue.submit(). See ArcHandle.h.
+    void Release() { commandBuffer_.reset(); }
 
     const CanvasGPUCommandBuffer *GetGPUCommandBuffer();
 
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPUCommandBufferImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -41,7 +43,7 @@ class GPUCommandBufferImpl : ObjectWrapperImpl {
                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    const CanvasGPUCommandBuffer *commandBuffer_;
+    ArcHandle<CanvasGPUCommandBuffer, canvas_native_webgpu_command_buffer_release> commandBuffer_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
index 0e644e1b..84c6ee8c 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
@@ -17,7 +17,7 @@ GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *enco
 																																																encoder) {}
 
 const CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
-	return this->encoder_;
+	return this->encoder_.get();
 }
 
 void GPUCommandEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
@@ -110,19 +110,30 @@ v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isol
 	tmpl->Set(
 						ConvertToV8String(isolate, "writeTimestamp"),
 						v8::FunctionTemplate::New(isolate, &WriteTimestamp));
-	
-	
+
+	tmpl->Set(
+						ConvertToV8String(isolate, "destroy"),
+						v8::FunctionTemplate::New(isolate, &Destroy));
+
+
 	cache->GPUCommandEncoderTmpl =
 	std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
 	return ctorTmpl;
 }
 
+void GPUCommandEncoderImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	auto ptr = GetPointer(args.This());
+	if (ptr != nullptr) {
+		ptr->Release();
+	}
+}
+
 void
 GPUCommandEncoderImpl::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_command_encoder_get_label(ptr->encoder_);
+		auto label = canvas_native_webgpu_command_encoder_get_label(ptr->encoder_.get());
 		if (label == nullptr) {
 			info.GetReturnValue().SetEmptyString();
 			return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
index 608716e1..0c45da60 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
@@ -8,17 +8,19 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 #include "GPUUtils.h"
+#include "ArcHandle.h"
 
 class GPUCommandEncoderImpl : ObjectWrapperImpl {
 public:
     explicit GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder);
 
-    ~GPUCommandEncoderImpl() {
-        canvas_native_webgpu_command_encoder_release(this->encoder_);
-    }
+    // Deterministic dispose, called from Destroy() at encoder.finish(). See ArcHandle.h.
+    void Release() { encoder_.reset(); }
 
     const CanvasGPUCommandEncoder *GetEncoder();
 
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPUCommandEncoderImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -66,7 +68,7 @@ class GPUCommandEncoderImpl : ObjectWrapperImpl {
     static void WriteTimestamp(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    const CanvasGPUCommandEncoder *encoder_;
+    ArcHandle<CanvasGPUCommandEncoder, canvas_native_webgpu_command_encoder_release> encoder_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.cpp
index 270450a2..f446ebeb 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.cpp
@@ -10,7 +10,7 @@ GPUCompilationInfoImpl::GPUCompilationInfoImpl(CanvasGPUCompilationInfo *info) :
         info) {}
 
 CanvasGPUCompilationInfo *GPUCompilationInfoImpl::GetCompilationInfo() {
-    return this->info_;
+    return this->info_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.h
index 7463fd1d..9a2fd343 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationInfoImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUCompilationInfoImpl : ObjectWrapperImpl {
 public:
     explicit GPUCompilationInfoImpl(CanvasGPUCompilationInfo *info);
 
-    ~GPUCompilationInfoImpl() {
-        canvas_native_webgpu_compilation_info_release(this->GetCompilationInfo());
-    }
+    ~GPUCompilationInfoImpl() = default;
 
     CanvasGPUCompilationInfo* GetCompilationInfo();
 
@@ -42,7 +41,7 @@ class GPUCompilationInfoImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUCompilationInfo *info_;
+    MutArcHandle<CanvasGPUCompilationInfo, canvas_native_webgpu_compilation_info_release> info_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.cpp
index 9f71385e..cc2f641a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.cpp
@@ -10,7 +10,7 @@ GPUCompilationMessageImpl::GPUCompilationMessageImpl(CanvasGPUCompilationMessage
         message) {}
 
 CanvasGPUCompilationMessage *GPUCompilationMessageImpl::GetMessage() {
-    return this->message_;
+    return this->message_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.h
index e3a00a68..b56f5677 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCompilationMessageImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUCompilationMessageImpl : ObjectWrapperImpl {
 public:
     explicit GPUCompilationMessageImpl(CanvasGPUCompilationMessage *message);
 
-    ~GPUCompilationMessageImpl() {
-        canvas_native_webgpu_compilation_message_release(this->GetMessage());
-    }
+    ~GPUCompilationMessageImpl() = default;
 
     CanvasGPUCompilationMessage *GetMessage();
 
@@ -57,7 +56,7 @@ class GPUCompilationMessageImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUCompilationMessage *message_;
+    MutArcHandle<CanvasGPUCompilationMessage, canvas_native_webgpu_compilation_message_release> message_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
index 583dedb1..218e6cf6 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
@@ -13,7 +13,7 @@ GPUComputePassEncoderImpl::GPUComputePassEncoderImpl(const CanvasGPUComputePassE
         pass) {}
 
 const CanvasGPUComputePassEncoder *GPUComputePassEncoderImpl::GetComputePass() {
-    return this->computePass_;
+    return this->computePass_.get();
 }
 
 
@@ -90,6 +90,10 @@ v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *
             ConvertToV8String(isolate, "setPipeline"),
             v8::FunctionTemplate::New(isolate, &SetPipeline));
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
 
     cache->GPUComputePassEncoderTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>
@@ -97,12 +101,19 @@ v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *
     return ctorTmpl;
 }
 
+void GPUComputePassEncoderImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        ptr->Release();
+    }
+}
+
 void
 GPUComputePassEncoderImpl::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_compute_pass_encoder_get_label(ptr->computePass_);
+        auto label = canvas_native_webgpu_compute_pass_encoder_get_label(ptr->computePass_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h
index bbcc283c..9730b63c 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h
@@ -7,17 +7,19 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUComputePassEncoderImpl : ObjectWrapperImpl {
 public:
     explicit GPUComputePassEncoderImpl(const CanvasGPUComputePassEncoder *computePass);
 
-    ~GPUComputePassEncoderImpl() {
-        canvas_native_webgpu_compute_pass_encoder_release(this->computePass_);
-    }
+    // Deterministic dispose, called from Destroy() at pass.end(). See ArcHandle.h.
+    void Release() { computePass_.reset(); }
 
     const CanvasGPUComputePassEncoder *GetComputePass();
 
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPUComputePassEncoderImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -58,7 +60,7 @@ class GPUComputePassEncoderImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUComputePassEncoder *computePass_;
+    ArcHandle<CanvasGPUComputePassEncoder, canvas_native_webgpu_compute_pass_encoder_release> computePass_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.cpp
index c9a04ec6..c1ad222c 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.cpp
@@ -11,7 +11,7 @@ GPUComputePipelineImpl::GPUComputePipelineImpl(const CanvasGPUComputePipeline *p
         pipeline) {}
 
 const CanvasGPUComputePipeline *GPUComputePipelineImpl::GetGPUPipeline() {
-    return this->pipeline_;
+    return this->pipeline_.get();
 }
 
 
@@ -68,7 +68,7 @@ GPUComputePipelineImpl::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_compute_pipeline_get_label(ptr->pipeline_);
+        auto label = canvas_native_webgpu_compute_pipeline_get_label(ptr->pipeline_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.h
index ecb30179..3ffb23ce 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePipelineImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUComputePipelineImpl : ObjectWrapperImpl {
 public:
     explicit GPUComputePipelineImpl(const CanvasGPUComputePipeline *pipeline);
 
-    ~GPUComputePipelineImpl() {
-        canvas_native_webgpu_compute_pipeline_release(this->pipeline_);
-    }
+    ~GPUComputePipelineImpl() = default;
 
     const CanvasGPUComputePipeline *GetGPUPipeline();
 
@@ -44,7 +43,7 @@ class GPUComputePipelineImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUComputePipeline *pipeline_;
+    ArcHandle<CanvasGPUComputePipeline, canvas_native_webgpu_compute_pipeline_release> pipeline_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
index 3b01f0b0..ccaf4567 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
@@ -26,7 +26,7 @@
 GPUDeviceImpl::GPUDeviceImpl(const CanvasGPUDevice *device) : device_(device) {}
 
 const CanvasGPUDevice *GPUDeviceImpl::GetGPUDevice() {
-    return this->device_;
+    return this->device_.get();
 }
 
 
@@ -173,7 +173,7 @@ GPUDeviceImpl::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_device_get_label(ptr->device_);
+        auto label = canvas_native_webgpu_device_get_label(ptr->device_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
index 3cfa4186..4b72c135 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUDeviceImpl : ObjectWrapperImpl {
 public:
     explicit GPUDeviceImpl(const CanvasGPUDevice *device);
 
-    ~GPUDeviceImpl() {
-        canvas_native_webgpu_device_release(this->device_);
-    }
+    ~GPUDeviceImpl() = default;
 
     const CanvasGPUDevice *GetGPUDevice();
 
@@ -90,7 +89,7 @@ class GPUDeviceImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUDevice *device_;
+    ArcHandle<CanvasGPUDevice, canvas_native_webgpu_device_release> device_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
index 55baa72d..0bdeaf0e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
@@ -8,7 +8,7 @@
 GPUImpl::GPUImpl(const CanvasWebGPUInstance *instance) : instance_(instance) {}
 
 const CanvasWebGPUInstance *GPUImpl::GetGPUInstance() {
-    return this->instance_;
+    return this->instance_.get();
 }
 
 void GPUImpl::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate) {
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
index 7729e175..969e998d 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
@@ -9,17 +9,13 @@
 #include "Helpers.h"
 #include "GPUAdapterImpl.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUImpl : ObjectWrapperImpl {
 public:
     explicit GPUImpl(const CanvasWebGPUInstance *instance);
 
-    ~GPUImpl() {
-        if (this->instance_ != nullptr) {
-            canvas_native_webgpu_instance_release(this->instance_);
-            this->instance_ = nullptr;
-        }
-    }
+    ~GPUImpl() = default;
 
     const CanvasWebGPUInstance *GetGPUInstance();
 
@@ -48,7 +44,7 @@ class GPUImpl : ObjectWrapperImpl {
     static void RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    const CanvasWebGPUInstance *instance_;
+    ArcHandle<CanvasWebGPUInstance, canvas_native_webgpu_instance_release> instance_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.cpp
index efc0a4c7..d7866f94 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.cpp
@@ -9,7 +9,7 @@ GPUPipelineLayoutImpl::GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipe
         pipeline) {}
 
 const CanvasGPUPipelineLayout *GPUPipelineLayoutImpl::GetPipeline() {
-    return this->pipeline_;
+    return this->pipeline_.get();
 }
 
 
@@ -63,7 +63,7 @@ GPUPipelineLayoutImpl::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_pipeline_layout_get_label(ptr->pipeline_);
+        auto label = canvas_native_webgpu_pipeline_layout_get_label(ptr->pipeline_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h
index 1ed01497..a57df5a9 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h
@@ -8,15 +8,14 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 
 class GPUPipelineLayoutImpl : ObjectWrapperImpl {
 public:
     explicit GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline);
 
-    ~GPUPipelineLayoutImpl() {
-        canvas_native_webgpu_pipeline_layout_release(this->GetPipeline());
-    }
+    ~GPUPipelineLayoutImpl() = default;
 
     const CanvasGPUPipelineLayout *GetPipeline();
 
@@ -42,7 +41,7 @@ class GPUPipelineLayoutImpl : ObjectWrapperImpl {
                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    const CanvasGPUPipelineLayout *pipeline_;
+    ArcHandle<CanvasGPUPipelineLayout, canvas_native_webgpu_pipeline_layout_release> pipeline_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.cpp
index a93113cb..f44561e1 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.cpp
@@ -8,7 +8,7 @@
 GPUQuerySetImpl::GPUQuerySetImpl(const CanvasGPUQuerySet *querySet) : querySet_(querySet) {}
 
 const CanvasGPUQuerySet *GPUQuerySetImpl::GetQuerySet() {
-    return this->querySet_;
+    return this->querySet_.get();
 }
 
 
@@ -131,6 +131,6 @@ void GPUQuerySetImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
     if (ptr == nullptr) {
         return;
     }
-    canvas_native_webgpu_query_set_destroy(ptr->querySet_);
+    canvas_native_webgpu_query_set_destroy(ptr->querySet_.get());
 
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.h
index 6d3efcf5..2f174a69 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.h
@@ -7,14 +7,13 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUQuerySetImpl : ObjectWrapperImpl {
 public:
     explicit GPUQuerySetImpl(const CanvasGPUQuerySet *querySet);
 
-    ~GPUQuerySetImpl() {
-        canvas_native_webgpu_query_set_release(this->GetQuerySet());
-    }
+    ~GPUQuerySetImpl() = default;
 
     const CanvasGPUQuerySet *GetQuerySet();
 
@@ -48,7 +47,7 @@ class GPUQuerySetImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUQuerySet *querySet_;
+    ArcHandle<CanvasGPUQuerySet, canvas_native_webgpu_query_set_release> querySet_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
index 88fef0ff..6bebbe31 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
@@ -17,7 +17,7 @@
 GPUQueueImpl::GPUQueueImpl(const CanvasGPUQueue *queue) : queue_(queue) {}
 
 const CanvasGPUQueue *GPUQueueImpl::GetGPUQueue() {
-    return this->queue_;
+    return this->queue_.get();
 }
 
 
@@ -94,7 +94,7 @@ GPUQueueImpl::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_queue_get_label(ptr->queue_);
+        auto label = canvas_native_webgpu_queue_get_label(ptr->queue_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
index 0ebd7244..6f2a729f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
@@ -8,15 +8,14 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 #include "GPUUtils.h"
 
 class GPUQueueImpl : ObjectWrapperImpl {
 public:
     explicit GPUQueueImpl(const CanvasGPUQueue *queue);
 
-    ~GPUQueueImpl() {
-        canvas_native_webgpu_queue_release(this->GetGPUQueue());
-    }
+    ~GPUQueueImpl() = default;
 
     const CanvasGPUQueue *GetGPUQueue();
 
@@ -52,7 +51,7 @@ class GPUQueueImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUQueue *queue_;
+    ArcHandle<CanvasGPUQueue, canvas_native_webgpu_queue_release> queue_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.cpp
index d192efef..f0e91ec7 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.cpp
@@ -15,7 +15,7 @@ GPURenderBundleEncoderImpl::GPURenderBundleEncoderImpl(const CanvasGPURenderBund
         encoder) {}
 
 const CanvasGPURenderBundleEncoder *GPURenderBundleEncoderImpl::GetEncoder() {
-    return this->encoder_;
+    return this->encoder_.get();
 }
 
 
@@ -121,7 +121,7 @@ GPURenderBundleEncoderImpl::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_render_bundle_encoder_get_label(ptr->encoder_);
+        auto label = canvas_native_webgpu_render_bundle_encoder_get_label(ptr->encoder_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.h
index a43042f9..3c01deec 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.h
@@ -8,15 +8,14 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPURenderBundleEncoderImpl : ObjectWrapperImpl {
 
 public:
     explicit GPURenderBundleEncoderImpl(const CanvasGPURenderBundleEncoder *encoder);
 
-    ~GPURenderBundleEncoderImpl() {
-        canvas_native_webgpu_render_bundle_encoder_release(this->GetEncoder());
-    }
+    ~GPURenderBundleEncoderImpl() = default;
 
     const CanvasGPURenderBundleEncoder *GetEncoder();
 
@@ -67,7 +66,7 @@ class GPURenderBundleEncoderImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPURenderBundleEncoder *encoder_;
+    ArcHandle<CanvasGPURenderBundleEncoder, canvas_native_webgpu_render_bundle_encoder_release> encoder_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.cpp
index c6d8f463..c7602cf7 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.cpp
@@ -9,7 +9,7 @@ GPURenderBundleImpl::GPURenderBundleImpl(const CanvasGPURenderBundle *bundle) :
         bundle) {}
 
 const CanvasGPURenderBundle *GPURenderBundleImpl::GetBundle() {
-    return this->bundle_;
+    return this->bundle_.get();
 }
 
 
@@ -62,7 +62,7 @@ GPURenderBundleImpl::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_render_bundle_get_label(ptr->bundle_);
+        auto label = canvas_native_webgpu_render_bundle_get_label(ptr->bundle_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.h
index 08f1971e..5e76772b 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPURenderBundleImpl : ObjectWrapperImpl {
 public:
     explicit GPURenderBundleImpl(const CanvasGPURenderBundle *bundle);
 
-    ~GPURenderBundleImpl() {
-        canvas_native_webgpu_render_bundle_release(this->bundle_);
-    }
+    ~GPURenderBundleImpl() = default;
 
     const CanvasGPURenderBundle *GetBundle();
 
@@ -41,7 +40,7 @@ class GPURenderBundleImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPURenderBundle *bundle_;
+    ArcHandle<CanvasGPURenderBundle, canvas_native_webgpu_render_bundle_release> bundle_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
index 4e46a1f9..785098d6 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
@@ -14,7 +14,7 @@ GPURenderPassEncoderImpl::GPURenderPassEncoderImpl(const CanvasGPURenderPassEnco
         pass) {}
 
 const CanvasGPURenderPassEncoder *GPURenderPassEncoderImpl::GetPass() {
-    return this->pass_;
+    return this->pass_.get();
 }
 
 
@@ -143,18 +143,29 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
             ConvertToV8String(isolate, "setViewport"),
             v8::FunctionTemplate::New(isolate, &SetViewport));
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
     cache->GPURenderPassEncoderTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
 
+void GPURenderPassEncoderImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        ptr->Release();
+    }
+}
+
 void
 GPURenderPassEncoderImpl::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_render_pass_encoder_get_label(ptr->pass_);
+        auto label = canvas_native_webgpu_render_pass_encoder_get_label(ptr->pass_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
index 0a8c146f..ed4e23ab 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
@@ -9,17 +9,19 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 #include "GPUUtils.h"
+#include "ArcHandle.h"
 
 class GPURenderPassEncoderImpl : ObjectWrapperImpl {
 public:
     explicit GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass);
 
-    ~GPURenderPassEncoderImpl() {
-        canvas_native_webgpu_render_pass_encoder_release(this->GetPass());
-    }
+    // Deterministic dispose, called from Destroy() at pass.end(). See ArcHandle.h.
+    void Release() { pass_.reset(); }
 
     const CanvasGPURenderPassEncoder *GetPass();
 
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPURenderPassEncoderImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -85,7 +87,7 @@ class GPURenderPassEncoderImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPURenderPassEncoder *pass_;
+    ArcHandle<CanvasGPURenderPassEncoder, canvas_native_webgpu_render_pass_encoder_release> pass_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
index 9229a5e1..67223fec 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
@@ -10,7 +10,7 @@ GPURenderPipelineImpl::GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipe
         pipeline) {}
 
 const CanvasGPURenderPipeline *GPURenderPipelineImpl::GetGPUPipeline() {
-    return this->pipeline_;
+    return this->pipeline_.get();
 }
 
 
@@ -92,7 +92,7 @@ GPURenderPipelineImpl::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_render_pipeline_get_label(ptr->pipeline_);
+        auto label = canvas_native_webgpu_render_pipeline_get_label(ptr->pipeline_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
index b2512cfe..17e3049d 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPURenderPipelineImpl : ObjectWrapperImpl {
 public:
     explicit GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipeline);
 
-    ~GPURenderPipelineImpl() {
-        canvas_native_webgpu_render_pipeline_release(this->pipeline_);
-    }
+    ~GPURenderPipelineImpl() = default;
 
     const CanvasGPURenderPipeline *GetGPUPipeline();
 
@@ -45,7 +44,7 @@ class GPURenderPipelineImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPURenderPipeline *pipeline_;
+    ArcHandle<CanvasGPURenderPipeline, canvas_native_webgpu_render_pipeline_release> pipeline_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.cpp
index aaeb15e2..82783a5a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.cpp
@@ -9,7 +9,7 @@ GPUSamplerImpl::GPUSamplerImpl(const CanvasGPUSampler *sampler) : sampler_(
         sampler) {}
 
 const CanvasGPUSampler *GPUSamplerImpl::GetSampler() {
-    return this->sampler_;
+    return this->sampler_.get();
 }
 
 
@@ -63,7 +63,7 @@ GPUSamplerImpl::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_sampler_get_label(ptr->sampler_);
+        auto label = canvas_native_webgpu_sampler_get_label(ptr->sampler_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.h
index 44c6ff4b..09aba01e 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSamplerImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUSamplerImpl : ObjectWrapperImpl {
 public:
     explicit GPUSamplerImpl(const CanvasGPUSampler *sampler);
 
-    ~GPUSamplerImpl() {
-        canvas_native_webgpu_sampler_release(this->sampler_);
-    }
+    ~GPUSamplerImpl() = default;
 
     const CanvasGPUSampler *GetSampler();
 
@@ -41,7 +40,7 @@ class GPUSamplerImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUSampler *sampler_;
+    ArcHandle<CanvasGPUSampler, canvas_native_webgpu_sampler_release> sampler_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
index 3487c25d..28193fa1 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
@@ -10,7 +10,7 @@ GPUShaderModuleImpl::GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModu
         shaderModule) {}
 
 const CanvasGPUShaderModule *GPUShaderModuleImpl::GetShaderModule() {
-    return this->shaderModule_;
+    return this->shaderModule_.get();
 }
 
 
@@ -67,7 +67,7 @@ GPUShaderModuleImpl::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_shader_module_get_label(ptr->shaderModule_);
+        auto label = canvas_native_webgpu_shader_module_get_label(ptr->shaderModule_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
index 77acecf2..f6fcf561 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
@@ -8,14 +8,13 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUShaderModuleImpl : ObjectWrapperImpl {
 public:
     explicit GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
 
-    ~GPUShaderModuleImpl() {
-        canvas_native_webgpu_shader_module_release(this->GetShaderModule());
-    }
+    ~GPUShaderModuleImpl() = default;
 
     const CanvasGPUShaderModule *GetShaderModule();
 
@@ -43,7 +42,7 @@ class GPUShaderModuleImpl : ObjectWrapperImpl {
     static void GetCompilationInfo(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    const CanvasGPUShaderModule *shaderModule_;
+    ArcHandle<CanvasGPUShaderModule, canvas_native_webgpu_shader_module_release> shaderModule_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.cpp
index 91d7406e..97b13b56 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.cpp
@@ -9,7 +9,7 @@ GPUSupportedLimitsImpl::GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits)
         limits) {}
 
 CanvasGPUSupportedLimits *GPUSupportedLimitsImpl::GetLimits() {
-    return this->limits_;
+    return this->limits_.get();
 }
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
index 387c4268..349d6af7 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
@@ -7,14 +7,13 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUSupportedLimitsImpl : public ObjectWrapperImpl {
 public:
     explicit GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
 
-    ~GPUSupportedLimitsImpl() {
-        canvas_native_webgpu_limits_release(this->limits_);
-    }
+    ~GPUSupportedLimitsImpl() = default;
 
     CanvasGPUSupportedLimits *GetLimits();
 
@@ -281,7 +280,7 @@ class GPUSupportedLimitsImpl : public ObjectWrapperImpl {
                                          const v8::PropertyCallbackInfo<void> &info);
 
 private:
-    CanvasGPUSupportedLimits *limits_;
+    MutArcHandle<CanvasGPUSupportedLimits, canvas_native_webgpu_limits_release> limits_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
index a0c701b3..e8b74846 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
@@ -10,7 +10,7 @@
 GPUTextureImpl::GPUTextureImpl(const CanvasGPUTexture *texture) : texture_(texture) {}
 
 const CanvasGPUTexture *GPUTextureImpl::GetTexture() {
-    return this->texture_;
+    return this->texture_.get();
 }
 
 
@@ -57,6 +57,10 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "destroy"),
             v8::FunctionTemplate::New(isolate, &Destroy));
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "__releaseHandle"),
+            v8::FunctionTemplate::New(isolate, &ReleaseHandle));
+
 
     tmpl->SetLazyDataProperty(
             ConvertToV8String(isolate, "width"),
@@ -118,7 +122,7 @@ GPUTextureImpl::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_texture_get_label(ptr->texture_);
+        auto label = canvas_native_webgpu_texture_get_label(ptr->texture_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
@@ -256,6 +260,14 @@ void GPUTextureImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
 }
 
 
+void GPUTextureImpl::ReleaseHandle(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUTextureImpl *ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        ptr->Release();
+    }
+}
+
+
 void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUTextureImpl *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
index 2d1688f7..db8a91bf 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
@@ -8,17 +8,19 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUTextureImpl : ObjectWrapperImpl {
 public:
     explicit GPUTextureImpl(const CanvasGPUTexture *texture);
 
-    ~GPUTextureImpl() {
-        canvas_native_webgpu_texture_release(this->GetTexture());
-    }
+    ~GPUTextureImpl() = default;
 
     const CanvasGPUTexture *GetTexture();
 
+    // drops the wrapper's Arc handle (not destroy(), which frees the GPU texture)
+    void Release() { texture_.reset(); }
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPUTextureImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -67,10 +69,13 @@ class GPUTextureImpl : ObjectWrapperImpl {
 
     static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    // JS __releaseHandle: drops the wrapper's handle without destroying the texture
+    static void ReleaseHandle(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void CreateView(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    const CanvasGPUTexture *texture_;
+    ArcHandle<CanvasGPUTexture, canvas_native_webgpu_texture_release> texture_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
index 3a810306..a25ab212 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
@@ -8,7 +8,7 @@
 GPUTextureViewImpl::GPUTextureViewImpl(const CanvasGPUTextureView *view) : view_(view) {}
 
 const CanvasGPUTextureView *GPUTextureViewImpl::GetTextureView() {
-    return this->view_;
+    return this->view_.get();
 }
 
 
@@ -51,6 +51,10 @@ v8::Local<v8::FunctionTemplate> GPUTextureViewImpl::GetCtor(v8::Isolate *isolate
             GetLabel
     );
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
 
     cache->GPUTextureViewTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -58,12 +62,19 @@ v8::Local<v8::FunctionTemplate> GPUTextureViewImpl::GetCtor(v8::Isolate *isolate
 }
 
 
+void GPUTextureViewImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        ptr->Release();
+    }
+}
+
 void
 GPUTextureViewImpl::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_texture_view_get_label(ptr->view_);
+        auto label = canvas_native_webgpu_texture_view_get_label(ptr->view_.get());
         if (label == nullptr) {
             info.GetReturnValue().SetEmptyString();
             return;
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
index 7432434f..608362ca 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
@@ -8,17 +8,19 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "ArcHandle.h"
 
 class GPUTextureViewImpl : ObjectWrapperImpl {
 public:
     explicit GPUTextureViewImpl(const CanvasGPUTextureView *view);
 
-    ~GPUTextureViewImpl() {
-        canvas_native_webgpu_texture_view_release(this->GetTextureView());
-    }
+    // deterministic dispose, called from Destroy() at present
+    void Release() { view_.reset(); }
 
     const CanvasGPUTextureView *GetTextureView();
 
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static GPUTextureViewImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -41,7 +43,7 @@ class GPUTextureViewImpl : ObjectWrapperImpl {
 
 
 private:
-    const CanvasGPUTextureView *view_;
+    ArcHandle<CanvasGPUTextureView, canvas_native_webgpu_texture_view_release> view_;
 };