react-native-facefusion 0.1.0

package/src/NativeFacefusion.ts

@@ -0,0 +1,324 @@
+import {
+  TurboModuleRegistry,
+  type CodegenTypes,
+  type TurboModule,
+} from 'react-native';
+
+/**
+ * What the device's Hexagon NPU reports about itself.
+ *
+ * `ok` is the field that decides whether the rest mean anything. `false` means the probe
+ * could not run — no Qualcomm NPU, no QNN runtime, an emulator — and *not* that the chip
+ * is too old. `tier` and `tierChain` are still usable in that case: they fall back to
+ * `v68`, the build that runs on every Hexagon.
+ */
+export type DeviceProbeResult = {
+  /** True only when the NPU was actually measured. */
+  ok: boolean;
+  /** The context-binary tier this chip should download — `v68` … `v81`. */
+  tier: string;
+  /** Every tier that would load here, best first. The downloader wants this one. */
+  tierChain: string[];
+  /** Hexagon architecture number: 68, 73, 79, 81. `0` when unmeasured. */
+  arch: number;
+  /** Tightly-coupled memory in MB. The v73/v79/v81 builds need 8. */
+  vtcmMb: number;
+  /** Qualcomm's SoC id — 69 is SM8750, the 8 Elite. */
+  socModel: number;
+  signedPd: boolean;
+  dlbc: boolean;
+  /** Why the probe failed. Empty when `ok`. */
+  error: string;
+};
+
+/**
+ * What is on disk, and what the pipeline would load right now.
+ *
+ * `tier` is resolved against the **files present**, not against the chip: a phone whose
+ * best architecture has no published models runs the best tier that does. So this can
+ * legitimately differ from `DeviceProbeResult.tier`, and this is the one that matters for
+ * "can it run".
+ */
+export type ModelStatus = {
+  /** The tier that will actually be loaded — best tier whose files are on disk. */
+  tier: string;
+  /** Every tier this chip could load, best first. */
+  tierChain: string[];
+  /** Absolute path of the models directory. */
+  dir: string;
+  /** True when every model the pipeline requires is present and verified. */
+  ready: boolean;
+  /** Base names of the required models still absent, e.g. `['hyperswap', 'nsfw']`. */
+  missing: string[];
+  /** Whether the optional face enhancer (`gpen`) is present. */
+  hasEnhancer: boolean;
+  /** True when the current connection is metered — worth a warning before ~317 MB. */
+  metered: boolean;
+};
+
+/**
+ * Tunable knobs for a swap. Every field is optional and defaults to upstream's own default
+ * for the `hyperswap` swapper — see `ffpipe::Config` in the vendored C++.
+ */
+export type SwapOptions = {
+  /** Blends the two identity embeddings before the generator sees them. 0.5 = source,
+   *  unmodified; above it strengthens the source identity, below it blends the target's
+   *  identity back in. Default `0.5`. */
+  swapperWeight?: number;
+  /** Softness of the paste-back mask edge, `0..1`. Default `0.3`. */
+  maskBlur?: number;
+  /** `[top, right, bottom, left]`, each `0..100` percent. Default `[0, 0, 0, 0]`. */
+  maskPadding?: number[];
+  /** Minimum detector confidence to count as a face, `0..1`. Default `0.5`. */
+  detectorScore?: number;
+  /** Minimum landmarker confidence, `0..1`. Default `0.5`. */
+  landmarkerScore?: number;
+  /** Per-axis upscale of the swap crop: 1 = 256px, 2 = 512px, 3 = 768px, 4 = 1024px. Costs
+   *  `pixelBoost²` swapper invocations. Default `1`. */
+  pixelBoost?: number;
+  /** Swap only the largest face instead of every face found. Default `false`. */
+  largestFaceOnly?: boolean;
+  /** Run the face enhancer after swapping. Silently has no effect if the enhancer model is
+   *  not on disk — check {@link ModelStatus.hasEnhancer} before offering this. Default
+   *  `false`. */
+  faceEnhance?: boolean;
+  /** How much of the enhancer to blend in, `0..1`. `0` is the swapper's output untouched.
+   *  Default `0.8`. */
+  faceEnhancerBlend?: number;
+  /**
+   * Which face in the source photo to use as the identity, as `[left, top, right,
+   * bottom]` from {@link detectSourceFaces} — in the source image's own pixel
+   * coordinates, not normalised. Omit for the default: the largest face in the source,
+   * same as every swap before this option existed.
+   */
+  sourceFaceBox?: number[];
+  /**
+   * Which face in the target to swap, as `[left, top, right, bottom]` from
+   * {@link detectTargetFaces} — in the target's own pixel coordinates (for a video, the
+   * clip's upright orientation). Omit to swap every face found (subject to
+   * {@link SwapOptions.largestFaceOnly}), same as every swap before this option existed.
+   * For a video, the box is picked once and held fixed for the whole clip — it is not
+   * re-detected frame to frame, so a subject who moves far out of it stops being swapped.
+   */
+  targetFaceBox?: number[];
+  /**
+   * `swapVideo` only. Caps how many of the source's frames actually get swapped and
+   * encoded — the rest are decoded and dropped, not held back or slowed down, so the
+   * output plays at the same real-world duration, just choppier. Omit, or set `>=` the
+   * source's own frame rate, to process every frame (default). Lowering this is a direct
+   * wall-clock speed lever: half the frames is roughly half the NPU + encode work.
+   */
+  targetFps?: number;
+};
+
+/**
+ * Tunable knobs for a detect-only pass — the same two thresholds {@link SwapOptions}
+ * carries, and they mean exactly the same thing.
+ *
+ * **Pass the same values here that you pass to the swap.** Two reasons. The obvious one is
+ * that a face picker which finds a face the following swap then rejects is a picker that
+ * lies. The non-obvious one is cost: these thresholds reach the native pipeline through
+ * `initEx`, so changing one re-opens every model graph. Detecting at the defaults and then
+ * swapping at your own values pays that reload twice per swap.
+ *
+ * Lowering {@link detectorScore} is the fix for "it finds the face on one phone and not on
+ * another with the same photo" — see the note on that field.
+ */
+export type DetectOptions = {
+  /**
+   * Minimum detector confidence to count as a face, `0..1`. Default `0.5`, which is
+   * upstream FaceFusion's own default.
+   *
+   * **This is the knob that differs by chip.** Every tier ships the same 4.0 MB yoloface
+   * graph, but as a *separately compiled* QNN context binary per Hexagon architecture, so
+   * the same photo scores differently on a v68 chip than on a v79 one. The cutoff is hard
+   * (`score <= detectorScore` is dropped outright), so a face scoring 0.46 on an older
+   * chip and 0.58 on a newer one is found on exactly one of them. Offer this as a control
+   * rather than treating "no faces" as final; ~0.3 recovers most of the gap.
+   */
+  detectorScore?: number;
+  /** Minimum landmarker confidence, `0..1`. Default `0.5`. */
+  landmarkerScore?: number;
+};
+
+/** One face found in a source photo, in the image's own pixel coordinates. */
+export type DetectedFace = {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+  /** Detector confidence, `0..1`. */
+  score: number;
+  /**
+   * Width of the image **as actually analysed** — the coordinate space `left`/`right`
+   * are in, which is *not* the size of the file on disk.
+   *
+   * Large photos are subsampled during decode so they fit in memory (a 50 MP photo
+   * needs ~950 MB uncapped), and a video target is analysed at its own frame size with
+   * no cap at all. So the scale factor differs by input type and cannot be worked out
+   * from the file — use these two fields.
+   *
+   * You do not need them to pick a face: pass a box straight back as
+   * `SwapOptions.targetFaceBox`/`sourceFaceBox` and it lines up, because the swap crops
+   * in this same space. You *do* need them to draw the box over the original image or
+   * crop a thumbnail from it:
+   *
+   * ```ts
+   * const scaleX = displayedWidth / face.imageWidth;
+   * const scaleY = displayedHeight / face.imageHeight;
+   * const rect = {
+   *   left: face.left * scaleX,
+   *   top: face.top * scaleY,
+   *   width: (face.right - face.left) * scaleX,
+   *   height: (face.bottom - face.top) * scaleY,
+   * };
+   * ```
+   */
+  imageWidth: number;
+  /** Height of the image as actually analysed — see {@link DetectedFace.imageWidth}. */
+  imageHeight: number;
+};
+
+/** The result of one still-photo swap. */
+export type SwapPhotoResult = {
+  /** Same as the `outputPath` passed in — returned for convenience. */
+  outputPath: string;
+  /** Faces found in the target. `0` means the swap ran but found nothing to swap, and
+   *  `outputPath` is then an untouched copy of the target. */
+  faceCount: number;
+  /** The tier that ran — see {@link ModelStatus.tier}. */
+  tier: string;
+};
+
+/** The result of one video swap. */
+export type SwapVideoResult = {
+  /** Same as the `outputPath` passed in — returned for convenience. */
+  outputPath: string;
+  /** Frames decoded, swapped and re-encoded — the real count. */
+  frameCount: number;
+  /** Of `frameCount`, how many had at least one face swapped. */
+  faceFrameCount: number;
+  /** The tier that ran — see {@link ModelStatus.tier}. */
+  tier: string;
+  /** Measured wall-clock frames/second across the decode-swap-encode loop. Not upstream's
+   *  per-graph figure — see `docs/MEMORY.md` rule 11. */
+  fps: number;
+  /** Whether the source clip had an audio track — if so, it was copied to `outputPath`
+   *  unmodified. */
+  hasAudio: boolean;
+};
+
+/** A tick of progress through a video swap. */
+export type VideoSwapProgress = {
+  /** Frames decoded, swapped and encoded so far. */
+  frameIndex: number;
+  /** Estimated from the container's duration and frame rate. `0` when it could not be
+   *  estimated — a variable-frame-rate source has no true count until the last frame. */
+  estimatedFrameCount: number;
+  /** Wall-clock frames/second so far. */
+  fps: number;
+};
+
+/** A download in flight. Byte counts are across the whole set, not the current file. */
+export type ModelDownloadProgress = {
+  /** The tier being fetched. May differ from the chip's best tier — see [ModelStatus]. */
+  tier: string;
+  /** 1-based index of the file being fetched, of `fileCount`. */
+  fileIndex: number;
+  /** How many files this run has to fetch. Already-present files are not counted. */
+  fileCount: number;
+  /** File name being fetched, e.g. `hyperswap_v79.bin`. Empty on the final tick. */
+  name: string;
+  /** Bytes transferred so far across the run, including a resumed `.part`. */
+  doneBytes: number;
+  /** Bytes this run has to transfer in total. */
+  totalBytes: number;
+};
+
+export interface Spec extends TurboModule {
+  probeDevice(): Promise<DeviceProbeResult>;
+  getModelStatus(): Promise<ModelStatus>;
+  downloadModels(): Promise<ModelStatus>;
+  cancelModelDownload(): void;
+  readonly onModelDownloadProgress: CodegenTypes.EventEmitter<ModelDownloadProgress>;
+  /**
+   * Swaps the face from `sourcePath` into every face found in `targetPath`, writing the
+   * result to `outputPath`. Paths in, path out — no pixels cross the bridge.
+   *
+   * Rejects with `E_BUSY` if a swap or video job is already running, `E_MODELS` if the
+   * required models are not on disk yet, `E_CONTENT` if the target was refused by the
+   * content gate, and `E_SWAP` otherwise.
+   */
+  swapPhoto(
+    sourcePath: string,
+    targetPath: string,
+    outputPath: string,
+    options?: SwapOptions
+  ): Promise<SwapPhotoResult>;
+  /**
+   * Swaps the face from `sourcePath` into every frame of the video at `targetPath`,
+   * writing the result to `outputPath`. Runs behind a foreground service (Android requires
+   * one for a job this long) and reports progress via {@link onVideoSwapProgress}.
+   *
+   * Rejects with `E_BUSY` if a swap or another video job is already running, `E_MODELS` if
+   * the required models are not on disk yet, `E_CANCELLED` if {@link cancelVideoSwap} was
+   * called, `E_CONTENT` if the target was refused by the content gate, and `E_SWAP`
+   * otherwise.
+   */
+  swapVideo(
+    sourcePath: string,
+    targetPath: string,
+    outputPath: string,
+    options?: SwapOptions
+  ): Promise<SwapVideoResult>;
+  /** Asks the video swap in flight to stop. Fire-and-forget — the answer arrives as the
+   *  `E_CANCELLED` rejection of the {@link swapVideo} promise, not from here. */
+  cancelVideoSwap(): void;
+  readonly onVideoSwapProgress: CodegenTypes.EventEmitter<VideoSwapProgress>;
+  /**
+   * Every face detected in the photo at `sourcePath`, for a UI to let the user pick one
+   * before swapping — pass the chosen face's box back as {@link SwapOptions.sourceFaceBox}.
+   * Does not swap or modify anything.
+   *
+   * Rejects with `E_BUSY` if a swap or video job is already running, `E_MODELS` if the
+   * required models are not on disk yet, and `E_DETECT` otherwise.
+   */
+  detectSourceFaces(
+    sourcePath: string,
+    options?: DetectOptions
+  ): Promise<DetectedFace[]>;
+  /**
+   * Every face detected in the target at `targetPath` — a photo, or a video (its first
+   * frame, already upright) — for a UI to let the user pick one before swapping. Pass the
+   * chosen face's box back as {@link SwapOptions.targetFaceBox}. Does not swap or modify
+   * anything.
+   *
+   * Rejects with `E_BUSY` if a swap or video job is already running, `E_MODELS` if the
+   * required models are not on disk yet, and `E_DETECT` otherwise.
+   */
+  detectTargetFaces(
+    targetPath: string,
+    options?: DetectOptions
+  ): Promise<DetectedFace[]>;
+  /**
+   * Copies the file at `path` — a `swapPhoto`/`swapVideo` output, typically — into the
+   * system's Photos/Gallery app, under a `Facefusion` album. Returns the resulting
+   * `content://` URI as a string.
+   *
+   * `path` and the app that owns it stay exactly as they were; this is a copy, not a move.
+   * `mimeType` must be `image/*` or `video/*` — pass the real one for the file (`image/jpeg`
+   * for `swapPhoto`'s default output, `video/mp4` for `swapVideo`'s), since there is no safe
+   * way to guess it from an arbitrary path. `displayName` defaults to `path`'s own filename.
+   *
+   * No storage permission is needed for this on Android — inserting new media an app itself
+   * created has never required one under scoped storage (API 29+). Rejects with `E_MIME` for
+   * an unsupported `mimeType` and `E_SAVE` for anything else, naming what failed.
+   */
+  saveToGallery(
+    path: string,
+    mimeType: string,
+    displayName?: string
+  ): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Facefusion');

package/src/detectSourceFaces.native.tsx

@@ -0,0 +1,17 @@
+import Facefusion from './NativeFacefusion';
+import type { DetectedFace, DetectOptions } from './NativeFacefusion';
+
+/**
+ * Every face detected in the photo at `sourcePath`, for a UI to let the user pick one
+ * before swapping — pass the chosen face's box back as `sourceFaceBox` in `SwapOptions`.
+ * Does not swap or modify anything.
+ *
+ * Rejects with `E_BUSY` if a swap or video job is already running, `E_MODELS` if the
+ * required models are not on disk yet, and `E_DETECT` otherwise.
+ */
+export function detectSourceFaces(
+  sourcePath: string,
+  options?: DetectOptions
+): Promise<DetectedFace[]> {
+  return Facefusion.detectSourceFaces(sourcePath, options);
+}

package/src/detectSourceFaces.tsx

@@ -0,0 +1,10 @@
+import type { DetectedFace, DetectOptions } from './NativeFacefusion';
+
+export function detectSourceFaces(
+  _sourcePath: string,
+  _options?: DetectOptions
+): Promise<DetectedFace[]> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}

package/src/detectTargetFaces.native.tsx

@@ -0,0 +1,15 @@
+import Facefusion from './NativeFacefusion';
+import type { DetectedFace, DetectOptions } from './NativeFacefusion';
+
+/**
+ * Every face detected in the target at `targetPath` — a photo, or a video (its first
+ * frame, already upright) — for a UI to let the user pick one before swapping — pass the
+ * chosen face's box back as `targetFaceBox` in `SwapOptions`. Does not swap or modify
+ * anything.
+ */
+export function detectTargetFaces(
+  targetPath: string,
+  options?: DetectOptions
+): Promise<DetectedFace[]> {
+  return Facefusion.detectTargetFaces(targetPath, options);
+}

package/src/detectTargetFaces.tsx

@@ -0,0 +1,10 @@
+import type { DetectedFace, DetectOptions } from './NativeFacefusion';
+
+export function detectTargetFaces(
+  _targetPath: string,
+  _options?: DetectOptions
+): Promise<DetectedFace[]> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}

package/src/index.tsx

@@ -0,0 +1,25 @@
+export { probeDevice } from './probeDevice';
+export {
+  getModelStatus,
+  downloadModels,
+  cancelModelDownload,
+  onModelDownloadProgress,
+} from './models';
+export { swapPhoto } from './swapPhoto';
+export { swapVideo, cancelVideoSwap, onVideoSwapProgress } from './swapVideo';
+export { detectSourceFaces } from './detectSourceFaces';
+export { detectTargetFaces } from './detectTargetFaces';
+export { saveToGallery } from './saveToGallery';
+export { FacefusionPreview } from './FacefusionPreview';
+export type { FacefusionPreviewProps } from './FacefusionPreview';
+export type {
+  DeviceProbeResult,
+  ModelStatus,
+  ModelDownloadProgress,
+  SwapOptions,
+  DetectOptions,
+  SwapPhotoResult,
+  SwapVideoResult,
+  VideoSwapProgress,
+  DetectedFace,
+} from './NativeFacefusion';

package/src/models.native.tsx

@@ -0,0 +1,45 @@
+import Facefusion from './NativeFacefusion';
+import type { EventSubscription } from 'react-native';
+import type { ModelStatus, ModelDownloadProgress } from './NativeFacefusion';
+
+/**
+ * What is on disk and whether a swap could run right now. Reads the filesystem only —
+ * no network, cheap enough to call whenever a screen appears.
+ */
+export function getModelStatus(): Promise<ModelStatus> {
+  return Facefusion.getModelStatus();
+}
+
+/**
+ * Download every model this device still needs, resolving with the resulting status.
+ *
+ * ~317 MB on a fresh install, and minutes on a phone connection. Resumable: an interrupted
+ * run leaves `.part` files and calling this again continues from where it stopped, so a
+ * retry after a dropped connection is cheap. Files already present and the right size are
+ * skipped, so calling it when everything is downloaded costs one manifest request.
+ *
+ * Rejects with `E_CANCELLED` after {@link cancelModelDownload}, `E_BUSY` if a download is
+ * already running, and `E_DOWNLOAD` naming the file that failed otherwise.
+ */
+export function downloadModels(): Promise<ModelStatus> {
+  return Facefusion.downloadModels();
+}
+
+/**
+ * Stop the download in flight. The promise from {@link downloadModels} rejects with
+ * `E_CANCELLED`; partial files are kept for a later resume.
+ */
+export function cancelModelDownload(): void {
+  Facefusion.cancelModelDownload();
+}
+
+/**
+ * Subscribe to download progress. Emits about four times a second while a download runs.
+ *
+ * Returns the subscription — call `.remove()` on unmount.
+ */
+export function onModelDownloadProgress(
+  listener: (progress: ModelDownloadProgress) => void
+): EventSubscription {
+  return Facefusion.onModelDownloadProgress(listener);
+}

package/src/models.tsx

@@ -0,0 +1,23 @@
+import type { EventSubscription } from 'react-native';
+import type { ModelStatus, ModelDownloadProgress } from './NativeFacefusion';
+
+const unsupported = () =>
+  new Error("'react-native-facefusion' is only supported on native platforms.");
+
+export function getModelStatus(): Promise<ModelStatus> {
+  throw unsupported();
+}
+
+export function downloadModels(): Promise<ModelStatus> {
+  throw unsupported();
+}
+
+export function cancelModelDownload(): void {
+  throw unsupported();
+}
+
+export function onModelDownloadProgress(
+  _listener: (progress: ModelDownloadProgress) => void
+): EventSubscription {
+  throw unsupported();
+}

package/src/probeDevice.native.tsx

@@ -0,0 +1,13 @@
+import Facefusion from './NativeFacefusion';
+import type { DeviceProbeResult } from './NativeFacefusion';
+
+/**
+ * Ask the device which NPU it has and which model tier it needs.
+ *
+ * Cheap enough to call on startup, and safe on hardware that has no NPU at all — it
+ * resolves with `ok: false` rather than rejecting. It rejects only when the native
+ * library itself is missing or unloadable.
+ */
+export function probeDevice(): Promise<DeviceProbeResult> {
+  return Facefusion.probeDevice();
+}

package/src/probeDevice.tsx

@@ -0,0 +1,7 @@
+import type { DeviceProbeResult } from './NativeFacefusion';
+
+export function probeDevice(): Promise<DeviceProbeResult> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}

package/src/saveToGallery.native.tsx

@@ -0,0 +1,16 @@
+import Facefusion from './NativeFacefusion';
+
+/**
+ * Copies a `swapPhoto`/`swapVideo` output into the system's Photos/Gallery app, so it
+ * survives beyond this app's own private storage. Returns the resulting `content://` URI.
+ *
+ * `mimeType` must be `image/*` or `video/*` — pass the real one, there's no safe way to
+ * guess it from a path alone. No storage permission is needed on Android.
+ */
+export function saveToGallery(
+  path: string,
+  mimeType: string,
+  displayName?: string
+): Promise<string> {
+  return Facefusion.saveToGallery(path, mimeType, displayName);
+}

package/src/saveToGallery.tsx

@@ -0,0 +1,9 @@
+export function saveToGallery(
+  _path: string,
+  _mimeType: string,
+  _displayName?: string
+): Promise<string> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}

package/src/swapPhoto.native.tsx

@@ -0,0 +1,20 @@
+import Facefusion from './NativeFacefusion';
+import type { SwapOptions, SwapPhotoResult } from './NativeFacefusion';
+
+/**
+ * Swaps the face from `sourcePath` into every face found in `targetPath`, writing the
+ * result to `outputPath`.
+ *
+ * Both images are decoded and re-encoded natively — nothing but paths and options crosses
+ * the JS bridge. Rejects with `E_BUSY` if another swap (or, from Phase 7, a video job) is
+ * already running, `E_MODELS` if the required models are not downloaded yet, and `E_SWAP`
+ * for anything else, naming what failed.
+ */
+export function swapPhoto(
+  sourcePath: string,
+  targetPath: string,
+  outputPath: string,
+  options?: SwapOptions
+): Promise<SwapPhotoResult> {
+  return Facefusion.swapPhoto(sourcePath, targetPath, outputPath, options);
+}

package/src/swapPhoto.tsx

@@ -0,0 +1,12 @@
+import type { SwapOptions, SwapPhotoResult } from './NativeFacefusion';
+
+export function swapPhoto(
+  _sourcePath: string,
+  _targetPath: string,
+  _outputPath: string,
+  _options?: SwapOptions
+): Promise<SwapPhotoResult> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}

package/src/swapVideo.native.tsx

@@ -0,0 +1,40 @@
+import Facefusion from './NativeFacefusion';
+import type { EventSubscription } from 'react-native';
+import type {
+  SwapOptions,
+  SwapVideoResult,
+  VideoSwapProgress,
+} from './NativeFacefusion';
+
+/**
+ * Swaps the face from `sourcePath` into every frame of the video at `targetPath`, writing
+ * the result to `outputPath`.
+ *
+ * Runs behind a foreground service — Android kills a plain background process partway
+ * through a job this long. Rejects with `E_BUSY` if a photo or another video swap is
+ * already running, `E_MODELS` if the required models are not downloaded yet, `E_CANCELLED`
+ * if `cancelVideoSwap()` was called, and `E_SWAP` for anything else, naming what failed.
+ */
+export function swapVideo(
+  sourcePath: string,
+  targetPath: string,
+  outputPath: string,
+  options?: SwapOptions
+): Promise<SwapVideoResult> {
+  return Facefusion.swapVideo(sourcePath, targetPath, outputPath, options);
+}
+
+/** Asks the video swap in flight to stop. Fire-and-forget — see `swapVideo`'s doc. */
+export function cancelVideoSwap(): void {
+  Facefusion.cancelVideoSwap();
+}
+
+/**
+ * Subscribe to video swap progress. Returns the subscription — call `.remove()` on
+ * unmount.
+ */
+export function onVideoSwapProgress(
+  listener: (progress: VideoSwapProgress) => void
+): EventSubscription {
+  return Facefusion.onVideoSwapProgress(listener);
+}

package/src/swapVideo.tsx

@@ -0,0 +1,31 @@
+import type { EventSubscription } from 'react-native';
+import type {
+  SwapOptions,
+  SwapVideoResult,
+  VideoSwapProgress,
+} from './NativeFacefusion';
+
+export function swapVideo(
+  _sourcePath: string,
+  _targetPath: string,
+  _outputPath: string,
+  _options?: SwapOptions
+): Promise<SwapVideoResult> {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}
+
+export function cancelVideoSwap(): void {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}
+
+export function onVideoSwapProgress(
+  _listener: (progress: VideoSwapProgress) => void
+): EventSubscription {
+  throw new Error(
+    "'react-native-facefusion' is only supported on native platforms."
+  );
+}