@fishjam-cloud/react-native-custom-video-source 0.29.0

package/dist/typescript/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Publish your own video frames to Fishjam.
+ *
+ * Source-lifecycle hooks that create a custom video track, publish it, and clean it up — you
+ * supply the frames from any source. Two modes, picked by how you produce frames:
+ *
+ * - {@link useManagedForwardTrack} — you already have finished native buffers (a camera, a native
+ *   ML pipeline, a compositor); forward each buffer pointer with `forwardFrame` from
+ *   `@fishjam-cloud/react-native-webrtc`.
+ * - {@link useManagedPooledTrack} — you render the frames yourself; allocate a surface pool, draw
+ *   into it, and hand each frame back with `pushFrame`. The `@fishjam-cloud/react-native-custom-video-source/webgpu`
+ *   entry point provides a WebGPU camera-rendering toolkit for this mode.
+ *
+ * For a ready-made VisionCamera integration on top of this, use
+ * `@fishjam-cloud/react-native-vision-camera-source`.
+ *
+ * @packageDocumentation
+ */
+export { type ManagedForwardTrack, useManagedForwardTrack } from './internal/useManagedForwardTrack';
+export { type ManagedPooledTrack, useManagedPooledTrack, type WorkletBufferDescriptor, } from './internal/useManagedPooledTrack';
+//# sourceMappingURL=index.d.ts.map

package/dist/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AACrG,OAAO,EACL,KAAK,kBAAkB,EACvB,qBAAqB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,kCAAkC,CAAC"}

package/dist/typescript/internal/stopStreamTracks.d.ts

@@ -0,0 +1,4 @@
+import type { MediaStream } from '@fishjam-cloud/react-native-webrtc';
+/** Stops every track of `stream`, downgrading failures to a warning tagged with `ownerLabel`. */
+export declare function stopStreamTracks(stream: MediaStream, ownerLabel: string): void;
+//# sourceMappingURL=stopStreamTracks.d.ts.map

package/dist/typescript/internal/stopStreamTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopStreamTracks.d.ts","sourceRoot":"","sources":["../../../src/internal/stopStreamTracks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEtE,iGAAiG;AACjG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAM9E"}

package/dist/typescript/internal/toError.d.ts

@@ -0,0 +1,3 @@
+/** Coerce an unknown thrown value into an Error, leaving real Errors untouched. */
+export declare function toError(cause: unknown): Error;
+//# sourceMappingURL=toError.d.ts.map

package/dist/typescript/internal/toError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toError.d.ts","sourceRoot":"","sources":["../../../src/internal/toError.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C"}

package/dist/typescript/internal/useManagedForwardTrack.d.ts

@@ -0,0 +1,17 @@
+import { type ForwardTrack, type MediaStream } from '@fishjam-cloud/react-native-webrtc';
+/**
+ * State of a forwarding custom video track managed by {@link useManagedForwardTrack}.
+ * While the track is being created (or after an error) `track` and `stream` are `null`.
+ */
+export interface ManagedForwardTrack {
+    track: ForwardTrack | null;
+    stream: MediaStream | null;
+    error: Error | null;
+}
+/**
+ * Owns the async lifecycle of a forwarding custom video track: creates it while `enabled`,
+ * exposes the handle + stream once ready, and stops the tracks on disable/unmount (also when
+ * creation resolves after the owner already unmounted).
+ */
+export declare function useManagedForwardTrack(enabled: boolean): ManagedForwardTrack;
+//# sourceMappingURL=useManagedForwardTrack.d.ts.map

package/dist/typescript/internal/useManagedForwardTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useManagedForwardTrack.d.ts","sourceRoot":"","sources":["../../../src/internal/useManagedForwardTrack.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,oCAAoC,CAAC;AAM5C;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAuC5E"}

package/dist/typescript/internal/useManagedPooledTrack.d.ts

@@ -0,0 +1,26 @@
+import { type MediaStream, type PooledTrack } from '@fishjam-cloud/react-native-webrtc';
+/** One pooled output surface as plain values the frame worklet can capture and import itself. */
+export interface WorkletBufferDescriptor {
+    index: number;
+    surfaceHandle: bigint;
+    width: number;
+    height: number;
+}
+/**
+ * State of a pooled custom video track managed by {@link useManagedPooledTrack}.
+ * While the pool and track are being created (or after an error) all fields are `null`.
+ */
+export interface ManagedPooledTrack {
+    track: PooledTrack | null;
+    stream: MediaStream | null;
+    /** Plain per-surface descriptors (the pool object itself is not worklet-serializable). */
+    bufferDescriptors: WorkletBufferDescriptor[] | null;
+    error: Error | null;
+}
+/**
+ * Owns the async lifecycle of a surface pool + pooled custom video track: allocates both while
+ * `enabled` (re-allocates when the dimensions change), exposes worklet-ready descriptors, and
+ * tears down in the correct order (stop tracks, then dispose the pool) on disable/unmount.
+ */
+export declare function useManagedPooledTrack(enabled: boolean, width: number, height: number, poolSize: number): ManagedPooledTrack;
+//# sourceMappingURL=useManagedPooledTrack.d.ts.map

package/dist/typescript/internal/useManagedPooledTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useManagedPooledTrack.d.ts","sourceRoot":"","sources":["../../../src/internal/useManagedPooledTrack.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,oCAAoC,CAAC;AAM5C,iGAAiG;AACjG,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,0FAA0F;IAC1F,iBAAiB,EAAE,uBAAuB,EAAE,GAAG,IAAI,CAAC;IACpD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAwCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,kBAAkB,CA8CpB"}

package/dist/typescript/webgpu/cameraPassthroughPipeline.d.ts

@@ -0,0 +1,46 @@
+import { type CameraShaderBindings } from './cameraShaderBindings';
+import { type FrameCrop } from './cropUtilities';
+/** Options for {@link createCameraPassthroughPipeline}. */
+export interface CameraPassthroughPipelineOptions {
+    /** Render-target format. Defaults to {@link getOutputSurfaceFormat} (the Fishjam output surface). */
+    outputFormat?: GPUTextureFormat;
+    /** Mirror the camera horizontally (the usual selfie self-view convention). Defaults to `false`. */
+    mirror?: boolean;
+}
+/**
+ * A ready-made full-screen camera→target render pipeline. Build once at setup with
+ * {@link createCameraPassthroughPipeline}; every field is safe to capture into the frame worklet.
+ *
+ * @group WebGPU
+ */
+export interface CameraPassthroughPipeline {
+    readonly pipeline: GPURenderPipeline;
+    /** The camera shader bindings the pipeline samples through. */
+    readonly cameraShaderBindings: CameraShaderBindings;
+    /** Uniform buffer holding the packed FrameCropParams; written by {@link encodeCameraPassthrough}. */
+    readonly cropParamsBuffer: GPUBuffer;
+    /** Static bind group with the crop uniform. */
+    readonly cropBindGroup: GPUBindGroup;
+}
+/**
+ * Builds the full-screen camera passthrough pipeline: crop/orientation via {@link FrameCrop},
+ * platform-correct camera sampling, one triangle. Use it to publish the camera through the WebGPU
+ * tier with zero WGSL of your own, or as the base pass under your overlay passes.
+ *
+ * @group WebGPU
+ */
+export declare function createCameraPassthroughPipeline(device: GPUDevice, options?: CameraPassthroughPipelineOptions): CameraPassthroughPipeline;
+/**
+ * Encodes one full-screen pass drawing the camera into `outputView`, cropped per `crop`.
+ * Worklet-safe; call it inside your render callback, and encode any overlay passes after it on
+ * the same command encoder (with `loadOp: 'load'` so they draw on top).
+ *
+ * At most one call per pipeline instance per frame: the crop lives in a single uniform buffer
+ * written via `queue.writeBuffer`, which lands before the submitted command buffer executes — a
+ * second call in the same frame makes both draws use the second crop. Encode to multiple targets
+ * with different crops by building one pipeline per target.
+ *
+ * @group WebGPU
+ */
+export declare function encodeCameraPassthrough(device: GPUDevice, passthrough: CameraPassthroughPipeline, cameraTexture: GPUExternalTexture, outputView: GPUTextureView, commandEncoder: GPUCommandEncoder, crop: FrameCrop): void;
+//# sourceMappingURL=cameraPassthroughPipeline.d.ts.map

package/dist/typescript/webgpu/cameraPassthroughPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraPassthroughPipeline.d.ts","sourceRoot":"","sources":["../../../src/webgpu/cameraPassthroughPipeline.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,KAAK,SAAS,EAAwC,MAAM,iBAAiB,CAAC;AAoDvF,2DAA2D;AAC3D,MAAM,WAAW,gCAAgC;IAC/C,qGAAqG;IACrG,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,mGAAmG;IACnG,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAC;IACpD,qGAAqG;IACrG,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAC;CACtC;AAeD;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,gCAAqC,GAC7C,yBAAyB,CAsC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,yBAAyB,EACtC,aAAa,EAAE,kBAAkB,EACjC,UAAU,EAAE,cAAc,EAC1B,cAAc,EAAE,iBAAiB,EACjC,IAAI,EAAE,SAAS,GACd,IAAI,CAYN"}

package/dist/typescript/webgpu/cameraShaderBindings.d.ts

@@ -0,0 +1,69 @@
+import { type TgpuFn } from 'typegpu';
+import * as d from 'typegpu/data';
+/**
+ * Samples the live camera and returns upright RGB on both platforms (the Android in-shader BT.709
+ * YUV decode is included automatically). A TypeGPU function you can call from your own TGSL
+ * fragment shaders. It reads the camera texture + sampler declared by
+ * {@link CameraShaderBindings.bindingDeclarations}, which you must prepend to the resolved shader.
+ *
+ * @group WebGPU
+ */
+export declare const sampleCamera: TgpuFn<(uv: d.Vec2f) => d.Vec4f>;
+/** Options for {@link createCameraShaderBindings}. */
+export interface CreateCameraShaderBindingsOptions {
+    /** Bind group index the camera texture + sampler are declared at. Defaults to `0`. */
+    bindGroupIndex?: number;
+}
+/**
+ * Everything a fragment shader needs to sample the live camera. Build once at setup with
+ * {@link createCameraShaderBindings}; the fields are safe to capture into the frame worklet.
+ *
+ * @group WebGPU
+ */
+export interface CameraShaderBindings {
+    /**
+     * The camera sampler as a TypeGPU function — call `sampleCamera(uv)` from your TGSL fragment
+     * shader. Same value as the exported {@link sampleCamera}.
+     */
+    readonly sampleCamera: typeof sampleCamera;
+    /**
+     * WGSL declaring the camera `texture_external` and `sampler` at {@link bindGroupIndex}. TypeGPU
+     * cannot emit an external-texture binding, so prepend this to the WGSL your shader resolves to.
+     */
+    readonly bindingDeclarations: string;
+    /** Layout of the camera bind group; place it at {@link bindGroupIndex} in your pipeline layout. */
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    /** The linear-filtering sampler bound at binding 1. */
+    readonly sampler: GPUSampler;
+    /** The group index the bindings are declared at. */
+    readonly bindGroupIndex: number;
+}
+/**
+ * Builds the camera-sampling bindings against the device your pipelines use. Pass the result to
+ * the source hook's `cameraShaderBindings` option and the render context delivers a ready-made
+ * `cameraBindGroup` every frame — set it at {@link CameraShaderBindings.bindGroupIndex} and call
+ * `sampleCamera(uv)` in your fragment shader.
+ *
+ * ```ts
+ * const cam = createCameraShaderBindings(device);
+ * const fragment = tgpu.fragmentFn({ in: { uv: d.location(0, d.vec2f) }, out: d.vec4f })((input) => {
+ *   return cam.sampleCamera(input.uv);
+ * });
+ * const wgsl = cam.bindingDeclarations + tgpu.resolve({ externals: { fragment } });
+ * ```
+ *
+ * @group WebGPU
+ */
+export declare function createCameraShaderBindings(device: GPUDevice, options?: CreateCameraShaderBindingsOptions): CameraShaderBindings;
+/**
+ * Builds the per-frame bind group for the live camera texture. The source hook already does this
+ * for you when you pass `cameraShaderBindings` in its options (see the render context's
+ * `cameraBindGroup`); call it yourself only for advanced multi-layout setups. Worklet-safe.
+ *
+ * A camera texture expires when the frame ends, so a bind group referencing it must be rebuilt
+ * every frame — never cache the result.
+ *
+ * @group WebGPU
+ */
+export declare function createCameraBindGroup(device: GPUDevice, cameraShaderBindings: CameraShaderBindings, cameraTexture: GPUExternalTexture): GPUBindGroup;
+//# sourceMappingURL=cameraShaderBindings.d.ts.map

package/dist/typescript/webgpu/cameraShaderBindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraShaderBindings.d.ts","sourceRoot":"","sources":["../../../src/webgpu/cameraShaderBindings.ts"],"names":[],"mappings":"AAEA,OAAa,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AA8BlC;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK,CAKlC,CAAC;AAEzB,sDAAsD;AACtD,MAAM,WAAW,iCAAiC;IAChD,sFAAsF;IACtF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,YAAY,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,mGAAmG;IACnG,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC;IAC7C,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAQD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,iCAAsC,GAC9C,oBAAoB,CAiBtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,EACjB,oBAAoB,EAAE,oBAAoB,EAC1C,aAAa,EAAE,kBAAkB,GAChC,YAAY,CAUd"}

package/dist/typescript/webgpu/cameraTextureResolver.d.ts

@@ -0,0 +1,39 @@
+import { createCameraPassthroughPipeline } from './cameraPassthroughPipeline';
+/**
+ * An owned `rgba8unorm` texture the camera frame is resolved into each frame — for pipelines that
+ * want a plain `texture_2d` camera instead of `texture_external`. Build once at setup with
+ * {@link createCameraTextureResolver}; every field is safe to capture into the frame worklet.
+ *
+ * Prefer sampling the camera directly via {@link createCameraShaderBindings} when you can: the
+ * resolver costs one extra render pass per frame.
+ *
+ * @group WebGPU
+ */
+export interface CameraTextureResolver {
+    /** The resolved camera texture (`rgba8unorm`, sampled + render-attachment usage). */
+    readonly texture: GPUTexture;
+    /** A reusable default view of {@link texture}. */
+    readonly view: GPUTextureView;
+    readonly width: number;
+    readonly height: number;
+    /** @internal The pass used to resolve into {@link texture}. */
+    readonly resolvePass: ReturnType<typeof createCameraPassthroughPipeline>;
+}
+/**
+ * Creates a {@link CameraTextureResolver} with an owned `rgba8unorm` texture of the given size.
+ *
+ * @group WebGPU
+ */
+export declare function createCameraTextureResolver(device: GPUDevice, size: {
+    width: number;
+    height: number;
+}): CameraTextureResolver;
+/**
+ * Encodes one pass resolving the live camera texture into `resolver.texture`, aspect-filled to
+ * the resolver's size (platform YUV decode included). Worklet-safe; call it inside your render
+ * callback before the passes that sample `resolver.texture`.
+ *
+ * @group WebGPU
+ */
+export declare function resolveCameraTexture(device: GPUDevice, resolver: CameraTextureResolver, cameraTexture: GPUExternalTexture, cameraWidth: number, cameraHeight: number, commandEncoder: GPUCommandEncoder): void;
+//# sourceMappingURL=cameraTextureResolver.d.ts.map

package/dist/typescript/webgpu/cameraTextureResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraTextureResolver.d.ts","sourceRoot":"","sources":["../../../src/webgpu/cameraTextureResolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,+BAA+B,EAA2B,MAAM,6BAA6B,CAAC;AAGvG;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,CAAC;CAC1E;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtC,qBAAqB,CAcvB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,qBAAqB,EAC/B,aAAa,EAAE,kBAAkB,EACjC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,iBAAiB,GAChC,IAAI,CAIN"}

package/dist/typescript/webgpu/cropUtilities.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Crop math + a worklet-safe byte packer for the {@link FrameCropParams} uniform used by
+ * {@link createCameraPassthroughPipeline} (and reusable by your own shaders).
+ */
+import * as d from 'typegpu/data';
+/**
+ * The TypeGPU schema for the crop uniform. This is the single source of truth for both the WGSL
+ * `struct FrameCropParams` (emitted when the passthrough shader is resolved) and the byte layout
+ * {@link packFrameCropParams} writes. Its std140 layout is 40 bytes:
+ *
+ *   sourceSize: vec2u  @0   cropOrigin: vec2f @8   cropSize: vec2f @16   uvTransform: mat2x2f @24
+ *
+ * @group WebGPU
+ */
+export declare const FrameCropParams: d.WgslStruct<{
+    sourceSize: d.Vec2u;
+    cropOrigin: d.Vec2f;
+    cropSize: d.Vec2f;
+    uvTransform: d.Mat2x2f;
+}>;
+/**
+ * A center-crop of a source frame plus a UV-space orientation transform, in source pixels.
+ * Produce one with {@link computeAspectFillCrop} or {@link computeSquareCrop}.
+ *
+ * @group WebGPU
+ */
+export interface FrameCrop {
+    sourceWidth: number;
+    sourceHeight: number;
+    cropOriginX: number;
+    cropOriginY: number;
+    cropSizeX: number;
+    cropSizeY: number;
+    /** uvTransform matrix scalars in (m00, m01, m10, m11) order; identity when omitted at compute time. */
+    uv00: number;
+    uv01: number;
+    uv10: number;
+    uv11: number;
+}
+/**
+ * Packs a {@link FrameCrop} into the {@link FrameCropParams} uniform byte layout.
+ * Worklet-safe; upload the result with `device.queue.writeBuffer(buffer, 0, bytes)`.
+ *
+ * @group WebGPU
+ */
+export declare function packFrameCropParams(crop: FrameCrop): ArrayBuffer;
+/**
+ * Center-crop of a (sourceWidth × sourceHeight) frame to the target aspect ratio (width/height).
+ * A no-op full-frame crop when the source already has the target aspect. Worklet-safe.
+ *
+ * Feed it the upright camera size from the render context:
+ * `computeAspectFillCrop(context.cameraWidth, context.cameraHeight, context.outputWidth / context.outputHeight)`.
+ *
+ * The optional `uv00..uv11` scalars form a UV-space transform applied around the frame center
+ * (identity by default).
+ *
+ * @group WebGPU
+ */
+export declare function computeAspectFillCrop(sourceWidth: number, sourceHeight: number, targetAspect: number, uv00?: number, uv01?: number, uv10?: number, uv11?: number): FrameCrop;
+/**
+ * Square center-crop of a (sourceWidth × sourceHeight) frame — the usual shape for square model
+ * inputs. Worklet-safe. The optional `uv00..uv11` scalars are as in {@link computeAspectFillCrop}.
+ *
+ * @group WebGPU
+ */
+export declare function computeSquareCrop(sourceWidth: number, sourceHeight: number, uv00?: number, uv01?: number, uv10?: number, uv11?: number): FrameCrop;
+//# sourceMappingURL=cropUtilities.d.ts.map

package/dist/typescript/webgpu/cropUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cropUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgpu/cropUtilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;EAK1B,CAAC;AAEH;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,uGAAuG;IACvG,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAQD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,CAgBhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,GACf,SAAS,CAqBX;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,EAChB,IAAI,GAAE,MAAU,GACf,SAAS,CAeX"}

package/dist/typescript/webgpu/frameRenderContext.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Everything your render callback needs for one frame. Handed to the function you pass to
+ * `render(...)` inside the source hook's `onFrame` worklet; every field is valid only until that
+ * function returns.
+ *
+ * @group WebGPU
+ */
+export interface WebGpuFrameRenderContext {
+    /** The device in use (the shared device, or your override). */
+    device: GPUDevice;
+    /** Shortcut for `device.queue`. */
+    queue: GPUQueue;
+    /**
+     * The command encoder for this frame. Encode your render/compute passes into it — the hook
+     * submits it (a single submit) and delivers the frame after your callback returns. Do not call
+     * `queue.submit` yourself for work targeting {@link outputTexture}.
+     */
+    commandEncoder: GPUCommandEncoder;
+    /**
+     * The live camera frame as a `texture_external`, already rotated upright (and mirrored per the
+     * camera's mirroring). On Android it samples as raw YCbCr — sample it through
+     * `createCameraShaderBindings` (or the ready-made {@link cameraBindGroup}) for
+     * platform-correct RGB.
+     */
+    cameraTexture: GPUExternalTexture;
+    /**
+     * Ready-made bind group for {@link cameraTexture}, present when the hook's
+     * `cameraShaderBindings` option was provided: set it at the bindings' group index and
+     * `sampleCamera(uv)` works.
+     */
+    cameraBindGroup?: GPUBindGroup;
+    /** The output texture your passes draw into; its content becomes the published video frame. */
+    outputTexture: GPUTexture;
+    /**
+     * A cached, reusable default `createView()` of {@link outputTexture}. Prefer this over calling
+     * `outputTexture.createView()` yourself every frame: `GPUTextureView` has no `destroy()`/`release()`
+     * in react-native-webgpu, so a per-frame view accumulates native (malloc) wrappers on the frame
+     * runtime until GC — a steady leak in a render loop. The output textures are a small fixed pool, so
+     * the hook builds one view per slot and reuses it.
+     */
+    outputView: GPUTextureView;
+    /** Size of {@link outputTexture}, in pixels. */
+    outputWidth: number;
+    outputHeight: number;
+    /**
+     * Upright (post-rotation) camera frame size, in pixels — feed it to `computeAspectFillCrop`
+     * together with the output aspect.
+     */
+    cameraWidth: number;
+    cameraHeight: number;
+    /** Whether the camera feed is mirrored (front cameras usually are). */
+    cameraIsMirrored: boolean;
+}
+/**
+ * The `render` function handed to the source hook's `onFrame` worklet. Call it at most once per
+ * frame with your encode function; skipping it drops the frame (nothing is published for it).
+ *
+ * @group WebGPU
+ */
+export type WebGpuFrameRenderFunction = (encode: (context: WebGpuFrameRenderContext) => void) => void;
+//# sourceMappingURL=frameRenderContext.d.ts.map

package/dist/typescript/webgpu/frameRenderContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameRenderContext.d.ts","sourceRoot":"","sources":["../../../src/webgpu/frameRenderContext.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,+DAA+D;IAC/D,MAAM,EAAE,SAAS,CAAC;IAClB,mCAAmC;IACnC,KAAK,EAAE,QAAQ,CAAC;IAChB;;;;OAIG;IACH,cAAc,EAAE,iBAAiB,CAAC;IAClC;;;;;OAKG;IACH,aAAa,EAAE,kBAAkB,CAAC;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,YAAY,CAAC;IAC/B,+FAA+F;IAC/F,aAAa,EAAE,UAAU,CAAC;IAC1B;;;;;;OAMG;IACH,UAAU,EAAE,cAAc,CAAC;IAC3B,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,wBAAwB,KAAK,IAAI,KAAK,IAAI,CAAC"}

package/dist/typescript/webgpu/requiredFeatures.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The GPU features a device must have to import camera frames and Fishjam output surfaces on this
+ * platform. {@link useCameraWebGpuDevice} requests them for you; pass them yourself as
+ * `requiredFeatures` in `GPUDeviceDescriptor` when you bring your own device.
+ *
+ * @group WebGPU
+ */
+export declare function getRequiredWebGpuCameraFeatures(): GPUFeatureName[];
+/**
+ * Throws a descriptive error when `device` is missing any feature required to import camera
+ * frames or Fishjam output surfaces on this platform. Called automatically on devices passed as
+ * an override; call it yourself to validate a device early.
+ *
+ * @group WebGPU
+ */
+export declare function assertWebGpuDeviceSupportsCameraImport(device: GPUDevice): void;
+/**
+ * The pixel format of Fishjam output surfaces on this platform: `'rgba8unorm'` on Android
+ * (AHardwareBuffer), `'bgra8unorm'` on iOS (IOSurface). Use it as the render-target format of any
+ * pipeline that draws into the output texture — a mismatched format renders wrong or black.
+ *
+ * @group WebGPU
+ */
+export declare function getOutputSurfaceFormat(): GPUTextureFormat;
+//# sourceMappingURL=requiredFeatures.d.ts.map

package/dist/typescript/webgpu/requiredFeatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requiredFeatures.d.ts","sourceRoot":"","sources":["../../../src/webgpu/requiredFeatures.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wBAAgB,+BAA+B,IAAI,cAAc,EAAE,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,sCAAsC,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAW9E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD"}

package/dist/typescript/webgpu/useCameraWebGpuDevice.d.ts

@@ -0,0 +1,27 @@
+/** Result of {@link useCameraWebGpuDevice}. */
+export interface UseCameraWebGpuDeviceResult {
+    /** The shared GPUDevice; `null` until acquisition resolves. */
+    device: GPUDevice | null;
+    /** Acquisition failure (no adapter, missing platform features), if any. */
+    error: Error | null;
+}
+/**
+ * The app-wide GPUDevice used for camera work, configured with
+ * {@link getRequiredWebGpuCameraFeatures}. All callers share one device, so pipelines you build
+ * against it work with the textures the source hook hands your render callback.
+ *
+ * Build your pipelines once the device arrives:
+ * ```tsx
+ * const { device } = useCameraWebGpuDevice();
+ * const effect = useMemo(() => (device ? buildMyEffect(device) : null), [device]);
+ * ```
+ *
+ * @group WebGPU
+ */
+export declare function useCameraWebGpuDevice(): UseCameraWebGpuDeviceResult;
+/**
+ * Device resolution for the source hook: the user-provided override (validated) when present,
+ * otherwise the shared device. Always called, so hook order stays stable either way.
+ */
+export declare function useCameraWebGpuDeviceWithOverride(override: GPUDevice | undefined): UseCameraWebGpuDeviceResult;
+//# sourceMappingURL=useCameraWebGpuDevice.d.ts.map

package/dist/typescript/webgpu/useCameraWebGpuDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraWebGpuDevice.d.ts","sourceRoot":"","sources":["../../../src/webgpu/useCameraWebGpuDevice.ts"],"names":[],"mappings":"AA+CA,+CAA+C;AAC/C,MAAM,WAAW,2BAA2B;IAC1C,+DAA+D;IAC/D,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,2EAA2E;IAC3E,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,IAAI,2BAA2B,CAsBnE;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,GAAG,2BAA2B,CAqB9G"}

package/dist/typescript/webgpu/webGpuRuntime.d.ts

@@ -0,0 +1,14 @@
+/** The react-native-webgpu runtime singleton (the `RNWebGPU` JSI global). */
+export type WebGpuRuntime = typeof RNWebGPU;
+/**
+ * Returns the react-native-webgpu runtime singleton, self-healing when the `RNWebGPU` global is
+ * missing on the calling runtime. The library binds the global once at module load, but that
+ * binding can be absent after a crash-recovery runtime reload or an install-ordering flake;
+ * `WebGPUModule.install()` binds it to the calling runtime and is safe to repeat.
+ *
+ * @throws When the runtime cannot be installed (react-native-webgpu missing or its native module
+ * not linked) — returning the still-undefined global would only defer the failure to an opaque
+ * per-frame TypeError.
+ */
+export declare function getWebGpuRuntime(): WebGpuRuntime;
+//# sourceMappingURL=webGpuRuntime.d.ts.map

package/dist/typescript/webgpu/webGpuRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webGpuRuntime.d.ts","sourceRoot":"","sources":["../../../src/webgpu/webGpuRuntime.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,OAAO,QAAQ,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAahD"}

package/dist/typescript/webgpu.d.ts

@@ -0,0 +1,24 @@
+/**
+ * WebGPU camera toolkit — sample the live camera and render your own content into the video you
+ * publish with `useManagedPooledTrack` (from the package's main entry point). Requires `react-native-webgpu` (an optional peer of
+ * this package; only this entry point loads it).
+ *
+ * - {@link createCameraShaderBindings} — sample the live camera from your own shaders via
+ *   `sampleCamera(uv)`, with the platform's YUV decode handled for you.
+ * - {@link createCameraPassthroughPipeline} / {@link encodeCameraPassthrough} — a ready-made
+ *   camera→output pass to publish the camera with zero WGSL, or to build overlays on.
+ * - {@link createCameraTextureResolver} — opt-in plain-texture camera for pipelines that can't
+ *   sample `texture_external`.
+ * - {@link useCameraWebGpuDevice} — the shared, camera-import-capable GPUDevice.
+ *
+ * @packageDocumentation
+ */
+export { type CameraPassthroughPipeline, type CameraPassthroughPipelineOptions, createCameraPassthroughPipeline, encodeCameraPassthrough, } from './webgpu/cameraPassthroughPipeline';
+export { type CameraShaderBindings, createCameraBindGroup, createCameraShaderBindings, type CreateCameraShaderBindingsOptions, sampleCamera, } from './webgpu/cameraShaderBindings';
+export { type CameraTextureResolver, createCameraTextureResolver, resolveCameraTexture, } from './webgpu/cameraTextureResolver';
+export { computeAspectFillCrop, computeSquareCrop, type FrameCrop, FrameCropParams, packFrameCropParams, } from './webgpu/cropUtilities';
+export type { WebGpuFrameRenderContext, WebGpuFrameRenderFunction } from './webgpu/frameRenderContext';
+export { assertWebGpuDeviceSupportsCameraImport, getOutputSurfaceFormat, getRequiredWebGpuCameraFeatures, } from './webgpu/requiredFeatures';
+export { useCameraWebGpuDevice, type UseCameraWebGpuDeviceResult, useCameraWebGpuDeviceWithOverride, } from './webgpu/useCameraWebGpuDevice';
+export { getWebGpuRuntime, type WebGpuRuntime } from './webgpu/webGpuRuntime';
+//# sourceMappingURL=webgpu.d.ts.map

package/dist/typescript/webgpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu.d.ts","sourceRoot":"","sources":["../../src/webgpu.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,KAAK,oBAAoB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,KAAK,iCAAiC,EACtC,YAAY,GACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,SAAS,EACd,eAAe,EACf,mBAAmB,GACpB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACvG,OAAO,EACL,sCAAsC,EACtC,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,iCAAiC,GAClC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC"}

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@fishjam-cloud/react-native-custom-video-source",
+  "version": "0.29.0",
+  "description": "Publish your own video frames to Fishjam — forward native buffers or render into a WebGPU surface pool, from any frame source",
+  "license": "Apache-2.0",
+  "author": "Fishjam Team",
+  "main": "./dist/module/index.js",
+  "module": "./dist/module/index.js",
+  "types": "./dist/typescript/index.d.ts",
+  "react-native": "./dist/module/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/typescript/index.d.ts",
+      "react-native": "./dist/module/index.js",
+      "import": "./dist/module/index.js",
+      "default": "./dist/module/index.js"
+    },
+    "./webgpu": {
+      "types": "./dist/typescript/webgpu.d.ts",
+      "react-native": "./dist/module/webgpu.js",
+      "import": "./dist/module/webgpu.js",
+      "default": "./dist/module/webgpu.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fishjam-cloud/web-client-sdk.git",
+    "directory": "packages/react-native-custom-video-source"
+  },
+  "homepage": "https://github.com/fishjam-cloud/web-client-sdk#readme",
+  "bugs": "https://github.com/fishjam-cloud/web-client-sdk/issues",
+  "keywords": [
+    "webrtc",
+    "fishjam",
+    "webgpu",
+    "custom-video"
+  ],
+  "scripts": {
+    "tsc": "tsc --noEmit",
+    "build:webrtc-workspace": "yarn workspace @fishjam-cloud/react-native-webrtc run prepare",
+    "build": "yarn build:webrtc-workspace && bob build",
+    "lint": "eslint . --ext .ts,.tsx --fix",
+    "prepare": "yarn build:webrtc-workspace && bob build",
+    "format": "prettier --write . --ignore-path ./.eslintignore",
+    "check:webrtc-published": "node ../../release-automation/check-webrtc-published.mjs"
+  },
+  "lint-staged": {
+    "*": [
+      "yarn format"
+    ],
+    "*.{js,ts,tsx}": [
+      "yarn lint"
+    ]
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "dist",
+    "targets": [
+      [
+        "module",
+        {
+          "configFile": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json",
+          "tsc": "../../node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  },
+  "peerDependencies": {
+    "@fishjam-cloud/react-native-webrtc": "0.29.0",
+    "react": "*",
+    "react-native": "*",
+    "react-native-webgpu": ">=0.5.15"
+  },
+  "peerDependenciesMeta": {
+    "react-native-webgpu": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "typegpu": "^0.11.8"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-typescript": "^7.27.0",
+    "@fishjam-cloud/react-native-webrtc": "0.29.0",
+    "@types/react": "19.2.14",
+    "@webgpu/types": "0.1.65",
+    "eslint-config-expo": "~9.2.0",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-prettier": "^5.5.1",
+    "react": "19.1.0",
+    "react-native": "0.85.3",
+    "react-native-builder-bob": "^0.18.2",
+    "react-native-webgpu": "0.5.15",
+    "typescript": "^5.8.3",
+    "unplugin-typegpu": "^0.11.5"
+  },
+  "packageManager": "yarn@4.16.0"
+}