react-native-facefusion 0.1.0

package/android/src/main/java/com/facefusion/mobile/NativePipe.kt

@@ -0,0 +1,192 @@
+package com.facefusion.mobile
+
+/**
+ * The JNI surface of `libffnative.so`.
+ *
+ * **The package name is load-bearing.** JNI binds a Java/Kotlin `external fun` to a C
+ * symbol by *name*: `ffjni.cpp` exports `Java_com_facefusion_mobile_NativePipe_probeTier`,
+ * which resolves only to a method called `probeTier` on a class called `NativePipe` in
+ * the package `com.facefusion.mobile`. Move or rename any part of that and the call
+ * fails at runtime with `UnsatisfiedLinkError`, not at build time. So this one file
+ * lives outside our own `com.facefusion` package, on purpose, and stays there.
+ *
+ * This is a Kotlin `object`, so the methods are instance methods on the singleton while
+ * `ffjni.cpp` declares its second parameter as `jclass` (the static form). That is fine:
+ * the mangled symbol name is identical either way, `jclass` and `jobject` are the same
+ * pointer, and every one of these functions ignores that argument.
+ *
+ * Nothing but `external fun` declarations and the library load belongs here. All of our
+ * own logic — path resolution, threading, parsing — lives in `com.facefusion`.
+ *
+ * Only the functions a shipped phase actually calls are declared. The rest of
+ * `ffjni.cpp` (init, setSource, processFrame, the colour converters) arrives with the
+ * phase that needs it.
+ */
+object NativePipe {
+
+  /**
+   * Null when `libffnative.so` loaded. Otherwise the reason it did not.
+   *
+   * The load is caught rather than thrown because a throw inside an `object` initialiser
+   * poisons the class forever: the first access dies with `ExceptionInInitializerError`
+   * and every access after it with a `NoClassDefFoundError` that no longer mentions the
+   * real cause. A device without the library should get a clear message, not that.
+   */
+  var loadError: String? = null
+    private set
+
+  init {
+    try {
+      System.loadLibrary("ffnative")
+    } catch (e: UnsatisfiedLinkError) {
+      loadError = e.message ?: e.toString()
+    }
+  }
+
+  /** The last error the native layer recorded. Empty when there has not been one. */
+  external fun lastError(): String
+
+  /**
+   * The context-binary tier this chip needs — `"v68"` … `"v81"`.
+   *
+   * `libDir` must hold `libQnnHtp.so` and `libQnnSystem.so`; `skelDir` the matching
+   * `libQnnHtpV<n>Skel.so`. In this package both are the app's `nativeLibraryDir`.
+   *
+   * Never throws and never returns empty: if the QNN backend cannot come up at all it
+   * answers `"v68"`, the floor that runs everywhere. Check [probeDeviceInfo] to tell a
+   * measured `v68` from a fallback one.
+   */
+  external fun probeTier(libDir: String, skelDir: String): String
+
+  /** Every tier this chip can load, best first, comma-joined: `"v81,v73,v68"`. */
+  external fun probeTierChain(libDir: String, skelDir: String): String
+
+  /**
+   * What the HTP reports, as `key=value;` pairs — `ok=1;arch=79;vtcm=8;soc=69;…`.
+   *
+   * `ok=0` means the probe **failed** and every other field is absent. It does not mean
+   * the chip is old, and the two must never be collapsed into one answer.
+   */
+  external fun probeDeviceInfo(libDir: String, skelDir: String): String
+
+  /**
+   * Brings up the pipeline: QNN backend, every required context binary, the swap config.
+   *
+   * `modelDir` must hold `<name>_<tier>.bin` for the tier this chip measures internally —
+   * the same resolution [com.facefusion.ModelPaths.tier] does against disk, so the two
+   * are expected to agree (see that file's class doc). `padding` is `[top, right, bottom,
+   * left]`, each `0..100`, or null for no padding.
+   *
+   * Expensive — `dlopen`s the QNN backend and finalises every graph — so callers keep the
+   * pipeline warm across calls rather than calling this per swap. See [PipeGuard].
+   */
+  external fun initEx(
+    libDir: String,
+    skelDir: String,
+    modelDir: String,
+    swapperName: String,
+    weight: Float,
+    maskBlur: Float,
+    padding: IntArray?,
+    detectorScore: Float,
+    landmarkerScore: Float,
+    pixelBoost: Int,
+    largestOnly: Boolean,
+    faceEnhance: Boolean,
+    enhanceBlend: Float,
+  ): Boolean
+
+  /** Tears down the pipeline built by [initEx]. Safe to call when nothing is initialised. */
+  external fun release()
+
+  /** Sets the source identity from one BGR image: the largest face's embedding only. */
+  external fun setSource(bgr: ByteArray, w: Int, h: Int): Boolean
+
+  /** Swaps every face in `bgr`, in place. Returns the face count found, or -1 on error. */
+  external fun processFrame(bgr: ByteArray, w: Int, h: Int): Int
+
+  /**
+   * Detects every face in `bgr` without swapping — box and confidence only, no embeddings.
+   * Flat, 5 floats per face: `[left, top, right, bottom, score] x N`, in `bgr`'s own pixel
+   * coordinates. Returns `null` on error (check [lastError]); an empty array is a real
+   * answer (no face found), not a failure.
+   *
+   * The one function in this file that is not upstream's — see
+   * `third_party/facefusion-mobile/NOTICE` and `docs/02-upstream.md` "Patches". Lets a
+   * multi-face source photo be shown to the user before [setSource] commits to one; the
+   * caller picks a face by cropping to its box and calling [setSource] on the crop, not by
+   * any parameter here.
+   */
+  external fun analyseFaces(bgr: ByteArray, w: Int, h: Int): FloatArray?
+
+  /**
+   * Upstream's NSFW content gate on one BGR frame (content_analyser.py:detect_with_nsfw_2).
+   * Returns the raw decision statistic `logit[0] - logit[1]` -- the threshold is policy and
+   * lives in [com.facefusion.ContentGate], not here -- or `NaN` if the graph did not run
+   * (check [lastError]). `NaN` must never be treated as "allow": there is no in-band float
+   * that could be mistaken for a real score, which is the point of returning it this way
+   * instead of a boolean.
+   */
+  external fun contentScore(bgr: ByteArray, w: Int, h: Int): Float
+
+  /**
+   * Whether the loaded tier's gate is the quantised build (every tier except v79). The
+   * quantised gate sits ~0.087 mean closer to flagging than the fp32 one, measured 16 of 16
+   * frames in the same direction -- see `docs/02-upstream.md` "The content gate". Reported
+   * alongside a refusal, never compensated for here.
+   */
+  external fun contentGateIsQuantised(): Boolean
+
+  /** `Bitmap.getPixels()` output (packed ARGB ints) -> packed BGR bytes for the pipeline. */
+  external fun argbToBgr(argb: IntArray, w: Int, h: Int): ByteArray
+
+  /**
+   * Packed BGR bytes -> packed ARGB ints for `Bitmap.setPixels()`, optionally resampling to
+   * `dstW`x`dstH`. Pass the source size for both to get an unscaled conversion.
+   */
+  external fun bgrToArgb(bgr: ByteArray, w: Int, h: Int, dstW: Int, dstH: Int): IntArray
+
+  /**
+   * `YUV_420_888` planes (a MediaCodec decoder's output image) -> packed BGR bytes.
+   *
+   * `yRow`/`uRow`/`vRow` are each plane's row stride and `uPix`/`vPix` the chroma pixel
+   * stride — MediaCodec hands back arbitrary values for both, and semi-planar (NV12/NV21)
+   * output is a pixel stride of 2, so passing the raw `Image.Plane` values through
+   * unmodified is required; assuming tightly packed I420 renders as green and magenta.
+   */
+  external fun yuvToBgr(
+    y: ByteArray, yRow: Int,
+    u: ByteArray, uRow: Int, uPix: Int,
+    v: ByteArray, vRow: Int, vPix: Int,
+    w: Int, h: Int,
+  ): ByteArray
+
+  /**
+   * Rotates a packed BGR frame by 0/90/180/270 degrees clockwise.
+   *
+   * A portrait clip is stored as LANDSCAPE frames plus a rotation flag in the container —
+   * MediaExtractor exposes it as `MediaFormat.KEY_ROTATION` but MediaCodec does not apply
+   * it, so a decoded frame is on its side and the detector would find nothing. Rotate
+   * upright before [processFrame], then rotate back by `360 - degrees` before encoding so
+   * the output keeps the source's own orientation (the muxer still carries the rotation
+   * hint). 90/270 swap width and height — callers must resize everything downstream.
+   */
+  external fun rotateBgr(bgr: ByteArray, w: Int, h: Int, degrees: Int): ByteArray?
+
+  /**
+   * Packed BGR -> the ENCODER's own input planes, honouring its real row/pixel strides.
+   *
+   * `COLOR_FormatYUV420Flexible` does not mean planar I420 — on-device AVC encoders are
+   * commonly semi-planar (NV12), chroma interleaved with pixel stride 2. Writing planar
+   * I420 into that puts luma right and chroma wrong, which renders as a grey image with
+   * green/pink blobs — closer to right than obviously broken, which is what makes it easy
+   * to miss. `yBuf`/`uBuf`/`vBuf` must be the direct `ByteBuffer`s from the encoder's own
+   * `Image.getPlanes()` (`getInputImage()`), not caller-allocated buffers.
+   */
+  external fun bgrToImagePlanes(
+    bgr: ByteArray, w: Int, h: Int,
+    yBuf: java.nio.ByteBuffer, yRow: Int, yPix: Int,
+    uBuf: java.nio.ByteBuffer, uRow: Int, uPix: Int,
+    vBuf: java.nio.ByteBuffer, vRow: Int, vPix: Int,
+  ): Boolean
+}

package/lib/module/FacefusionPreview.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function FacefusionPreview(_props) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=FacefusionPreview.js.map

package/lib/module/FacefusionPreview.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FacefusionPreview","_props","Error"],"sourceRoot":"../../src","sources":["FacefusionPreview.tsx"],"mappings":";;AAIA,OAAO,SAASA,iBAAiBA,CAACC,MAA8B,EAAS;EACvE,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/FacefusionPreview.native.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { requireNativeComponent } from 'react-native';
+/**
+ * A live view of the frame [swapPhoto]/[swapVideo] just produced — the result the instant
+ * it's ready for a photo, and one frame at a time while a video swap is running.
+ *
+ * No prop carries pixels and none of this crosses the JS bridge: the native side
+ * (`PreviewSurfaceHolder.kt`) draws straight into this view's own `Surface` from whichever
+ * swap is running. Mount it, give it a size with `style`, and it shows whatever the native
+ * layer is currently drawing — there is nothing else to wire up. At most one swap runs at a
+ * time (`PipeGuard`), so at most one `<FacefusionPreview />` needs to be mounted to see it.
+ */
+export const FacefusionPreview = requireNativeComponent('FacefusionPreviewView');
+//# sourceMappingURL=FacefusionPreview.native.js.map

package/lib/module/FacefusionPreview.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["requireNativeComponent","FacefusionPreview"],"sourceRoot":"../../src","sources":["FacefusionPreview.native.tsx"],"mappings":";;AAAA,SAASA,sBAAsB,QAAQ,cAAc;AAKrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,iBAAiB,GAAGD,sBAAsB,CACrD,uBACF,CAAC","ignoreList":[]}

package/lib/module/NativeFacefusion.js

@@ -0,0 +1,53 @@
+"use strict";
+
+import { TurboModuleRegistry } 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.
+ */
+
+/**
+ * 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".
+ */
+
+/**
+ * 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++.
+ */
+
+/**
+ * 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.
+ */
+
+/** One face found in a source photo, in the image's own pixel coordinates. */
+
+/** The result of one still-photo swap. */
+
+/** The result of one video swap. */
+
+/** A tick of progress through a video swap. */
+
+/** A download in flight. Byte counts are across the whole set, not the current file. */
+
+export default TurboModuleRegistry.getEnforcing('Facefusion');
+//# sourceMappingURL=NativeFacefusion.js.map

package/lib/module/NativeFacefusion.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeFacefusion.ts"],"mappings":";;AAAA,SACEA,mBAAmB,QAGd,cAAc;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAoBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkBA;AACA;AACA;AACA;;AAoDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkBA;;AAsCA;;AAWA;;AAkBA;;AAWA;;AAsGA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,YAAY,CAAC","ignoreList":[]}

package/lib/module/detectSourceFaces.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function detectSourceFaces(_sourcePath, _options) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=detectSourceFaces.js.map

package/lib/module/detectSourceFaces.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["detectSourceFaces","_sourcePath","_options","Error"],"sourceRoot":"../../src","sources":["detectSourceFaces.tsx"],"mappings":";;AAEA,OAAO,SAASA,iBAAiBA,CAC/BC,WAAmB,EACnBC,QAAwB,EACC;EACzB,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/detectSourceFaces.native.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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, options) {
+  return Facefusion.detectSourceFaces(sourcePath, options);
+}
+//# sourceMappingURL=detectSourceFaces.native.js.map

package/lib/module/detectSourceFaces.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","detectSourceFaces","sourcePath","options"],"sourceRoot":"../../src","sources":["detectSourceFaces.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAG3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,UAAkB,EAClBC,OAAuB,EACE;EACzB,OAAOH,UAAU,CAACC,iBAAiB,CAACC,UAAU,EAAEC,OAAO,CAAC;AAC1D","ignoreList":[]}

package/lib/module/detectTargetFaces.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function detectTargetFaces(_targetPath, _options) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=detectTargetFaces.js.map

package/lib/module/detectTargetFaces.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["detectTargetFaces","_targetPath","_options","Error"],"sourceRoot":"../../src","sources":["detectTargetFaces.tsx"],"mappings":";;AAEA,OAAO,SAASA,iBAAiBA,CAC/BC,WAAmB,EACnBC,QAAwB,EACC;EACzB,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/detectTargetFaces.native.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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, options) {
+  return Facefusion.detectTargetFaces(targetPath, options);
+}
+//# sourceMappingURL=detectTargetFaces.native.js.map

package/lib/module/detectTargetFaces.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","detectTargetFaces","targetPath","options"],"sourceRoot":"../../src","sources":["detectTargetFaces.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAG3C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,UAAkB,EAClBC,OAAuB,EACE;EACzB,OAAOH,UAAU,CAACC,iBAAiB,CAACC,UAAU,EAAEC,OAAO,CAAC;AAC1D","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+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';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["probeDevice","getModelStatus","downloadModels","cancelModelDownload","onModelDownloadProgress","swapPhoto","swapVideo","cancelVideoSwap","onVideoSwapProgress","detectSourceFaces","detectTargetFaces","saveToGallery","FacefusionPreview"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,WAAW,QAAQ,eAAe;AAC3C,SACEC,cAAc,EACdC,cAAc,EACdC,mBAAmB,EACnBC,uBAAuB,QAClB,UAAU;AACjB,SAASC,SAAS,QAAQ,aAAa;AACvC,SAASC,SAAS,EAAEC,eAAe,EAAEC,mBAAmB,QAAQ,aAAa;AAC7E,SAASC,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,aAAa,QAAQ,iBAAiB;AAC/C,SAASC,iBAAiB,QAAQ,qBAAqB","ignoreList":[]}

package/lib/module/models.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const unsupported = () => new Error("'react-native-facefusion' is only supported on native platforms.");
+export function getModelStatus() {
+  throw unsupported();
+}
+export function downloadModels() {
+  throw unsupported();
+}
+export function cancelModelDownload() {
+  throw unsupported();
+}
+export function onModelDownloadProgress(_listener) {
+  throw unsupported();
+}
+//# sourceMappingURL=models.js.map

package/lib/module/models.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["unsupported","Error","getModelStatus","downloadModels","cancelModelDownload","onModelDownloadProgress","_listener"],"sourceRoot":"../../src","sources":["models.tsx"],"mappings":";;AAGA,MAAMA,WAAW,GAAGA,CAAA,KAClB,IAAIC,KAAK,CAAC,kEAAkE,CAAC;AAE/E,OAAO,SAASC,cAAcA,CAAA,EAAyB;EACrD,MAAMF,WAAW,CAAC,CAAC;AACrB;AAEA,OAAO,SAASG,cAAcA,CAAA,EAAyB;EACrD,MAAMH,WAAW,CAAC,CAAC;AACrB;AAEA,OAAO,SAASI,mBAAmBA,CAAA,EAAS;EAC1C,MAAMJ,WAAW,CAAC,CAAC;AACrB;AAEA,OAAO,SAASK,uBAAuBA,CACrCC,SAAoD,EACjC;EACnB,MAAMN,WAAW,CAAC,CAAC;AACrB","ignoreList":[]}

package/lib/module/models.native.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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() {
+  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() {
+  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() {
+  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) {
+  return Facefusion.onModelDownloadProgress(listener);
+}
+//# sourceMappingURL=models.native.js.map

package/lib/module/models.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","getModelStatus","downloadModels","cancelModelDownload","onModelDownloadProgress","listener"],"sourceRoot":"../../src","sources":["models.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAI3C;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAyB;EACrD,OAAOD,UAAU,CAACC,cAAc,CAAC,CAAC;AACpC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAyB;EACrD,OAAOF,UAAU,CAACE,cAAc,CAAC,CAAC;AACpC;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CAAA,EAAS;EAC1CH,UAAU,CAACG,mBAAmB,CAAC,CAAC;AAClC;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,uBAAuBA,CACrCC,QAAmD,EAChC;EACnB,OAAOL,UAAU,CAACI,uBAAuB,CAACC,QAAQ,CAAC;AACrD","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/probeDevice.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function probeDevice() {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=probeDevice.js.map

package/lib/module/probeDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["probeDevice","Error"],"sourceRoot":"../../src","sources":["probeDevice.tsx"],"mappings":";;AAEA,OAAO,SAASA,WAAWA,CAAA,EAA+B;EACxD,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/probeDevice.native.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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() {
+  return Facefusion.probeDevice();
+}
+//# sourceMappingURL=probeDevice.native.js.map

package/lib/module/probeDevice.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","probeDevice"],"sourceRoot":"../../src","sources":["probeDevice.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAG3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CAAA,EAA+B;EACxD,OAAOD,UAAU,CAACC,WAAW,CAAC,CAAC;AACjC","ignoreList":[]}

package/lib/module/saveToGallery.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function saveToGallery(_path, _mimeType, _displayName) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=saveToGallery.js.map

package/lib/module/saveToGallery.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["saveToGallery","_path","_mimeType","_displayName","Error"],"sourceRoot":"../../src","sources":["saveToGallery.tsx"],"mappings":";;AAAA,OAAO,SAASA,aAAaA,CAC3BC,KAAa,EACbC,SAAiB,EACjBC,YAAqB,EACJ;EACjB,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/saveToGallery.native.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+
+/**
+ * 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, mimeType, displayName) {
+  return Facefusion.saveToGallery(path, mimeType, displayName);
+}
+//# sourceMappingURL=saveToGallery.native.js.map

package/lib/module/saveToGallery.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","saveToGallery","path","mimeType","displayName"],"sourceRoot":"../../src","sources":["saveToGallery.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAC3BC,IAAY,EACZC,QAAgB,EAChBC,WAAoB,EACH;EACjB,OAAOJ,UAAU,CAACC,aAAa,CAACC,IAAI,EAAEC,QAAQ,EAAEC,WAAW,CAAC;AAC9D","ignoreList":[]}

package/lib/module/swapPhoto.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function swapPhoto(_sourcePath, _targetPath, _outputPath, _options) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=swapPhoto.js.map

package/lib/module/swapPhoto.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["swapPhoto","_sourcePath","_targetPath","_outputPath","_options","Error"],"sourceRoot":"../../src","sources":["swapPhoto.tsx"],"mappings":";;AAEA,OAAO,SAASA,SAASA,CACvBC,WAAmB,EACnBC,WAAmB,EACnBC,WAAmB,EACnBC,QAAsB,EACI;EAC1B,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/swapPhoto.native.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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, targetPath, outputPath, options) {
+  return Facefusion.swapPhoto(sourcePath, targetPath, outputPath, options);
+}
+//# sourceMappingURL=swapPhoto.native.js.map

package/lib/module/swapPhoto.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","swapPhoto","sourcePath","targetPath","outputPath","options"],"sourceRoot":"../../src","sources":["swapPhoto.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAG3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,SAASA,CACvBC,UAAkB,EAClBC,UAAkB,EAClBC,UAAkB,EAClBC,OAAqB,EACK;EAC1B,OAAOL,UAAU,CAACC,SAAS,CAACC,UAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,OAAO,CAAC;AAC1E","ignoreList":[]}

package/lib/module/swapVideo.js

@@ -0,0 +1,12 @@
+"use strict";
+
+export function swapVideo(_sourcePath, _targetPath, _outputPath, _options) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+export function cancelVideoSwap() {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+export function onVideoSwapProgress(_listener) {
+  throw new Error("'react-native-facefusion' is only supported on native platforms.");
+}
+//# sourceMappingURL=swapVideo.js.map

package/lib/module/swapVideo.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["swapVideo","_sourcePath","_targetPath","_outputPath","_options","Error","cancelVideoSwap","onVideoSwapProgress","_listener"],"sourceRoot":"../../src","sources":["swapVideo.tsx"],"mappings":";;AAOA,OAAO,SAASA,SAASA,CACvBC,WAAmB,EACnBC,WAAmB,EACnBC,WAAmB,EACnBC,QAAsB,EACI;EAC1B,MAAM,IAAIC,KAAK,CACb,kEACF,CAAC;AACH;AAEA,OAAO,SAASC,eAAeA,CAAA,EAAS;EACtC,MAAM,IAAID,KAAK,CACb,kEACF,CAAC;AACH;AAEA,OAAO,SAASE,mBAAmBA,CACjCC,SAAgD,EAC7B;EACnB,MAAM,IAAIH,KAAK,CACb,kEACF,CAAC;AACH","ignoreList":[]}

package/lib/module/swapVideo.native.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import Facefusion from "./NativeFacefusion.js";
+/**
+ * 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, targetPath, outputPath, options) {
+  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() {
+  Facefusion.cancelVideoSwap();
+}
+
+/**
+ * Subscribe to video swap progress. Returns the subscription — call `.remove()` on
+ * unmount.
+ */
+export function onVideoSwapProgress(listener) {
+  return Facefusion.onVideoSwapProgress(listener);
+}
+//# sourceMappingURL=swapVideo.native.js.map

package/lib/module/swapVideo.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Facefusion","swapVideo","sourcePath","targetPath","outputPath","options","cancelVideoSwap","onVideoSwapProgress","listener"],"sourceRoot":"../../src","sources":["swapVideo.native.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;AAQ3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,SAASA,CACvBC,UAAkB,EAClBC,UAAkB,EAClBC,UAAkB,EAClBC,OAAqB,EACK;EAC1B,OAAOL,UAAU,CAACC,SAAS,CAACC,UAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,OAAO,CAAC;AAC1E;;AAEA;AACA,OAAO,SAASC,eAAeA,CAAA,EAAS;EACtCN,UAAU,CAACM,eAAe,CAAC,CAAC;AAC9B;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CACjCC,QAA+C,EAC5B;EACnB,OAAOR,UAAU,CAACO,mBAAmB,CAACC,QAAQ,CAAC;AACjD","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,4 @@
+import type { ViewProps } from 'react-native';
+export type FacefusionPreviewProps = ViewProps;
+export declare function FacefusionPreview(_props: FacefusionPreviewProps): never;
+//# sourceMappingURL=FacefusionPreview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FacefusionPreview.d.ts","sourceRoot":"","sources":["../../../src/FacefusionPreview.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC;AAE/C,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,KAAK,CAIvE"}