@shopify/react-native-skia 2.6.6 → 2.6.8

package/lib/commonjs/skia/types/WebGPU.js

@@ -3,4 +3,103 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.installWebGPU = void 0;
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+const installWebGPU = exports.installWebGPU = (() => {
+  const g = typeof global !== "undefined" ? global : undefined;
+  return g && typeof g.installWebGPU === "function" ? g.installWebGPU : () => {};
+})();
+
+// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by
+// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are
+// only available on native (SK_GRAPHITE) builds, reachable through
+// `Skia.getDevice()`.
+//
+// The exported interfaces below describe the descriptors and objects those
+// entry points use; the `declare global` block augments the standard WebGPU
+// interfaces so the new methods are typed without casting to `any`.
+
+/**
+ * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
+ * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).
+ *
+ * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a
+ * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller
+ * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep
+ * it alive until the imported texture is destroyed.
+ */
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the
+ * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see
+ * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and
+ * lifetime rules).
+ */
+
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+
+/**
+ * Shared texture memory imported from a platform native buffer via
+ * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
+ * the memory, then bracket the GPU work that touches it with
+ * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.
+ */
+
+/**
+ * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
+ * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's
+ * toggle list for valid names.
+ */
 //# sourceMappingURL=WebGPU.js.map

package/lib/commonjs/skia/types/WebGPU.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":["installWebGPU","exports","g","global","undefined"],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n/**\n * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,\n * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime\n * that calls this.\n *\n * The native module installs these globals on the main JS runtime, but worklet\n * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame\n * processors) start without them, so referencing the bare global inside a\n * worklet yields `undefined`. Call `installWebGPU()` once at the top of a\n * worklet to install them there:\n *\n * ```tsx\n * import { installWebGPU } from \"@shopify/react-native-skia\";\n *\n * const work = (device: GPUDevice) => {\n *   \"worklet\";\n *   installWebGPU();\n *   device.createBuffer({\n *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,\n *   });\n * };\n * ```\n *\n * `installWebGPU` is a native host function. When captured into a worklet, the\n * Worklets serializer re-creates it on the worklet runtime, so calling it there\n * installs the constants on that runtime. The values come from the native\n * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.\n * Calling it on a runtime that already has the constants is a safe no-op, and on\n * web (where the constants are always global) it is a no-op too.\n */\nexport const installWebGPU: () => void = (() => {\n  const g =\n    typeof global !== \"undefined\"\n      ? (global as unknown as { installWebGPU?: () => void })\n      : undefined;\n  return g && typeof g.installWebGPU === \"function\"\n    ? g.installWebGPU\n    : () => {};\n})();\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,aAAyB,GAAAC,OAAA,CAAAD,aAAA,GAAG,CAAC,MAAM;EAC9C,MAAME,CAAC,GACL,OAAOC,MAAM,KAAK,WAAW,GACxBA,MAAM,GACPC,SAAS;EACf,OAAOF,CAAC,IAAI,OAAOA,CAAC,CAACF,aAAa,KAAK,UAAU,GAC7CE,CAAC,CAACF,aAAa,GACf,MAAM,CAAC,CAAC;AACd,CAAC,EAAE,CAAC;;AAEJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAyBA;AACA;AACA;AACA;AACA;AACA;;AAOA;;AAMA;AACA;AACA;AACA;;AAMA;AACA;AACA;AACA;AACA;AACA;;AAuBA;AACA;AACA;AACA;AACA","ignoreList":[]}

package/lib/module/skia/types/WebGPU.d.ts

@@ -1,4 +1,35 @@
 import type { NativeBuffer } from "./NativeBuffer";
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export declare const installWebGPU: () => void;
 /**
  * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
  * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).

package/lib/module/skia/types/WebGPU.js

@@ -1,2 +1,99 @@
-export {};
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export const installWebGPU = (() => {
+  const g = typeof global !== "undefined" ? global : undefined;
+  return g && typeof g.installWebGPU === "function" ? g.installWebGPU : () => {};
+})();
+
+// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by
+// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are
+// only available on native (SK_GRAPHITE) builds, reachable through
+// `Skia.getDevice()`.
+//
+// The exported interfaces below describe the descriptors and objects those
+// entry points use; the `declare global` block augments the standard WebGPU
+// interfaces so the new methods are typed without casting to `any`.
+
+/**
+ * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
+ * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).
+ *
+ * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a
+ * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller
+ * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep
+ * it alive until the imported texture is destroyed.
+ */
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the
+ * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see
+ * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and
+ * lifetime rules).
+ */
+
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+
+/**
+ * Shared texture memory imported from a platform native buffer via
+ * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
+ * the memory, then bracket the GPU work that touches it with
+ * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.
+ */
+
+/**
+ * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
+ * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's
+ * toggle list for valid names.
+ */
 //# sourceMappingURL=WebGPU.js.map

package/lib/module/skia/types/WebGPU.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":["installWebGPU","g","global","undefined"],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n/**\n * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,\n * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime\n * that calls this.\n *\n * The native module installs these globals on the main JS runtime, but worklet\n * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame\n * processors) start without them, so referencing the bare global inside a\n * worklet yields `undefined`. Call `installWebGPU()` once at the top of a\n * worklet to install them there:\n *\n * ```tsx\n * import { installWebGPU } from \"@shopify/react-native-skia\";\n *\n * const work = (device: GPUDevice) => {\n *   \"worklet\";\n *   installWebGPU();\n *   device.createBuffer({\n *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,\n *   });\n * };\n * ```\n *\n * `installWebGPU` is a native host function. When captured into a worklet, the\n * Worklets serializer re-creates it on the worklet runtime, so calling it there\n * installs the constants on that runtime. The values come from the native\n * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.\n * Calling it on a runtime that already has the constants is a safe no-op, and on\n * web (where the constants are always global) it is a no-op too.\n */\nexport const installWebGPU: () => void = (() => {\n  const g =\n    typeof global !== \"undefined\"\n      ? (global as unknown as { installWebGPU?: () => void })\n      : undefined;\n  return g && typeof g.installWebGPU === \"function\"\n    ? g.installWebGPU\n    : () => {};\n})();\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":"AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,aAAyB,GAAG,CAAC,MAAM;EAC9C,MAAMC,CAAC,GACL,OAAOC,MAAM,KAAK,WAAW,GACxBA,MAAM,GACPC,SAAS;EACf,OAAOF,CAAC,IAAI,OAAOA,CAAC,CAACD,aAAa,KAAK,UAAU,GAC7CC,CAAC,CAACD,aAAa,GACf,MAAM,CAAC,CAAC;AACd,CAAC,EAAE,CAAC;;AAEJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAyBA;AACA;AACA;AACA;AACA;AACA;;AAOA;;AAMA;AACA;AACA;AACA;;AAMA;AACA;AACA;AACA;AACA;AACA;;AAuBA;AACA;AACA;AACA;AACA","ignoreList":[]}

package/lib/typescript/lib/commonjs/skia/types/WebGPU.d.ts

@@ -1 +1,2 @@
 export const __esModule: boolean;
+export const installWebGPU: any;

package/lib/typescript/lib/module/mock/index.d.ts

@@ -306,6 +306,7 @@ export function Mock(CanvasKit: any): {
     isNativeBufferAddr: (buffer: any) => buffer is BigInt;
     isNativeBufferWeb: (buffer: any) => boolean;
     isNativeBufferNode: (buffer: any) => buffer is ArrayBuffer;
+    installWebGPU: any;
     LineBreakType: {};
     VerticalTextAlign: {};
     ResizePolicy: {};

package/lib/typescript/lib/module/skia/types/WebGPU.d.ts

@@ -1 +1,31 @@
-export {};
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export const installWebGPU: any;

package/lib/typescript/src/skia/types/WebGPU.d.ts

@@ -1,4 +1,35 @@
 import type { NativeBuffer } from "./NativeBuffer";
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export declare const installWebGPU: () => void;
 /**
  * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
  * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).

package/package.json

@@ -8,7 +8,7 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.6.6",
+  "version": "2.6.8",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",

package/src/skia/types/WebGPU.ts

@@ -1,5 +1,45 @@
 import type { NativeBuffer } from "./NativeBuffer";
 
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export const installWebGPU: () => void = (() => {
+  const g =
+    typeof global !== "undefined"
+      ? (global as unknown as { installWebGPU?: () => void })
+      : undefined;
+  return g && typeof g.installWebGPU === "function"
+    ? g.installWebGPU
+    : () => {};
+})();
+
 // Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by
 // @webgpu/types) with a few Skia- and Dawn-specific entry points. These are
 // only available on native (SK_GRAPHITE) builds, reachable through

package/cpp/rnwgpu/async/AsyncDispatcher.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-
-#include <jsi/jsi.h>
-
-namespace rnwgpu::async {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Abstract dispatcher used by the AsyncRunner to enqueue work back onto the
- * JavaScript thread.
- */
-class AsyncDispatcher {
-public:
-  using Work = std::function<void(jsi::Runtime &)>;
-
-  virtual ~AsyncDispatcher() = default;
-
-  /**
-   * Enqueue a unit of work that will be executed on the JavaScript thread.
-   */
-  virtual void post(Work work) = 0;
-};
-
-} // namespace rnwgpu::async