react-native-skia-webgpu-video 0.0.0-stage → 0.1.0-beta.1

package/lib/typescript/src/videoCompositionPlayer.d.ts

@@ -0,0 +1,105 @@
+import type { SkImage } from "react-native-skia";
+import { type DerivedValue, type SharedValue } from "react-native-reanimated";
+import type { FrameDrawer, VideoComposition, VideoCompositionFramesExtractor } from "./types.js";
+type UseVideoCompositionPlayerOptions<T = undefined> = {
+    /**
+     * The video composition to play.
+     * if null, the composition player won't be created.
+     */
+    composition: VideoComposition | null;
+    /**
+     * The function used to draw the composition frames.
+     */
+    drawFrame: FrameDrawer<T>;
+    /**
+     * A function that is called before drawing each frame.
+     * the return value will be passed to the drawFrame function as context.
+     */
+    beforeDrawFrame?: () => T;
+    /**
+     * A function that is called after drawing each frame.
+     * the context returned by the beforeDrawFrame function will be passed to this function.
+     * This function can be used to clean up resources allocated during the drawFrame function.
+     */
+    afterDrawFrame?: (context: T) => void;
+    /**
+     * The width of rendered frames.
+     */
+    width: number;
+    /**
+     * The height of rendered frames.
+     */
+    height: number;
+    /**
+     * Whether the composition should start playing automatically.
+     */
+    autoPlay?: boolean;
+    /**
+     * Weather the composition should loop.
+     */
+    isLooping?: boolean;
+    /**
+     * Whether to keep calling `drawFrame` at every vsync while playback is
+     * paused. By default a paused player only redraws when the composition time
+     * or the decoded frames change (a seek, the frame that follows it), which
+     * saves GPU time and battery. Enable it if `drawFrame` depends on values
+     * that change while paused, an overlay being dragged for instance.
+     *
+     * Or the shared values `drawFrame` reads: a paused player then redraws only
+     * when one of them is replaced, besides the time, the frames, the size or
+     * `drawFrame` itself. An idle editor stops redrawing at every vsync.
+     * @default false
+     */
+    drawWhenPaused?: boolean | SharedValue<unknown>[];
+    /**
+     * Whether `drawFrame` can draw something different at `currentTime` than it
+     * drew at `previousTime` from the same decoded frames. By default every time
+     * change redraws, so a playing player draws at every vsync even though the
+     * video only changes at its own frame rate. A drawer whose picture depends on
+     * time only through the frames (or only at known moments, a transition say)
+     * returns false elsewhere, and the player then redraws when a new frame is
+     * decoded instead. Must be a worklet.
+     */
+    redrawOnTime?: (previousTime: number, currentTime: number) => boolean;
+    /**
+     * Import a newly decoded frame in one vsync and draw it in the next, instead
+     * of both in the same one. On Android the import (YUV blit and its checked
+     * GPU wait) and the draw (snapshot and its checked GPU wait) cost about as
+     * much as each other, and together they overrun a 90–120 Hz frame budget on
+     * the UI thread. The picture then trails the clock by one vsync.
+     * The first frame of a session is still drawn as soon as it is imported.
+     * @default false
+     */
+    splitImportAndDraw?: boolean;
+    /**
+     * Callback that is called when the composition is ready to play.
+     */
+    onReadyToPlay?: () => void;
+    /**
+     * Callback that is called when the composition playback completes.
+     */
+    onComplete?: () => void;
+    /**
+     * Callback that is called when an error occurs.
+     * @param error the error that occurred.
+     * @param retry a function that can be called to retry the operation.
+     */
+    onError?: (error: any, retry: () => void) => void;
+};
+type VideoCompositionPlayerController = Pick<VideoCompositionFramesExtractor, "currentTime" | "play" | "pause" | "seekTo" | "isPlaying">;
+type UseVideoCompositionPlayerReturnType = {
+    /**
+     * The current drawn frame of the video composition.
+     */
+    currentFrame: DerivedValue<SkImage | null>;
+    /**
+     * The video player controller.
+     */
+    player: VideoCompositionPlayerController | null;
+};
+/**
+ * A hook that creates a video composition player.
+ */
+export declare const useVideoComposition: <T = undefined>({ composition, drawFrame, beforeDrawFrame, afterDrawFrame, width, height, autoPlay, isLooping, drawWhenPaused, redrawOnTime, splitImportAndDraw, onReadyToPlay, onComplete, onError, }: UseVideoCompositionPlayerOptions<T>) => UseVideoCompositionPlayerReturnType;
+export {};
+//# sourceMappingURL=videoCompositionPlayer.d.ts.map

package/lib/typescript/src/videoCompositionPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"videoCompositionPlayer.d.ts","sourceRoot":"","sources":["../../../src/videoCompositionPlayer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAY,OAAO,EAAa,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EACV,WAAW,EAEX,gBAAgB,EAChB,+BAA+B,EAChC,MAAM,YAAS,CAAC;AASjB,KAAK,gCAAgC,CAAC,CAAC,GAAG,SAAS,IAAI;IACrD;;;OAGG;IACH,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACrC;;OAEG;IACH,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC1B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;IACtC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAClD;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACtE;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CACnD,CAAC;AAEF,KAAK,gCAAgC,GAAG,IAAI,CAC1C,+BAA+B,EAC/B,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,CAC1D,CAAC;AAEF,KAAK,mCAAmC,GAAG;IACzC;;OAEG;IACH,YAAY,EAAE,YAAY,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAC3C;;OAEG;IACH,MAAM,EAAE,gCAAgC,GAAG,IAAI,CAAC;CACjD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,GAAG,SAAS,EAAE,wLAehD,gCAAgC,CAAC,CAAC,CAAC,KAAG,mCAsaxC,CAAC"}

package/lib/typescript/src/videoFrameImage.d.ts

@@ -0,0 +1,60 @@
+import type { SkCanvas, SkImage, SkPaint, SkRect } from "react-native-skia";
+import type { VideoFrame } from "./types.js";
+/**
+ * A frame as a Skia image, with what it takes to show its picture: the part of
+ * the image that is the picture, and the rotation that shows it upright.
+ */
+export type VideoFrameImage = {
+    /** The frame's whole texture. */
+    image: SkImage;
+    /**
+     * The picture, in the image's pixels: all of the image, except for the
+     * decoder's buffers that Android hands over with `textureMode: 'direct'`.
+     */
+    rect: SkRect;
+    /** Clockwise, in degrees (0, 90, 180 or 270), to show the picture upright. */
+    rotation: number;
+    /** The width of the upright picture. */
+    width: number;
+    /** The height of the upright picture. */
+    height: number;
+};
+/**
+ * How the picture fills the destination of {@link drawVideoFrame}.
+ *
+ * - `fill`: all of it, stretched to the destination.
+ * - `cover`: the middle of it with the destination's aspect, all of the
+ *   destination.
+ * - `contain`: all of it with its own aspect, in the middle of the destination.
+ */
+export type VideoFrameFit = "fill" | "cover" | "contain";
+/**
+ * Wraps a frame's texture in a Skia image, and says which part of it to draw
+ * and how to turn it. Works with every frame, whatever the platform and the
+ * texture mode: iOS frames and Android `direct` frames come as decoded, with
+ * a rotation, and Android `direct` frames are larger than their picture.
+ *
+ * @param frame the frame, drawn in the tick it was handed out in
+ * @param output an image returned for a previous frame, recycled rather than
+ * allocating a new wrapper. Accepted for compatibility; owned snapshots are used in v3
+ * @returns the image and its picture, or null when the frame has no texture
+ */
+export declare const makeVideoFrameImage: (frame: VideoFrame, _output?: SkImage | null) => VideoFrameImage | null;
+/**
+ * Draws a frame's picture, upright, into a rectangle of the canvas.
+ *
+ * @param canvas the canvas to draw on
+ * @param frame the frame, drawn in the tick it was handed out in
+ * @param dst where to draw the picture
+ * @param options.paint the paint to draw with, for an opacity say
+ * @param options.fit how the picture fills `dst`, `fill` by default
+ * @param options.output an image returned by a previous call, recycled
+ * @returns the image drawn, to pass back as `output` next time, or null when
+ * the frame has no texture
+ */
+export declare const drawVideoFrame: (canvas: SkCanvas, frame: VideoFrame, dst: SkRect, options?: {
+    paint?: SkPaint;
+    fit?: VideoFrameFit;
+    output?: SkImage | null;
+}) => SkImage | null;
+//# sourceMappingURL=videoFrameImage.d.ts.map

package/lib/typescript/src/videoFrameImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"videoFrameImage.d.ts","sourceRoot":"","sources":["../../../src/videoFrameImage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAS,CAAC;AAG1C;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,UAAU,EACjB,UAAU,OAAO,GAAG,IAAI,KACvB,eAAe,GAAG,IAqBpB,CAAC;AAgDF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,QAAQ,EAChB,OAAO,UAAU,EACjB,KAAK,MAAM,EACX,UAAU;IACR,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACzB,KACA,OAAO,GAAG,IAiEZ,CAAC"}

package/lib/typescript/src/videoPlayer.d.ts

@@ -0,0 +1,99 @@
+import { type SharedValue } from "react-native-reanimated";
+import type { BufferingRange, VideoDimensions, VideoFrame, VideoPlayer, VideoTextureMode } from "./types.js";
+type UseVideoPlayerOptions = {
+    /**
+     * The URI of the video to play.
+     * if null, the video player won't be created.
+     */
+    uri: string | null;
+    /**
+     * If provided, the resolution to scale the video to.
+     * If not provided, the original resolution of the video will be used.
+     * Downscaling the video can improve performance.
+     * Changing the resolution after the video player will lead to re-creating the video player.
+     */
+    resolution?: {
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * How the decoded frames reach Skia on iOS, see `VideoTextureMode`.
+     * Changing it re-creates the video player. Ignored on Android.
+     * @default 'copy'
+     */
+    textureMode?: VideoTextureMode;
+    /**
+     * Whether the video should start playing automatically.
+     */
+    autoPlay?: boolean;
+    /**
+     * Weather the video should loop.
+     */
+    isLooping?: boolean;
+    /**
+     * The volume of the video.
+     */
+    volume?: number;
+    /**
+     * The playback speed of the video.
+     * The value should be greater than 0. 1.0 is normal speed, 2.0 is double speed, 0.5 is half speed.
+     */
+    playbackSpeed?: number;
+    /**
+     * Callback that is called when the video is ready to play.
+     * @param dimensions The dimensions of the video.
+     */
+    onReadyToPlay?: (dimensions: VideoDimensions) => void;
+    /**
+     * Callback that is called when the video starts buffering.
+     */
+    onBufferingStart?: () => void;
+    /**
+     * Callback that is called when the video stops buffering.
+     */
+    onBufferingEnd?: () => void;
+    /**
+     * Callback that is called when the buffered ranges are updated.
+     * @param loadedRanges The buffered ranges.
+     */
+    onBufferingUpdate?: (loadedRanges: BufferingRange[]) => void;
+    /**
+     * Callback that is called when the video playback completes.
+     */
+    onComplete?: () => void;
+    /**
+     * Callback that is called when an error occurs.
+     * @param error the error that occurred.
+     * @param retry a function that can be called to retry the operation.
+     */
+    onError?: (error: any, retry: () => void) => void;
+    /**
+     * Callback that is called when the playing status changes.
+     * @param playing Whether the video is playing.
+     */
+    onPlayingStatusChange?: (playing: boolean) => void;
+    /**
+     * Callback that is called when a seek operation completes.
+     * @returns
+     */
+    onSeekComplete?: () => void;
+};
+type VideoPlayerController = Pick<VideoPlayer, "currentTime" | "duration" | "play" | "pause" | "seekTo" | "isPlaying">;
+type UseVideoPlayerReturnType = {
+    /**
+     * The current frame of the playing video.
+     */
+    currentFrame: SharedValue<VideoFrame | null>;
+    /**
+     * The video player controller.
+     */
+    player: VideoPlayerController | null;
+};
+/**
+ * Hook that creates a video player and manages its state.
+ * @param options The options for the video player.
+ * @returns
+ */
+export declare const useVideoPlayback: ({ uri, resolution, textureMode, autoPlay, isLooping, volume, playbackSpeed, onReadyToPlay, onBufferingStart, onBufferingEnd, onBufferingUpdate, onComplete, onError, onPlayingStatusChange, onSeekComplete, }: UseVideoPlayerOptions) => UseVideoPlayerReturnType;
+export {};
+//# sourceMappingURL=videoPlayer.d.ts.map

package/lib/typescript/src/videoPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"videoPlayer.d.ts","sourceRoot":"","sources":["../../../src/videoPlayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,UAAU,EACV,WAAW,EACX,gBAAgB,EACjB,MAAM,YAAS,CAAC;AAOjB,KAAK,qBAAqB,GAAG;IAC3B;;;OAGG;IACH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB;;;;;OAKG;IACH,UAAU,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACtD;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;IACtD;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,CAAC,YAAY,EAAE,cAAc,EAAE,KAAK,IAAI,CAAC;IAC7D;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAClD;;;OAGG;IACH,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACnD;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B,CAAC;AAEF,KAAK,qBAAqB,GAAG,IAAI,CAC/B,WAAW,EACX,aAAa,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,CACvE,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B;;OAEG;IACH,YAAY,EAAE,WAAW,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAC7C;;OAEG;IACH,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,+MAgB9B,qBAAqB,KAAG,wBAwL1B,CAAC"}

package/lib/typescript/src/yuvBlit.d.ts

@@ -0,0 +1,50 @@
+import type { GPUNativeBufferExternalTexture, NativeVideoFrame } from "react-native-webgpu";
+/** One Android decoder buffer, imported once as an external texture. An
+ * ImageReader cycles through a few buffers: each one is imported the first
+ * time it shows up, then only its access is opened and closed per frame. */
+export type YuvImport = {
+    handle: bigint;
+    rotation: number;
+    /** The import's own reference on the buffer, released with it. */
+    source: NativeVideoFrame;
+    wrapper: GPUNativeBufferExternalTexture;
+    uniforms: GPUBuffer;
+    bindGroup: GPUBindGroup;
+    /** uv scale and offset last written to `uniforms`. */
+    mapping: number[];
+};
+/** The corner of a decoder buffer's crop rectangle once the buffer is turned
+ * clockwise for display: the blit takes its source origin in that turned
+ * space. Throws unless the rectangle lies in the buffer and turns into the
+ * frame's display size. */
+export declare const yuvFrameOrigin: (region: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, rotation: number, buffer: {
+    width: number;
+    height: number;
+}, frame: {
+    width: number;
+    height: number;
+}) => {
+    x: number;
+    y: number;
+};
+/** Call only once the GPU work sampling the buffer has completed. */
+export declare const releaseYuvImport: (entry: YuvImport) => void;
+/** Releases a producer's imports, or every producer's. Call only once the GPU
+ * work sampling them has completed (a checked flush). */
+export declare const releaseYuvImports: (imports: Map<number, YuvImport[]>, producer?: number) => void;
+/**
+ * Draws the upright `width`×`height` region at `origin` of a decoder buffer
+ * into `target`, converting YUV to RGB; the buffer is imported on its first
+ * frame. Submits the draw: the caller waits for it before releasing the
+ * frame's lease or `source`, as after copyExternalImageToTexture.
+ */
+export declare const blitYuvFrame: (device: GPUDevice, imports: Map<number, YuvImport[]>, producer: number, source: NativeVideoFrame, rotation: number, origin: {
+    x: number;
+    y: number;
+}, width: number, height: number, target: GPUTexture) => void;
+//# sourceMappingURL=yuvBlit.d.ts.map

package/lib/typescript/src/yuvBlit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yuvBlit.d.ts","sourceRoot":"","sources":["../../../src/yuvBlit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,8BAA8B,EAC9B,gBAAgB,EACjB,MAAM,qBAAqB,CAAC;AAO7B;;4EAE4E;AAC5E,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,8BAA8B,CAAC;IACxC,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,EAAE,YAAY,CAAC;IACxB,sDAAsD;IACtD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4CF;;;2BAG2B;AAC3B,eAAO,MAAM,cAAc,GACzB,QAAQ;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC/D,UAAU,MAAM,EAChB,QAAQ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,OAAO;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KACvC;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAyBxB,CAAC;AAyEF,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,IAKnD,CAAC;AAEF;yDACyD;AACzD,eAAO,MAAM,iBAAiB,GAC5B,SAAS,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EACjC,WAAW,MAAM,KAChB,IAUF,CAAC;AAoDF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,SAAS,EACjB,SAAS,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EACjC,UAAU,MAAM,EAChB,QAAQ,gBAAgB,EACxB,UAAU,MAAM,EAChB,QAAQ;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAChC,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,QAAQ,UAAU,KACjB,IAgEF,CAAC"}

package/package.json

@@ -1,6 +1,157 @@
 {
   "name": "react-native-skia-webgpu-video",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.1",
+  "description": "Bounded video composition, playback and export for React Native Skia 3 / Graphite",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/typescript/src/index.d.ts",
+      "react-native": "./src/index.tsx",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json",
+    "./gpu": {
+      "types": "./lib/typescript/src/gpu.d.ts",
+      "react-native": "./src/gpu.ts",
+      "default": "./lib/module/gpu.js"
+    },
+    "./apply-skia-canvas-patch": "./scripts/apply-skia-canvas-patch.mjs"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!android/src/test",
+    "!android/tests",
+    "!android/scripts",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*",
+    "scripts/apply-skia-canvas-patch.mjs",
+    "scripts/skia-canvas-patch.json",
+    "patches/react-native-skia+3.7.0.patch",
+    "docs/UPSTREAM_NOTES.md",
+    "!ios/tests",
+    "!android/src/androidTest",
+    "!cpp/tests",
+    "docs",
+    "examples"
+  ],
+  "scripts": {
+    "test": "jest --runInBand",
+    "typecheck": "tsc --noEmit",
+    "build": "bob build",
+    "check-package": "publint --strict --pack npm",
+    "test:native": "node scripts/test-native.mjs",
+    "prebuild": "node scripts/apply-skia-canvas-patch.mjs",
+    "benchmark:test": "node --test test/comparison/*.test.mjs",
+    "benchmark:compare": "node scripts/benchmark-compare.mjs",
+    "benchmark:inventory": "node scripts/benchmark-inventory.mjs",
+    "benchmark:fixtures": "node scripts/benchmark-fixture-manifest.mjs",
+    "test:package": "node --test test/package/*.test.mjs",
+    "release": "node scripts/release.mjs"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "skia",
+    "video",
+    "react-native-skia",
+    "video-composition"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/batical/react-native-skia-webgpu-video.git"
+  },
+  "author": "Sebastien Hecart (https://github.com/batical)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/batical/react-native-skia-webgpu-video/issues"
+  },
+  "homepage": "https://github.com/batical/react-native-skia-webgpu-video#readme",
+  "devDependencies": {
+    "@babel/core": "^7.29.7",
+    "@react-native-community/cli": "^20.2.0",
+    "@react-native-community/cli-platform-ios": "^20.2.0",
+    "@react-native/babel-preset": "0.86.2",
+    "@react-native/jest-preset": "0.86.2",
+    "@react-native/metro-config": "^0.86.2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.19.11",
+    "@types/react": "^19.2.18",
+    "@types/react-test-renderer": "^19",
+    "jest": "^29.7.0",
+    "prettier": "^3.9.6",
+    "publint": "^0.3.22",
+    "react": "19.2.3",
+    "react-native": "0.86.2",
+    "react-native-builder-bob": "^0.43.0",
+    "react-native-reanimated": "4.5.3",
+    "react-native-skia": "3.7.0",
+    "react-native-webgpu": "0.17.0",
+    "react-native-worklets": "0.11.3",
+    "react-test-renderer": "19.2.3",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-native": ">=0.83 <0.87",
+    "react-native-reanimated": "4.5.3",
+    "react-native-skia": "3.7.0",
+    "react-native-webgpu": "0.17.0",
+    "react-native-worklets": "0.11.3"
+  },
+  "jest": {
+    "preset": "@react-native/jest-preset",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/lib/",
+      "<rootDir>/benchmark/"
+    ]
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "RNReactNativeSkiaVideoSpec",
+    "type": "modules",
+    "jsSrcsDir": "src"
+  },
+  "react-native": "./src/index.tsx",
+  "bin": {
+    "skia-video-patch-canvas": "scripts/apply-skia-canvas-patch.mjs"
+  },
+  "dependencies": {
+    "@webgpu/types": "^0.1.65"
+  },
+  "type": "commonjs",
+  "contributors": [
+    "Azzapp <contact@azzapp.com> (https://www.azzapp.com)"
+  ]
+}