@nativescript/canvas 2.0.0-rc.10 → 2.0.0-rc.11

package/platforms/ios/CanvasNative.xcframework/Info.plist

@@ -10,18 +10,15 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -29,15 +26,18 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/CanvasNative-Swift.h

@@ -1,6 +1,6 @@
 #if 0
 #elif defined(__arm64__) && __arm64__
-// Generated by Apple Swift version 5.10 (swiftlang-5.10.0.13 clang-1500.3.9.4)
+// Generated by Apple Swift version 6.0.2 effective-5.10 (swiftlang-6.0.2.1.2 clang-1600.0.26.4)
 #ifndef CANVASNATIVE_SWIFT_H
 #define CANVASNATIVE_SWIFT_H
 #pragma clang diagnostic push
@@ -42,6 +42,8 @@
 #include <string.h>
 #endif
 #if defined(__cplusplus)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnon-modular-include-in-framework-module"
 #if defined(__arm64e__) && __has_include(<ptrauth.h>)
 # include <ptrauth.h>
 #else
@@ -55,6 +57,7 @@
 # endif
 #pragma clang diagnostic pop
 #endif
+#pragma clang diagnostic pop
 #endif
 
 #if !defined(SWIFT_TYPEDEFS)
@@ -297,6 +300,7 @@ typedef unsigned int swift_uint4  __attribute__((__ext_vector_type__(4)));
 #pragma clang diagnostic ignored "-Wunknown-pragmas"
 #pragma clang diagnostic ignored "-Wnullability"
 #pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
 
 #if __has_attribute(external_source_symbol)
 # pragma push_macro("any")
@@ -306,15 +310,16 @@ typedef unsigned int swift_uint4  __attribute__((__ext_vector_type__(4)));
 #endif
 
 #if defined(__OBJC__)
+@class NSMutableData;
 @class NSCoder;
 
 SWIFT_CLASS_NAMED("CanvasCPUView")
 @interface CanvasCPUView : UIView
 @property (nonatomic) BOOL ignorePixelScaling;
+@property (nonatomic, readonly, strong) NSMutableData * _Nullable data;
 - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
 - (nonnull instancetype)initWithFrame:(CGRect)frame OBJC_DESIGNATED_INITIALIZER;
 - (nullable instancetype)initWithCoder:(NSCoder * _Nonnull)coder SWIFT_UNAVAILABLE;
-- (void)drawRect:(CGRect)rect;
 @end
 
 @class NSCCanvas;
@@ -333,7 +338,6 @@ SWIFT_CLASS_NAMED("CanvasGLKView")
 @end
 
 @class UIImage;
-@class NSMutableData;
 @class NSString;
 @class NSData;
 @class NSError;
@@ -395,14 +399,15 @@ SWIFT_CLASS_PROPERTY(@property (nonatomic, class, readonly, strong) NSMutableDic
 @property (nonatomic) BOOL autoScale;
 @property (nonatomic, readonly) int64_t nativeContext;
 @property (nonatomic, readonly) BOOL is2D;
+@property (nonatomic, readonly) BOOL willReadFrequently;
 @property (nonatomic, readonly) CGFloat drawingBufferWidth;
 @property (nonatomic, readonly) CGFloat drawingBufferHeight;
 @property (nonatomic, readonly) float width;
 @property (nonatomic, readonly) float height;
 - (NSString * _Nonnull)toDataURL:(NSString * _Nonnull)format :(float)quality SWIFT_WARN_UNUSED_RESULT;
-- (void)initContext:(NSString * _Nonnull)type :(BOOL)alpha :(BOOL)antialias :(BOOL)depth :(BOOL)failIfMajorPerformanceCaveat :(int32_t)powerPreference :(BOOL)premultipliedAlpha :(BOOL)preserveDrawingBuffer :(BOOL)stencil :(BOOL)desynchronized :(BOOL)xrCompatible SWIFT_METHOD_FAMILY(none);
+- (void)initContext:(NSString * _Nonnull)type :(BOOL)alpha :(BOOL)antialias :(BOOL)depth :(BOOL)failIfMajorPerformanceCaveat :(int32_t)powerPreference :(BOOL)premultipliedAlpha :(BOOL)preserveDrawingBuffer :(BOOL)stencil :(BOOL)desynchronized :(BOOL)xrCompatible :(BOOL)willReadFrequently SWIFT_METHOD_FAMILY(none);
 - (void)initWebGPUContext:(int64_t)instance SWIFT_METHOD_FAMILY(none);
-- (int64_t)create2DContext:(BOOL)alpha :(BOOL)antialias :(BOOL)depth :(BOOL)failIfMajorPerformanceCaveat :(int32_t)powerPreference :(BOOL)premultipliedAlpha :(BOOL)preserveDrawingBuffer :(BOOL)stencil :(BOOL)desynchronized :(BOOL)xrCompatible :(int32_t)fontColor SWIFT_WARN_UNUSED_RESULT;
+- (int64_t)create2DContext:(BOOL)alpha :(BOOL)antialias :(BOOL)depth :(BOOL)failIfMajorPerformanceCaveat :(int32_t)powerPreference :(BOOL)premultipliedAlpha :(BOOL)preserveDrawingBuffer :(BOOL)stencil :(BOOL)desynchronized :(BOOL)xrCompatible :(int32_t)fontColor :(BOOL)willReadFrequently SWIFT_WARN_UNUSED_RESULT;
 - (UIImage * _Nullable)snapshot:(BOOL)flip SWIFT_WARN_UNUSED_RESULT;
 - (BOOL)render;
 @property (nonatomic, copy) void (^ _Nullable touchEventListener)(NSString * _Nonnull, UIGestureRecognizer * _Nonnull);

package/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h

@@ -453,6 +453,20 @@ typedef enum CanvasStorageTextureAccess {
    * ```
    */
   CanvasStorageTextureAccessReadWrite,
+  /**
+   * The texture can be both read and written in the shader via atomics and must be annotated
+   * with `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<r32uint, atomic>;
+   * ```
+   */
+  CanvasStorageTextureAccessAtomic,
 } CanvasStorageTextureAccess;
 
 typedef enum CanvasStoreOp {
@@ -511,41 +525,51 @@ typedef enum CanvasTextureViewDimension {
 } CanvasTextureViewDimension;
 
 typedef enum CanvasVertexFormat {
-  CanvasVertexFormatUint8x2 = 0,
-  CanvasVertexFormatUint8x4 = 1,
-  CanvasVertexFormatSint8x2 = 2,
-  CanvasVertexFormatSint8x4 = 3,
-  CanvasVertexFormatUnorm8x2 = 4,
-  CanvasVertexFormatUnorm8x4 = 5,
-  CanvasVertexFormatSnorm8x2 = 6,
-  CanvasVertexFormatSnorm8x4 = 7,
-  CanvasVertexFormatUint16x2 = 8,
-  CanvasVertexFormatUint16x4 = 9,
-  CanvasVertexFormatSint16x2 = 10,
-  CanvasVertexFormatSint16x4 = 11,
-  CanvasVertexFormatUnorm16x2 = 12,
-  CanvasVertexFormatUnorm16x4 = 13,
-  CanvasVertexFormatSnorm16x2 = 14,
-  CanvasVertexFormatSnorm16x4 = 15,
-  CanvasVertexFormatFloat16x2 = 16,
-  CanvasVertexFormatFloat16x4 = 17,
-  CanvasVertexFormatFloat32 = 18,
-  CanvasVertexFormatFloat32x2 = 19,
-  CanvasVertexFormatFloat32x3 = 20,
-  CanvasVertexFormatFloat32x4 = 21,
-  CanvasVertexFormatUint32 = 22,
-  CanvasVertexFormatUint32x2 = 23,
-  CanvasVertexFormatUint32x3 = 24,
-  CanvasVertexFormatUint32x4 = 25,
-  CanvasVertexFormatSint32 = 26,
-  CanvasVertexFormatSint32x2 = 27,
-  CanvasVertexFormatSint32x3 = 28,
-  CanvasVertexFormatSint32x4 = 29,
-  CanvasVertexFormatFloat64 = 30,
-  CanvasVertexFormatFloat64x2 = 31,
-  CanvasVertexFormatFloat64x3 = 32,
-  CanvasVertexFormatFloat64x4 = 33,
-  CanvasVertexFormatUnorm10_10_10_2 = 34,
+  CanvasVertexFormatUint8 = 0,
+  CanvasVertexFormatUint8x2 = 1,
+  CanvasVertexFormatUint8x4 = 2,
+  CanvasVertexFormatSint8 = 3,
+  CanvasVertexFormatSint8x2 = 4,
+  CanvasVertexFormatSint8x4 = 5,
+  CanvasVertexFormatUnorm8 = 6,
+  CanvasVertexFormatUnorm8x2 = 7,
+  CanvasVertexFormatUnorm8x4 = 8,
+  CanvasVertexFormatSnorm8 = 9,
+  CanvasVertexFormatSnorm8x2 = 10,
+  CanvasVertexFormatSnorm8x4 = 11,
+  CanvasVertexFormatUint16 = 12,
+  CanvasVertexFormatUint16x2 = 13,
+  CanvasVertexFormatUint16x4 = 14,
+  CanvasVertexFormatSint16 = 15,
+  CanvasVertexFormatSint16x2 = 16,
+  CanvasVertexFormatSint16x4 = 17,
+  CanvasVertexFormatUnorm16 = 18,
+  CanvasVertexFormatUnorm16x2 = 19,
+  CanvasVertexFormatUnorm16x4 = 20,
+  CanvasVertexFormatSnorm16 = 21,
+  CanvasVertexFormatSnorm16x2 = 22,
+  CanvasVertexFormatSnorm16x4 = 23,
+  CanvasVertexFormatFloat16 = 24,
+  CanvasVertexFormatFloat16x2 = 25,
+  CanvasVertexFormatFloat16x4 = 26,
+  CanvasVertexFormatFloat32 = 27,
+  CanvasVertexFormatFloat32x2 = 28,
+  CanvasVertexFormatFloat32x3 = 29,
+  CanvasVertexFormatFloat32x4 = 30,
+  CanvasVertexFormatUint32 = 31,
+  CanvasVertexFormatUint32x2 = 32,
+  CanvasVertexFormatUint32x3 = 33,
+  CanvasVertexFormatUint32x4 = 34,
+  CanvasVertexFormatSint32 = 35,
+  CanvasVertexFormatSint32x2 = 36,
+  CanvasVertexFormatSint32x3 = 37,
+  CanvasVertexFormatSint32x4 = 38,
+  CanvasVertexFormatFloat64 = 39,
+  CanvasVertexFormatFloat64x2 = 40,
+  CanvasVertexFormatFloat64x3 = 41,
+  CanvasVertexFormatFloat64x4 = 42,
+  CanvasVertexFormatUnorm10_10_10_2 = 43,
+  CanvasVertexFormatUnorm8x4Bgra = 44,
 } CanvasVertexFormat;
 
 typedef enum CanvasVertexStepMode {
@@ -602,6 +626,7 @@ typedef enum SurfaceGetCurrentTextureStatus {
   SurfaceGetCurrentTextureStatusOutOfMemory = 4,
   SurfaceGetCurrentTextureStatusDeviceLost = 5,
   SurfaceGetCurrentTextureStatusForce32 = 2147483647,
+  SurfaceGetCurrentTextureStatusUnknown = 6,
 } SurfaceGetCurrentTextureStatus;
 
 typedef enum TextBaseLine {
@@ -657,6 +682,8 @@ typedef enum WebGLResultType {
 
 typedef struct ANGLE_instanced_arrays ANGLE_instanced_arrays;
 
+typedef struct BoolBuffer BoolBuffer;
+
 typedef struct CCow CCow;
 
 typedef struct CanvasConstants CanvasConstants;
@@ -954,6 +981,7 @@ typedef enum CanvasGPUTextureFormat_Tag {
    * Red, green, and blue channels. 11 bit float with no sign bit for RG channels. 10 bit float with no sign bit for blue channel. Float in shader.
    */
   CanvasGPUTextureFormatRg11b10UFloat,
+  CanvasGPUTextureFormatR64Uint,
   /**
    * Red and green channels. 32 bit integer per channel. Unsigned in shader.
    */
@@ -1301,6 +1329,8 @@ typedef struct CanvasGPUSupportedLimits {
   uint32_t max_storage_buffers_per_shader_stage;
   uint32_t max_storage_textures_per_shader_stage;
   uint32_t max_uniform_buffers_per_shader_stage;
+  uint32_t max_binding_array_elements_per_shader_stage;
+  uint32_t max_binding_array_sampler_elements_per_shader_stage;
   uint32_t max_uniform_buffer_binding_size;
   uint32_t max_storage_buffer_binding_size;
   uint32_t max_vertex_buffers;
@@ -1369,10 +1399,24 @@ typedef struct CanvasColor {
 #define CanvasColor_GREEN (CanvasColor){ .r = 0.0, .g = 1.0, .b = 0.0, .a = 1.0 }
 #define CanvasColor_BLUE (CanvasColor){ .r = 0.0, .g = 0.0, .b = 1.0, .a = 1.0 }
 
+typedef enum CanvasOptionalColor_Tag {
+  CanvasOptionalColorNone,
+  CanvasOptionalColorSome,
+} CanvasOptionalColor_Tag;
+
+typedef struct CanvasOptionalColor {
+  CanvasOptionalColor_Tag tag;
+  union {
+    struct {
+      struct CanvasColor some;
+    };
+  };
+} CanvasOptionalColor;
+
 typedef struct CanvasPassChannelColor {
   enum CanvasLoadOp load_op;
   enum CanvasStoreOp store_op;
-  struct CanvasColor clear_value;
+  struct CanvasOptionalColor clear_value;
   bool read_only;
 } CanvasPassChannelColor;
 
@@ -1382,6 +1426,20 @@ typedef struct CanvasRenderPassColorAttachment {
   struct CanvasPassChannelColor channel;
 } CanvasRenderPassColorAttachment;
 
+typedef enum CanvasOptionF32_Tag {
+  CanvasOptionF32None,
+  CanvasOptionF32Some,
+} CanvasOptionF32_Tag;
+
+typedef struct CanvasOptionF32 {
+  CanvasOptionF32_Tag tag;
+  union {
+    struct {
+      float some;
+    };
+  };
+} CanvasOptionF32;
+
 typedef enum CanvasOptionalLoadOp_Tag {
   CanvasOptionalLoadOpNone,
   CanvasOptionalLoadOpSome,
@@ -1412,7 +1470,7 @@ typedef struct CanvasOptionalStoreOp {
 
 typedef struct CanvasRenderPassDepthStencilAttachment {
   const struct CanvasGPUTextureView *view;
-  float depth_clear_value;
+  struct CanvasOptionF32 depth_clear_value;
   struct CanvasOptionalLoadOp depth_load_op;
   struct CanvasOptionalStoreOp depth_store_op;
   bool depth_read_only;
@@ -1590,6 +1648,20 @@ typedef struct CanvasVertexState {
   uintptr_t buffers_size;
 } CanvasVertexState;
 
+typedef enum CanvasOptionalPrimitiveTopology_Tag {
+  CanvasOptionalPrimitiveTopologyNone,
+  CanvasOptionalPrimitiveTopologySome,
+} CanvasOptionalPrimitiveTopology_Tag;
+
+typedef struct CanvasOptionalPrimitiveTopology {
+  CanvasOptionalPrimitiveTopology_Tag tag;
+  union {
+    struct {
+      enum CanvasPrimitiveTopology some;
+    };
+  };
+} CanvasOptionalPrimitiveTopology;
+
 typedef enum CanvasOptionalIndexFormat_Tag {
   CanvasOptionalIndexFormatNone,
   CanvasOptionalIndexFormatSome,
@@ -1605,7 +1677,7 @@ typedef struct CanvasOptionalIndexFormat {
 } CanvasOptionalIndexFormat;
 
 typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalPrimitiveTopology topology;
   struct CanvasOptionalIndexFormat strip_index_format;
   enum CanvasFrontFace front_face;
   enum CanvasCullMode cull_mode;
@@ -1865,6 +1937,29 @@ typedef struct CanvasImageCopyExternalImage {
   uint32_t height;
 } CanvasImageCopyExternalImage;
 
+typedef struct CanvasImageCopyGPUContext {
+  /**
+   * The texture to be copied from. The copy source data is captured at the moment
+   * the copy is issued.
+   */
+  const struct CanvasGPUCanvasContext *source;
+  /**
+   * The base texel used for copying from the external image. Together
+   * with the `copy_size` argument to copy functions, defines the
+   * sub-region of the image to copy.
+   *
+   * Relative to the top left of the image.
+   *
+   * Must be [`Origin2d::ZERO`] if [`DownlevelFlags::UNRESTRICTED_EXTERNAL_TEXTURE_COPIES`] is not supported.
+   */
+  struct CanvasOrigin2d origin;
+  /**
+   * If the Y coordinate of the image should be flipped. Even if this is
+   * true, `origin` is still relative to the top left.
+   */
+  bool flip_y;
+} CanvasImageCopyGPUContext;
+
 typedef struct CanvasImageDataLayout {
   uint64_t offset;
   int32_t bytes_per_row;
@@ -1884,6 +1979,7 @@ typedef struct CanvasCreateTextureViewDescriptor {
   struct CanvasOptionalGPUTextureFormat format;
   enum CanvasOptionalTextureViewDimension dimension;
   const struct CanvasImageSubresourceRange *range;
+  uint32_t usage;
 } CanvasCreateTextureViewDescriptor;
 
 typedef struct FileHelperMime {
@@ -1907,6 +2003,10 @@ void canvas_native_context_2d_path_test(int64_t context);
 
 void canvas_native_context_2d_conic_test(int64_t context);
 
+void canvas_native_context_set_render_func(int64_t value, void *data, void (*render)(const void*));
+
+void canvas_native_context_clear_render_func(int64_t value);
+
 void canvas_native_context_release(struct CanvasRenderingContext2D *value);
 
 #if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
@@ -2057,6 +2157,11 @@ const char *canvas_native_context_get_global_composition(const struct CanvasRend
 void canvas_native_context_set_global_composition(struct CanvasRenderingContext2D *context,
                                                   const char *composition);
 
+void canvas_native_context_set_global_composition_int(struct CanvasRenderingContext2D *context,
+                                                      uint32_t composition);
+
+uint32_t canvas_native_context_get_global_composition_int(const struct CanvasRenderingContext2D *context);
+
 void canvas_native_paint_style_set_fill_color_with_c_string(struct CanvasRenderingContext2D *context,
                                                             const char *color);
 
@@ -2367,7 +2472,7 @@ void canvas_native_context_draw_atlas(struct CanvasRenderingContext2D *context,
                                       uintptr_t tex_size,
                                       const char *const *colors,
                                       uintptr_t colors_size,
-                                      int32_t blend_mode);
+                                      uint32_t blend_mode);
 
 void canvas_native_context_draw_atlas_encoded(struct CanvasRenderingContext2D *context,
                                               const uint8_t *data,
@@ -2378,7 +2483,7 @@ void canvas_native_context_draw_atlas_encoded(struct CanvasRenderingContext2D *c
                                               uintptr_t tex_size,
                                               const char *const *colors,
                                               uintptr_t colors_size,
-                                              int32_t blend_mode);
+                                              uint32_t blend_mode);
 
 void canvas_native_context_draw_atlas_asset(struct CanvasRenderingContext2D *context,
                                             const struct ImageAsset *asset,
@@ -2388,7 +2493,7 @@ void canvas_native_context_draw_atlas_asset(struct CanvasRenderingContext2D *con
                                             uintptr_t tex_size,
                                             const char *const *colors,
                                             uintptr_t colors_size,
-                                            int32_t blend_mode);
+                                            uint32_t blend_mode);
 
 void canvas_native_context_ellipse(struct CanvasRenderingContext2D *context,
                                    float x,
@@ -2496,6 +2601,8 @@ void canvas_native_context_rect(struct CanvasRenderingContext2D *context,
                                 float width,
                                 float height);
 
+void canvas_native_context_reset(struct CanvasRenderingContext2D *context);
+
 void canvas_native_context_round_rect(struct CanvasRenderingContext2D *context,
                                       float x,
                                       float y,
@@ -3008,13 +3115,15 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(enum CanvasGPUErrorType, char*, void*),
                                            void *callback_data);
 
+char *canvas_native_webgpu_to_data_url_with_fallback(const struct CanvasGPUCanvasContext *context,
+                                                     const char *format,
+                                                     float quality);
+
 char *canvas_native_webgpu_to_data_url(const struct CanvasGPUCanvasContext *context,
-                                       const struct CanvasGPUDevice *device,
                                        const char *format,
                                        uint32_t quality);
 
 char *canvas_native_webgpu_to_data_url_with_texture(const struct CanvasGPUCanvasContext *context,
-                                                    const struct CanvasGPUDevice *device,
                                                     const struct CanvasGPUTexture *texture,
                                                     const char *format,
                                                     uint32_t quality);
@@ -3068,12 +3177,23 @@ void canvas_native_webgpu_context_resize_nsview(const struct CanvasGPUCanvasCont
                                                 uint32_t height);
 #endif
 
+#if (defined(TARGET_OS_MACOS) || defined(TARGET_OS_IOS))
+void canvas_native_webgpu_context_resize_layer(const struct CanvasGPUCanvasContext *context,
+                                               void *layer,
+                                               uint32_t width,
+                                               uint32_t height);
+#endif
+
 void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
                                             const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
 void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context);
 
+bool canvas_native_webgpu_context_has_current_texture(const struct CanvasGPUCanvasContext *context);
+
+bool canvas_native_webgpu_context_has_surface_presented(const struct CanvasGPUCanvasContext *context);
+
 const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
 
 void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context,
@@ -3124,7 +3244,7 @@ void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct Can
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
-                                                                uint64_t size);
+                                                                int64_t size);
 
 void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
@@ -3362,6 +3482,11 @@ void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct Canv
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
+void canvas_native_webgpu_queue_copy_gpu_context_to_texture(const struct CanvasGPUQueue *queue,
+                                                            const struct CanvasImageCopyGPUContext *source,
+                                                            const struct CanvasImageCopyTexture *destination,
+                                                            const struct CanvasExtent3d *size);
+
 void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
@@ -3375,8 +3500,15 @@ void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
-                                             uintptr_t data_offset,
-                                             intptr_t size);
+                                             uintptr_t data_offset);
+
+void canvas_native_webgpu_queue_write_buffer_size(const struct CanvasGPUQueue *queue,
+                                                  const struct CanvasGPUBuffer *buffer,
+                                                  uint64_t buffer_offset,
+                                                  const uint8_t *data,
+                                                  uintptr_t data_size,
+                                                  uintptr_t data_offset,
+                                                  uintptr_t size);
 
 void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
@@ -3889,12 +4021,20 @@ bool canvas_native_webgl_result_get_bool(const struct WebGLResult *result);
 
 struct I32Buffer *canvas_native_webgl_result_get_i32_array(const struct WebGLResult *result);
 
+struct I32Buffer *canvas_native_webgl_result_into_i32_array(struct WebGLResult *result);
+
 struct U32Buffer *canvas_native_webgl_result_get_u32_array(const struct WebGLResult *result);
 
+struct U32Buffer *canvas_native_webgl_result_into_u32_array(struct WebGLResult *result);
+
 struct F32Buffer *canvas_native_webgl_result_get_f32_array(const struct WebGLResult *result);
 
+struct F32Buffer *canvas_native_webgl_result_into_f32_array(struct WebGLResult *result);
+
 struct U8Buffer *canvas_native_webgl_result_get_bool_array(const struct WebGLResult *result);
 
+struct BoolBuffer *canvas_native_webgl_result_into_bool_array(struct WebGLResult *result);
+
 uint32_t canvas_native_webgl_result_get_u32(const struct WebGLResult *result);
 
 int32_t canvas_native_webgl_result_get_i32(const struct WebGLResult *result);
@@ -4607,6 +4747,17 @@ void canvas_native_webgl_tex_sub_image2d(uint32_t target,
                                          uintptr_t size,
                                          struct WebGLState *state);
 
+void canvas_native_webgl_tex_sub_image2d_offset(uint32_t target,
+                                                int32_t level,
+                                                int32_t xoffset,
+                                                int32_t yoffset,
+                                                int32_t width,
+                                                int32_t height,
+                                                uint32_t format,
+                                                int32_t image_type,
+                                                int64_t offset,
+                                                struct WebGLState *state);
+
 void canvas_native_webgl_uniform1f(int32_t location, float v0, struct WebGLState *state);
 
 void canvas_native_webgl_uniform1fv(int32_t location,
@@ -4832,6 +4983,30 @@ uint32_t canvas_native_webgl2_client_wait_sync(const struct WebGLSync *sync,
                                                intptr_t timeout,
                                                struct WebGLState *state);
 
+void canvas_native_webgl2_compressed_tex_image3d_none(uint32_t target,
+                                                      int32_t level,
+                                                      uint32_t internalformat,
+                                                      int32_t width,
+                                                      int32_t height,
+                                                      int32_t depth,
+                                                      int32_t border,
+                                                      int32_t image_size,
+                                                      uintptr_t offset,
+                                                      struct WebGLState *state);
+
+void canvas_native_webgl2_compressed_tex_image3d(uint32_t target,
+                                                 int32_t level,
+                                                 uint32_t internalformat,
+                                                 int32_t width,
+                                                 int32_t height,
+                                                 int32_t depth,
+                                                 int32_t border,
+                                                 const uint8_t *src,
+                                                 uintptr_t size,
+                                                 uintptr_t src_offset,
+                                                 uintptr_t src_length_override,
+                                                 struct WebGLState *state);
+
 void canvas_native_webgl2_compressed_tex_sub_image3d_none(uint32_t target,
                                                           int32_t level,
                                                           int32_t xoffset,
@@ -4842,7 +5017,7 @@ void canvas_native_webgl2_compressed_tex_sub_image3d_none(uint32_t target,
                                                           int32_t depth,
                                                           uint32_t format,
                                                           int32_t image_size,
-                                                          int32_t offset,
+                                                          uintptr_t offset,
                                                           struct WebGLState *state);
 
 void canvas_native_webgl2_compressed_tex_sub_image3d(uint32_t target,
@@ -4890,6 +5065,8 @@ void canvas_native_webgl2_delete_query_with_query(uint32_t id, struct WebGLState
 
 void canvas_native_webgl2_delete_sampler_with_sampler(uint32_t sampler, struct WebGLState *state);
 
+void canvas_native_webgl2_sync_destroy(const struct WebGLSync *sync);
+
 void canvas_native_webgl2_delete_sync_with_sync(const struct WebGLSync *sync,
                                                 struct WebGLState *state);
 
@@ -5090,6 +5267,18 @@ void canvas_native_webgl2_tex_image3d_canvas2d(uint32_t target,
                                                struct CanvasRenderingContext2D *canvas,
                                                struct WebGLState *state);
 
+void canvas_native_webgl2_tex_image3d_webgl(uint32_t target,
+                                            int32_t level,
+                                            int32_t internalformat,
+                                            int32_t _width,
+                                            int32_t _height,
+                                            int32_t depth,
+                                            int32_t border,
+                                            uint32_t format,
+                                            uint32_t type_,
+                                            struct WebGLState *webgl,
+                                            struct WebGLState *state);
+
 void canvas_native_webgl2_tex_image3d(uint32_t target,
                                       int32_t level,
                                       int32_t internalformat,
@@ -5185,6 +5374,19 @@ void canvas_native_webgl2_tex_sub_image3d_canvas2d(uint32_t target,
                                                    struct CanvasRenderingContext2D *canvas,
                                                    struct WebGLState *state);
 
+void canvas_native_webgl2_tex_sub_image3d_webgl(uint32_t target,
+                                                int32_t level,
+                                                int32_t xoffset,
+                                                int32_t yoffset,
+                                                int32_t zoffset,
+                                                int32_t _width,
+                                                int32_t _height,
+                                                int32_t depth,
+                                                uint32_t format,
+                                                uint32_t type_,
+                                                struct WebGLState *webgl,
+                                                struct WebGLState *state);
+
 void canvas_native_webgl2_tex_sub_image3d_offset(uint32_t target,
                                                  int32_t level,
                                                  int32_t xoffset,