react-native-wgpu 0.5.13 → 0.5.15

package/README.md

@@ -1,403 +1,9 @@
-# React Native WebGPU
+# react-native-wgpu
 
-React Native implementation of WebGPU using [Dawn](https://dawn.googlesource.com/dawn).  
+This package has been renamed to [`react-native-webgpu`](https://www.npmjs.com/package/react-native-webgpu).
 
-React Native WebGPU requires React Native 0.81 or newer. It doesn't support the legacy architecture.
-
-## Installation
-
-Please note that the package name is `react-native-wgpu`.
-
-```
-npm install react-native-wgpu
-```
-
-## With Expo
-
-Expo provides a React Native WebGPU template that works with React Three Fiber.
-The works on iOS, Android, and Web.
-
-```
-npx create-expo-app@latest -e with-webgpu
-```
-
-https://github.com/user-attachments/assets/efbd05f8-4ce0-46c2-919c-03e1095bc8ac
-
-Below are some examples from the [example app](/apps/example/).
-
-https://github.com/user-attachments/assets/116a41b2-2cf8-49f1-9f16-a5c83637c198
-
-Starting from `r168`, Three.js runs out of the box with React Native WebGPU.
-You need to have a slight modification of [the metro config](/apps/example/metro.config.js) to resolve Three.js to the WebGPU build.
-We also support [react-three-fiber](/apps/example/src/ThreeJS/Fiber.tsx); to make it work, patch `node_modules/@react-three/fiber/package.json` (for instance via `patch-package`) so that it resolves to the WebGPU entry point instead of the React Native bundle:
-
-```diff
-diff --git a/node_modules/@react-three/fiber/package.json b/node_modules/@react-three/fiber/package.json
-@@
--  "react-native": "native/dist/react-three-fiber-native.cjs.js",
-+  "react-native": "dist/react-three-fiber.cjs.js",
-```
-
-For model loading, we also need [the following polyfill](/apps/example/src/App.tsx#29).
-
-https://github.com/user-attachments/assets/5b49ef63-0a3c-4679-aeb5-e4b4dddfcc1d
-
-We also provide prebuilt binaries for visionOS and macOS.
-
-https://github.com/user-attachments/assets/2d5c618e-5b15-4cef-8558-d4ddf8c70667
-
-## Usage
-
-Usage is identical to Web.
-
-```tsx
-import React from "react";
-import { StyleSheet, View, PixelRatio } from "react-native";
-import { Canvas, CanvasRef } from "react-native-wgpu";
-
-import { redFragWGSL, triangleVertWGSL } from "./triangle";
-
-export function HelloTriangle() {
-  const ref = useRef<CanvasRef>(null);
-  useEffect(() => {
-    const helloTriangle = async () => {
-      const adapter = await navigator.gpu.requestAdapter();
-      if (!adapter) {
-        throw new Error("No adapter");
-      }
-      const device = await adapter.requestDevice();
-      const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
-
-      const context = ref.current!.getContext("webgpu")!;
-      const canvas = context.canvas as HTMLCanvasElement;
-      canvas.width = canvas.clientWidth * PixelRatio.get();
-      canvas.height = canvas.clientHeight * PixelRatio.get();
-
-      if (!context) {
-        throw new Error("No context");
-      }
-
-      context.configure({
-        device,
-        format: presentationFormat,
-        alphaMode: "opaque",
-      });
-
-      const pipeline = device.createRenderPipeline({
-        layout: "auto",
-        vertex: {
-          module: device.createShaderModule({
-            code: triangleVertWGSL,
-          }),
-          entryPoint: "main",
-        },
-        fragment: {
-          module: device.createShaderModule({
-            code: redFragWGSL,
-          }),
-          entryPoint: "main",
-          targets: [
-            {
-              format: presentationFormat,
-            },
-          ],
-        },
-        primitive: {
-          topology: "triangle-list",
-        },
-      });
-
-      const commandEncoder = device.createCommandEncoder();
-
-      const textureView = context.getCurrentTexture().createView();
-
-      const renderPassDescriptor: GPURenderPassDescriptor = {
-        colorAttachments: [
-          {
-            view: textureView,
-            clearValue: [0, 0, 0, 1],
-            loadOp: "clear",
-            storeOp: "store",
-          },
-        ],
-      };
-
-      const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
-      passEncoder.setPipeline(pipeline);
-      passEncoder.draw(3);
-      passEncoder.end();
-
-      device.queue.submit([commandEncoder.finish()]);
-
-      context.present();
-    };
-    helloTriangle();
-  }, [ref]);
-
-  return (
-    <View style={style.container}>
-      <Canvas ref={ref} style={style.webgpu} />
-    </View>
-  );
-}
-
-const style = StyleSheet.create({
-  container: {
-    flex: 1,
-  },
-  webgpu: {
-    flex: 1,
-  },
-});
-```
-
-## Example App
-
-To run the example app you first need to [install Dawn](#installing-dawn).
-
-From there you will be able to run the example app properly.
-
-## Similarities and Differences with the Web
-
-The API has been designed to be completely symmetric with the Web.  
-For instance, you can access the WebGPU context synchronously, as well as the canvas size.  
-Pixel density and canvas resizing are handled exactly like on the Web as well.
-
-```tsx
-// The default canvas size is not scaled to the device pixel ratio
-// When resizing the canvas, the clientWidth and clientHeight are updated automatically
-// This behaviour is symmetric to the Web
-const ctx = canvas.current.getContext("webgpu")!;
-ctx.canvas.width = ctx.canvas.clientWidth * PixelRatio.get();
-ctx.canvas.height = ctx.canvas.clientHeight * PixelRatio.get();
-```
-
-### Frame Scheduling
-
-In React Native, we want to keep frame presentation as a manual operation as we plan to provide more advanced rendering options that are React Native specific.  
-This means that when you are ready to present a frame, you need to call `present` on the context.
-
-```tsx
-// draw
-// submit to the queue
-device.queue.submit([commandEncoder.finish()]);
-// This method is React Native only
-context.present();
-```
-
-### Canvas Transparency
-
-On Android, the `alphaMode` property is ignored when configuring the canvas.
-To have a transparent canvas by default, use the `transparent` property.
-
-```tsx
-return (
-  <View style={style.container}>
-    <Canvas ref={ref} style={style.webgpu} transparent />
-  </View>
-);
-```
-
-### External Textures
-
-This module provides a `createImageBitmap` function that you can use in `copyExternalImageToTexture`.
-
-```tsx
-const url = Image.resolveAssetSource(require("./assets/image.png")).uri;
-const response = await fetch(url);
-const imageBitmap = await createImageBitmap(await response.blob());
-
-const texture = device.createTexture({
-  size: [imageBitmap.width, imageBitmap.height, 1],
-  format: "rgba8unorm",
-  usage:
-    GPUTextureUsage.TEXTURE_BINDING |
-    GPUTextureUsage.COPY_DST |
-    GPUTextureUsage.RENDER_ATTACHMENT,
-});
-device.queue.copyExternalImageToTexture(
-  { source: imageBitmap },
-  { texture },
-  [imageBitmap.width, imageBitmap.height],
-);
-```
-
-### Shared Texture Memory
-
-React Native WebGPU exposes Dawn's `SharedTextureMemory` so you can import a native pixel surface (an `IOSurface`-backed `CVPixelBuffer` on iOS, an `AHardwareBuffer` on Android) as a sampleable `GPUTexture` without copying pixels through the CPU. This is the path you want for camera frames, video frames, or anything coming out of a hardware producer.
-
-Like `importExternalTexture` on the web, this is **enabled by default**, there is nothing to request at device creation. The only thing to check is that the device supports it before importing. It always does on iOS/macOS; it can be missing on some Android drivers and emulators.
-
-```tsx
-import type { NativeVideoFrame } from "react-native-wgpu";
-
-const adapter = await navigator.gpu.requestAdapter();
-const device = await adapter!.requestDevice();
-
-// On by default when supported; this is the only check you need.
-if (!device.features.has("rnwebgpu/native-texture" as GPUFeatureName)) {
-  return; // rare: some Android drivers/emulators can't import native surfaces
-}
-
-// `frame` here is a NativeVideoFrame whose .handle is the native surface
-// (IOSurfaceRef / AHardwareBuffer*). NativeVideoFrames are produced by helpers
-// like RNWebGPU.createVideoPlayer or RNWebGPU.createTestVideoFrame, or by
-// any third-party module that hands you a compatible native pointer.
-const memory = device.importSharedTextureMemory({
-  handle: frame.handle,
-  label: "video-frame",
-});
-const texture = memory.createTexture();
-
-memory.beginAccess(texture, /* initialized */ true);
-// ... bind `texture` into a sampler and render normally ...
-memory.endAccess(texture);
-
-texture.destroy();
-frame.release();
-```
-
-`beginAccess`/`endAccess` bracket the GPU's read window on the shared surface. Pass `initialized: true` when the producer has already written meaningful pixels (the typical video/camera case) and `false` when the next pass will fully overwrite the texture.
-
-### Importing External Textures
-
-`GPUDevice.importExternalTexture` is the higher-level path for sampling a native surface. You hand it a `NativeVideoFrame` and get back a `GPUExternalTexture` that you bind as a `texture_external` and read with `textureSampleBaseClampToEdge`. It does two things for you on top of `SharedTextureMemory`:
-
-- **Color conversion.** Camera and video surfaces are usually biplanar YUV (NV12), not RGB. An external texture carries the YUV→RGB matrix and the source/destination color-space transfer functions, so on the supported paths the sampler returns ready-to-use RGB in hardware. With raw `SharedTextureMemory` you would sample the luma/chroma planes and do that conversion by hand in WGSL. This is the main reason to prefer it for camera and video frames.
-- **Lifecycle.** It owns the `SharedTextureMemory` + `createTexture` + `beginAccess`/`endAccess` sequence internally, so you just import the frame and `destroy()` the result.
-
-It builds on the same default-on capability as Shared Texture Memory above, so feature-detect the device the same way before importing.
-
-> **Android note:** the hardware YUV→RGB conversion is fully automatic on iOS (NV12 `IOSurface`). On Android, camera frames arrive as an _opaque_ YCbCr `AHardwareBuffer`, and Dawn's Vulkan path forces an identity (`RGB_IDENTITY`) sampler conversion, so the external sample comes back as raw `[Y, Cb, Cr]`. You still get the zero-copy import and the rotation/mirror transform, but you need to apply the YUV→RGB matrix yourself in the shader. See the `CAMERA_PRELUDE` in the [VisionCamera example](/apps/example/src/VisionCamera/shaders.ts) for a ready-made BT.709 decode.
-
-```tsx
-const adapter = await navigator.gpu.requestAdapter();
-const device = await adapter!.requestDevice();
-// Feature-detect as shown above before importing on unsupported hardware.
-
-const render = () => {
-  // A GPUExternalTexture expires once the queue work that used it is submitted,
-  // so re-import one every frame.
-  const externalTexture = device.importExternalTexture({
-    source: frame, // a NativeVideoFrame
-    label: "video-frame",
-  });
-
-  const bindGroup = device.createBindGroup({
-    layout: pipeline.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: externalTexture },
-      { binding: 1, resource: sampler },
-    ],
-  });
-
-  // ... encode a pass that samples `externalTexture`, then:
-  device.queue.submit([encoder.finish()]);
-
-  // Release the surface's access window right after the submit that sampled it.
-  externalTexture.destroy();
-  context.present();
-};
-```
-
-Camera frames arrive in the sensor's native orientation, so `importExternalTexture` also accepts non-spec `rotation` (`0` | `90` | `180` | `270`, in degrees) and `mirrored` (horizontal flip) options. Dawn bakes them into the sampling transform, so the shader sees an upright frame. They map directly onto VisionCamera's `frame.orientation` / `frame.isMirrored`.
-
-#### Calling `destroy()`
-
-A `GPUExternalTexture` keeps an open access window on the underlying native surface until the wrapper is destroyed. On the Web `importExternalTexture` is core and the lifetime is handled for you; here the window is tied to the JavaScript object's lifetime. Call `externalTexture.destroy()` right after the `queue.submit()` that sampled it (never before) to release the surface back to its producer immediately. `destroy()` is idempotent, and the surface is also released when the object is garbage-collected, but relying on GC can starve a producer's buffer pool (e.g. an `AVPlayer`'s recycled `IOSurface`s) and pile up GPU resources, so prefer the explicit call in a render loop.
-
-### Reanimated Integration
-
-React Native WebGPU supports running WebGPU rendering on the UI thread using [React Native Reanimated](https://docs.swmansion.com/react-native-reanimated/) and [React Native Worklets](https://github.com/margelo/react-native-worklets).
-
-First, install the optional peer dependencies:
-
-```sh
-npm install react-native-reanimated react-native-worklets
-```
-
-WebGPU objects are automatically registered for Worklets serialization when the module loads. You can pass WebGPU objects like `GPUDevice` and `GPUCanvasContext` directly to worklets:
-
-```tsx
-import { Canvas } from "react-native-wgpu";
-import { runOnUI } from "react-native-reanimated";
-
-const renderFrame = (device: GPUDevice, context: GPUCanvasContext) => {
-  "worklet";
-  // WebGPU rendering code runs on the UI thread
-  const commandEncoder = device.createCommandEncoder();
-  // ... render ...
-  device.queue.submit([commandEncoder.finish()]);
-  context.present();
-};
-
-// Initialize WebGPU on main thread, then run on UI thread
-const device = await adapter.requestDevice();
-const context = canvasRef.current.getContext("webgpu");
-runOnUI(renderFrame)(device, context);
-```
-
-## Troubleshooting
-
-### iOS
-
-To run the React Native WebGPU project on the iOS simulator, you need to disable the Metal validation API.  
-In "Edit Scheme," uncheck "Metal Validation". Learn more [here](https://developer.apple.com/documentation/xcode/validating-your-apps-metal-api-usage/).
-
-<img width="1052" alt="Uncheck 'Metal Validation'" src="https://github.com/user-attachments/assets/2676e5cc-e351-4a97-bdc8-22cbd7df2ef2">
-
-## Library Development
-
-Make sure to check out the submodules:
-
-```
-git submodule update --init
-```
-
-Make sure you have all the tools required for building the Skia libraries (Android Studio, XCode, Ninja, CMake, Android NDK/build tools).
-
-### Installing Dawn
-
-There is an alternative way which is to install the prebuilt binaries from GitHub.
-
-```sh
-$ yarn
-$ cd packages/webgpu
-$ yarn install-dawn
-```
-
-### Building Dawn
-
-Alternatively, you can build Dawn locally.
-
-```sh
-yarn
-cd packages/webgpu
-yarn build-dawn
-```
-
-### Upgrading
-
-1. `git submodule update --remote`
-2. `yarn clean-dawn`
-3. `yarn build-dawn`
-
-### Codegen
-
-* `cd packages/webgpu && yarn codegen`
-
-### Testing
-
-In the `package` folder, to run the test against Chrome for reference:
-
-```
-yarn test:ref
-```
-
-To run the e2e test, open the example app on the e2e screen.  
-By default, it will try to connect to a localhost test server.  
-If you want to run the test suite on a physical device, you can modify the address [here](/apps/example/src/useClient.ts#L4).
+Please use `react-native-webgpu` instead.
 
 ```
-yarn test
+npm install react-native-webgpu
 ```

package/lib/commonjs/index.js

@@ -3,15 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _main = require("./main");
-Object.keys(_main).forEach(function (key) {
+var _reactNativeWebgpu = require("react-native-webgpu");
+Object.keys(_reactNativeWebgpu).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _main[key]) return;
+  if (key in exports && exports[key] === _reactNativeWebgpu[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _main[key];
+      return _reactNativeWebgpu[key];
     }
   });
 });
+if (typeof __DEV__ !== "undefined" && __DEV__) {
+  console.warn("[react-native-wgpu] This package has been renamed to 'react-native-webgpu'. " + "The 'react-native-wgpu' shim is deprecated and will be removed in a future release. " + "Please install 'react-native-webgpu' and update your imports.");
+}
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_main","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;AAYA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}
+{"version":3,"names":["_reactNativeWebgpu","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","__DEV__","console","warn"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;AAQA,IAAAA,kBAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,kBAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,kBAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,kBAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AARA,IAAI,OAAOK,OAAO,KAAK,WAAW,IAAIA,OAAO,EAAE;EAC7CC,OAAO,CAACC,IAAI,CACV,8EAA8E,GAC5E,sFAAsF,GACtF,+DACJ,CAAC;AACH","ignoreList":[]}

package/lib/module/index.js

@@ -1,5 +1,5 @@
-/// <reference types="@webgpu/types" />
-
-export * from "./main";
-export {};
+if (typeof __DEV__ !== "undefined" && __DEV__) {
+  console.warn("[react-native-wgpu] This package has been renamed to 'react-native-webgpu'. " + "The 'react-native-wgpu' shim is deprecated and will be removed in a future release. " + "Please install 'react-native-webgpu' and update your imports.");
+}
+export * from "react-native-webgpu";
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA;;AAYA,cAAc,QAAQ;AAAC","ignoreList":[]}
+{"version":3,"names":["__DEV__","console","warn"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":"AAAA,IAAI,OAAOA,OAAO,KAAK,WAAW,IAAIA,OAAO,EAAE;EAC7CC,OAAO,CAACC,IAAI,CACV,8EAA8E,GAC5E,sFAAsF,GACtF,+DACJ,CAAC;AACH;AAEA,cAAc,qBAAqB","ignoreList":[]}

package/lib/typescript/{src → webgpu/src}/Canvas.d.ts

@@ -9,6 +9,15 @@ export interface NativeCanvas {
     clientHeight: number;
 }
 export type RNCanvasContext = GPUCanvasContext & {
+    /**
+     * Present the current frame.
+     *
+     * Call this after `queue.submit()` on every runtime: the main JS runtime, the
+     * Reanimated UI runtime, and dedicated worklet runtimes (e.g.
+     * `createWorkletRuntime` / `runOnRuntime`, or a Vision Camera frame
+     * processor). It runs synchronously on the calling thread, so the frame is
+     * presented from whichever thread did the rendering.
+     */
     present: () => void;
 };
 export interface CanvasRef {

package/lib/typescript/webgpu/src/Canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Canvas.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/Canvas.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgD,MAAM,OAAO,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAU9C,KAAK,cAAc,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,UAAU,CAAC,WAAW,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI,CAAC;IAC1D,gBAAgB,EAAE,MAAM,YAAY,CAAC;CACtC;AAED,UAAU,WAAY,SAAQ,SAAS;IACrC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;CAC5B;AAED,eAAO,MAAM,MAAM,GAAI,gCAAgC,WAAW,sBAuCjE,CAAC"}

package/lib/typescript/webgpu/src/NativeWebGPUModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeWebGPUModule.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/NativeWebGPUModule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC;CACxB;;AAGD,wBAAsE"}

package/lib/typescript/webgpu/src/Offscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Offscreen.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/Offscreen.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAkB;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,OAAO,CAA4B;gBAE/B,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAMzC,UAAU,CAAC,SAAS,EAAE,QAAQ,GAAG,yBAAyB,GAAG,IAAI;IAQjE,YAAY;;;;;;CA6Bb;AAED,cAAM,yBAA0B,YAAW,gBAAgB;aAQ7B,MAAM,EAAE,GAAG;IAPvC,OAAO,EAAG,kBAAkB,CAAU;IAEtC,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,MAAM,CAA0B;gBAGZ,MAAM,EAAE,GAAG;IAGvC,gBAAgB,IAAI,yBAAyB,GAAG,IAAI;IAIpD,OAAO;IAIP,SAAS;IAOT,UAAU;IAOV,SAAS,CAAC,MAAM,EAAE,sBAAsB;IAcxC,WAAW;IAQX,iBAAiB,IAAI,UAAU;CAMhC"}

package/lib/typescript/webgpu/src/WebGPUViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGPUViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/WebGPUViewNativeComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2CAA2C,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,SAAS,EAAE,KAAK,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACtB;;AAGD,wBAAiE"}

package/lib/typescript/webgpu/src/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const GPUBufferUsage: GPUBufferUsage;
+export declare const GPUTextureUsage: GPUTextureUsage;
+export declare const GPUShaderStage: GPUShaderStage;
+export declare const GPUColorWrite: GPUColorWrite;
+export declare const GPUMapMode: GPUMapMode;
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/webgpu/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/constants.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,cAAc,gBAA4B,CAAC;AAExD,eAAO,MAAM,eAAe,iBAA6B,CAAC;AAE1D,eAAO,MAAM,cAAc,gBAA4B,CAAC;AAExD,eAAO,MAAM,aAAa,eAA2B,CAAC;AAEtD,eAAO,MAAM,UAAU,YAAwB,CAAC"}

package/lib/typescript/webgpu/src/external/ModuleProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleProxy.d.ts","sourceRoot":"","sources":["../../../../../../webgpu/src/external/ModuleProxy.ts"],"names":[],"mappings":"AACA,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,EACvC,WAAW,MAAM,UAAU,KAC1B,OAcF,CAAC;AAEF,qBAAa,mCAAoC,SAAQ,KAAK;gBAChD,IAAI,EAAE,MAAM;CAGzB"}

package/lib/typescript/webgpu/src/external/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../webgpu/src/external/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/lib/typescript/webgpu/src/external/reanimated/ReanimatedProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReanimatedProxy.d.ts","sourceRoot":"","sources":["../../../../../../../webgpu/src/external/reanimated/ReanimatedProxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAS5D,QAAA,MAAM,UAAU,oBAMd,CAAC;AAGH,eAAe,UAAU,CAAC"}

package/lib/typescript/webgpu/src/external/reanimated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../webgpu/src/external/reanimated/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/lib/typescript/webgpu/src/external/reanimated/registerWebGPUForReanimated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../../../webgpu/src/external/reanimated/registerWebGPUForReanimated.ts"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,YA2BvC,CAAC"}

package/lib/typescript/webgpu/src/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/hooks.tsx"],"names":[],"mappings":"AAAA,OAAO,KAON,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExD,eAAO,MAAM,4BAA4B,GAAI,SAAS,UAAU,SAQ/D,CAAC;AAEF,UAAU,aAAa;IACrB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CAC5B;AAED,QAAA,MAAM,aAAa,qCAA4C,CAAC;AAEhE,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;IACnC,cAAc,CAAC,EAAE,wBAAwB,CAAC;IAC1C,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;CACxC;AAED,eAAO,MAAM,iBAAiB,GAAI,iDAI/B,mBAAmB,6BAQrB,CAAC;AAEF,eAAO,MAAM,UAAU;;;CAQtB,CAAC;AAEF,eAAO,MAAM,aAAa,qBAMzB,CAAC;AAEF,eAAO,MAAM,YAAY,kCAAgC,CAAC;AAE1D,eAAO,MAAM,SAAS,GACpB,iBAAiB,wBAAwB,EACzC,mBAAmB,mBAAmB;;;CAqBvC,CAAC"}

package/lib/typescript/{src → webgpu/src}/index.d.ts

@@ -1,6 +1,8 @@
-import type { GPUDawnTogglesDescriptor, GPUSharedTextureMemory, GPUSharedTextureMemoryDescriptor, NativeCanvas, RNCanvasContext, VideoPlayer, NativeVideoFrame, NativeVideoPixelFormat } from "./types";
+import type { GPUSharedFence, GPUSharedFenceDescriptor, GPUDawnTogglesDescriptor, GPUSharedTextureMemory, GPUSharedTextureMemoryDescriptor, NativeCanvas, RNCanvasContext, VideoPlayer, NativeVideoFrame, NativeVideoPixelFormat } from "./types";
 export * from "./main";
-export type { NativeVideoFrame, VideoPlayer, NativeVideoPixelFormat, CreateVideoPlayerOptions, GPUSharedTextureMemory, GPUSharedTextureMemoryDescriptor, GPUDawnTogglesDescriptor, } from "./types";
+export * from "./constants";
+export * from "./install";
+export type { NativeVideoFrame, VideoPlayer, GPUSharedFence, GPUSharedFenceDescriptor, GPUSharedFenceExportInfo, GPUSharedFenceState, GPUSharedFenceType, GPUSharedTextureMemory, GPUSharedTextureMemoryDescriptor, GPUSharedTextureMemoryEndAccessState, NativeVideoPixelFormat, CreateVideoPlayerOptions, GPUDawnTogglesDescriptor, } from "./types";
 declare global {
     interface Navigator {
         gpu: GPU;
@@ -21,6 +23,7 @@ declare global {
     };
     interface GPUDevice {
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
     interface GPUDeviceDescriptor {
         dawnToggles?: GPUDawnTogglesDescriptor;

package/lib/typescript/webgpu/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,gCAAgC,EAChC,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AAEjB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,GAAG,EAAE,GAAG,CAAC;KACV;IAED,IAAI,SAAS,EAAE,SAAS,CAAC;IAEzB,IAAI,QAAQ,EAAE;QACZ,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,OAAO,CAAC;QAChB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAC;QACtD,uBAAuB,EAAE,CACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,eAAe,CAAC;QACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;QAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACnD,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC;QAI1E,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACxE,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,sBAAsB,KACjC,WAAW,CAAC;QACjB,kBAAkB,EAAE,MAAM,MAAM,CAAC;KAClC,CAAC;IAEF,UAAU,SAAS;QACjB,yBAAyB,CACvB,UAAU,EAAE,gCAAgC,GAC3C,sBAAsB,CAAC;QAC1B,iBAAiB,CAAC,UAAU,EAAE,wBAAwB,GAAG,cAAc,CAAC;KACzE;IAID,UAAU,mBAAmB;QAC3B,WAAW,CAAC,EAAE,wBAAwB,CAAC;KACxC;IAMD,UAAU,4BAA4B;QACpC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB;IASD,UAAU,kBAAkB;QAC1B,OAAO,IAAI,IAAI,CAAC;KACjB;IAGD,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,GACnC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}

package/lib/typescript/webgpu/src/install.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Install WebGPU on the runtime that calls it.
+ *
+ * The native module installs the WebGPU flag constants (`GPUBufferUsage`,
+ * `GPUTextureUsage`, `GPUShaderStage`, `GPUColorWrite`, `GPUMapMode`) as 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 make those globals
+ * available there, instead of importing each constant by hand:
+ *
+ * ```tsx
+ * import { installWebGPU } from "react-native-webgpu";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * The constants are captured into the worklet by closure (the same way a shader
+ * string is), so they work on every runtime. Calling it on a runtime that
+ * already has the globals (e.g. the main JS runtime) is a safe no-op.
+ *
+ * This is the explicit entry point for runtime setup; for now it only installs
+ * the flag constants, but it is the place where other per-runtime WebGPU setup
+ * (e.g. `navigator.gpu`) can be wired in later.
+ */
+export declare const installWebGPU: () => void;
+//# sourceMappingURL=install.d.ts.map

package/lib/typescript/webgpu/src/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/install.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,aAAa,YAQzB,CAAC"}

package/lib/typescript/webgpu/src/main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../webgpu/src/main/index.tsx"],"names":[],"mappings":"AAGA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,UAAU,CAAC;AAEzB,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/typescript/{src → webgpu/src}/types.d.ts

@@ -7,6 +7,15 @@ export interface NativeCanvas {
     clientHeight: number;
 }
 export type RNCanvasContext = GPUCanvasContext & {
+    /**
+     * Present the current frame.
+     *
+     * Call this after `queue.submit()` on every runtime: the main JS runtime, the
+     * Reanimated UI runtime, and dedicated worklet runtimes (e.g.
+     * `createWorkletRuntime` / `runOnRuntime`, or a Vision Camera frame
+     * processor). It runs synchronously on the calling thread, so the frame is
+     * presented from whichever thread did the rendering.
+     */
     present: () => void;
 };
 export interface CanvasRef {
@@ -35,6 +44,29 @@ export interface GPUSharedTextureMemoryDescriptor {
     handle: bigint;
     label?: string;
 }
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+export interface GPUSharedFenceDescriptor {
+    type: GPUSharedFenceType;
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    handle: bigint;
+}
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 export interface GPUDawnTogglesDescriptor {
     enabledToggles?: string[];
     disabledToggles?: string[];
@@ -43,8 +75,8 @@ export interface GPUSharedTextureMemory {
     readonly __brand: "GPUSharedTextureMemory";
     label: string;
     createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
-    endAccess(texture: GPUTexture): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 export {};
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/webgpu/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../webgpu/src/types.ts"],"names":[],"mappings":"AAAA,KAAK,cAAc,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,UAAU,CAAC,WAAW,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI,CAAC;IAC1D,gBAAgB,EAAE,MAAM,YAAY,CAAC;CACtC;AAKD,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,MAAM,CAAC;AAkBtD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;IAC7C,OAAO,IAAI,IAAI,CAAC;CACjB;AAKD,MAAM,WAAW,WAAW;IAC1B,eAAe,IAAI,gBAAgB,GAAG,IAAI,CAAC;IAC3C,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,IAAI,CAAC;IACd,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,wBAAwB;IAKvC,WAAW,CAAC,EAAE,sBAAsB,CAAC;CACtC;AAED,MAAM,WAAW,gCAAgC;IAM/C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,MAAM,MAAM,kBAAkB,GAC1B,kBAAkB,GAClB,SAAS,GACT,wBAAwB,CAAC;AAE7B,MAAM,WAAW,wBAAwB;IAGvC,IAAI,EAAE,kBAAkB,CAAC;IAGzB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,kBAAkB,CAAC;IAIzB,MAAM,EAAE,MAAM,CAAC;CAChB;AAKD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,IAAI,wBAAwB,CAAC;CACpC;AAGD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,cAAc,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAID,MAAM,WAAW,oCAAoC;IACnD,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAQD,MAAM,WAAW,wBAAwB;IACvC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAMD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,UAAU,CAAC,EAAE,oBAAoB,GAAG,UAAU,CAAC;IAM7D,WAAW,CACT,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,mBAAmB,EAAE,GAC7B,IAAI,CAAC;IAGR,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,oCAAoC,CAAC;CACtE"}

package/lib/typescript/{eslint.config.d.mts.map → webgpu-shim/eslint.config.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"eslint.config.d.mts","sourceRoot":"","sources":["../../eslint.config.mjs"],"names":[],"mappings":""}
+{"version":3,"file":"eslint.config.d.mts","sourceRoot":"","sources":["../../../eslint.config.mjs"],"names":[],"mappings":""}