@shopify/react-native-skia 2.6.5 → 2.6.7

package/cpp/skia/src/base/SkAutoLocaleSetter.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAutoLocaleSetter_DEFINED
+#define SkAutoLocaleSetter_DEFINED
+
+#include "include/private/base/SkNoncopyable.h"
+
+#if defined(SK_BUILD_FOR_WIN)
+#include <optional>
+#include <string>
+#endif
+
+#if !defined(SK_BUILD_FOR_ANDROID)
+#include <locale.h>
+#endif
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+#include <xlocale.h>
+#include <cstring>
+#define HAVE_XLOCALE 1
+#else
+#define HAVE_XLOCALE 0
+#endif
+
+#if defined(SK_BUILD_FOR_ANDROID) || defined(__UCLIBC__) || defined(_NEWLIB_VERSION)
+#define HAVE_LOCALE_T 0
+#else
+#define HAVE_LOCALE_T 1
+#endif
+
+/**
+ * Helper class for ensuring that we don't use the wrong locale when building shaders. Android
+ * doesn't support locale in the NDK, so this is a no-op there.
+ */
+class SkAutoLocaleSetter : public SkNoncopyable {
+public:
+    SkAutoLocaleSetter (const char* name) {
+#if defined(SK_BUILD_FOR_WIN)
+        fOldPerThreadLocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
+        char* oldLocale = setlocale(LC_ALL, name);
+        if (oldLocale) {
+            fOldLocale.emplace(oldLocale);
+        }
+#elif HAVE_LOCALE_T
+#if HAVE_XLOCALE
+        // In xlocale nullptr means the C locale.
+        if (0 == strcmp(name, "C")) {
+            name = nullptr;
+        }
+#endif
+        fLocale = newlocale(LC_ALL_MASK, name, nullptr);
+        if (fLocale) {
+            fOldLocale = uselocale(fLocale);
+        } else {
+            fOldLocale = static_cast<locale_t>(nullptr);
+        }
+#else
+        (void) name; // suppress unused param warning.
+#endif
+    }
+
+    ~SkAutoLocaleSetter () {
+#if defined(SK_BUILD_FOR_WIN)
+        if (fOldLocale) {
+            setlocale(LC_ALL, fOldLocale->c_str());
+        }
+        _configthreadlocale(fOldPerThreadLocale);
+#elif HAVE_LOCALE_T
+        if (fLocale) {
+             uselocale(fOldLocale);
+             freelocale(fLocale);
+        }
+#endif
+    }
+
+private:
+#if defined(SK_BUILD_FOR_WIN)
+    int fOldPerThreadLocale;
+    std::optional<std::string> fOldLocale;
+#elif HAVE_LOCALE_T
+    locale_t fOldLocale;
+    locale_t fLocale;
+#endif
+};
+
+#undef HAVE_LOCALE_T
+#undef HAVE_XLOCALE
+
+#endif

package/cpp/skia/src/base/SkUTF.h

@@ -1,4 +1,4 @@
-// Copyright 2018 Google LLC.
+// Copyright 2018 Google LLC
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 #ifndef SkUTF_DEFINED
 #define SkUTF_DEFINED

package/lib/commonjs/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`).
@@ -24,6 +55,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * 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.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * 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}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +123,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +173,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

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 * 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   * Returns `false` if access could not be acquired.\n   */\n  beginAccess(texture: GPUTexture, initialized: boolean): boolean;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted.\n   * Returns `false` on failure.\n   */\n  endAccess(texture: GPUTexture): boolean;\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}\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`).
@@ -24,6 +55,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * 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.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * 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}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +123,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +173,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

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 * 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   * Returns `false` if access could not be acquired.\n   */\n  beginAccess(texture: GPUTexture, initialized: boolean): boolean;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted.\n   * Returns `false` on failure.\n   */\n  endAccess(texture: GPUTexture): boolean;\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}\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: {};