@smileid/usesmileid_vision_face 12.0.0-beta01

package/ios/UseSmileIDVisionFaceModule/UseSmileIDVisionFaceModule.swift

@@ -0,0 +1,280 @@
+import ExpoModulesCore
+import UIKit
+import UseSmileIDBridge
+import UseSmileIDVisionFace
+import VisionCamera
+
+/// Expo Module bridging `UseSmileIDFaceSession` to the JS side.
+/// No ML logic lives here — the native session owns the full pipeline.
+/// Publishes the active session to `UseSmileIDVisionFaceSessionHolder` so
+/// the frame processor plugin can feed frames without crossing the JS thread.
+public class UseSmileIDVisionFaceModule: Module {
+  /// Wire-format key partners pass via `FaceConfig.analyzerFactoryKey`.
+  static let KEY = "vision-face"
+
+  /// Prevents double-registration of the frame processor plugin when
+  /// Expo Go / dev-client fast-refreshes the JS bundle and `OnCreate`
+  /// runs again in the same native process.
+  private static var isFrameProcessorRegistered = false
+
+  private var session: UseSmileIDFaceSession?
+
+  private static func freshSessionDirectory() -> URL {
+    // Application Support — not Caches — so the OS cannot evict
+    // in-flight capture frames between capture and submission under
+    // memory pressure. The root is flagged out of iCloud / iTunes
+    // backup so biometric frames never leave the device.
+    let support = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+      ?? FileManager.default.temporaryDirectory
+    var root = support.appendingPathComponent("UseSmileID", isDirectory: true)
+    try? FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+    var resourceValues = URLResourceValues()
+    resourceValues.isExcludedFromBackup = true
+    try? root.setResourceValues(resourceValues)
+    let dir = root.appendingPathComponent(String(Int(Date().timeIntervalSince1970 * 1000)), isDirectory: true)
+    try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+    return dir
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("UseSmileIDVisionFace")
+
+    OnCreate {
+      FaceAnalyzerFactoryRegistry.shared.register(key: Self.KEY) { @Sendable in
+        let analyzer = FaceDetectorAnalyzer.Factory().newInstance()!
+        return { @Sendable input, state in await analyzer.analyze(data: input, state: state) }
+      }
+
+      // Guard prevents double-registration on dev-client fast-refresh reloads.
+      if !Self.isFrameProcessorRegistered {
+        FrameProcessorPluginRegistry.addFrameProcessorPlugin("UseSmileIDVisionFaceFrameProcessor") { proxy, options in
+          UseSmileIDVisionFaceFrameProcessorPlugin(proxy: proxy, options: options)
+        }
+        Self.isFrameProcessorRegistered = true
+      }
+    }
+
+    AsyncFunction("configure") { (config: [String: Any?]) in
+      let key = (config["analyzerFactoryKey"] as? String) ?? Self.KEY
+      let analyzeFrame = try FaceAnalyzerFactoryRegistry.shared.newAnalyzeFrame(key: key)
+      let storage = config.toResizingFrameStorage(sessionDirectory: Self.freshSessionDirectory())
+      let newSession = UseSmileIDFaceSession(
+        analyzeFrame: analyzeFrame,
+        config: config.toFaceScanConfig(),
+        frameStorage: storage
+      )
+      self.session = newSession
+      // Publish the session through the holder's operation queue so the
+      // write is serialised with any concurrent scan on the FP thread.
+      UseSmileIDVisionFaceSessionHolder.shared.setSession(newSession)
+    }
+
+    AsyncFunction("reset") {
+      UseSmileIDVisionFaceSessionHolder.shared.reset()
+    }
+
+    AsyncFunction("flush") { (promise: Promise) in
+      // Hop onto a detached task so the Expo queue is not blocked while
+      // flush waits behind any in-flight scan on the operation queue.
+      Task.detached(priority: .userInitiated) {
+        do {
+          try UseSmileIDVisionFaceSessionHolder.shared.flush()
+          promise.resolve(nil)
+        } catch {
+          promise.reject("FLUSH_FAILED", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("close") {
+      UseSmileIDVisionFaceSessionHolder.shared.setSession(nil)
+      self.session = nil
+    }
+
+    OnDestroy {
+      UseSmileIDVisionFaceSessionHolder.shared.setSession(nil)
+      self.session = nil
+      FaceAnalyzerFactoryRegistry.shared.unregister(key: Self.KEY)
+    }
+  }
+}
+
+/// Adapt the partner-supplied JS object (a `[String: Any?]` after
+/// Expo Modules' bridge marshalling) into a `ResizingFrameStorage`
+/// configured with the token-resolved capture dimensions and JPEG
+/// quality values. All fields fall back to SDK defaults when absent.
+private extension Dictionary where Key == String, Value == Any? {
+  func toResizingFrameStorage(sessionDirectory: URL) -> ResizingFrameStorage {
+    // iOS quality is CGFloat 0..1; wire keys carry an integer 1..100.
+    let selfieTargetWidth = (self["selfieImageWidth"] as? NSNumber)?.intValue ?? 480
+    let selfieTargetHeight = (self["selfieImageHeight"] as? NSNumber)?.intValue ?? 640
+    let livenessTargetWidth = (self["livenessImageWidth"] as? NSNumber)?.intValue ?? 480
+    let livenessTargetHeight = (self["livenessImageHeight"] as? NSNumber)?.intValue ?? 640
+    let selfieQuality = ((self["selfieJpegQuality"] as? NSNumber)?.intValue).map { CGFloat($0) / 100.0 } ?? 0.95
+    let livenessQuality = ((self["livenessJpegQuality"] as? NSNumber)?.intValue).map { CGFloat($0) / 100.0 } ?? 0.80
+    return ResizingFrameStorage(
+      sessionDirectory: sessionDirectory,
+      documentSide: .front,
+      selfieTargetWidth: selfieTargetWidth,
+      selfieTargetHeight: selfieTargetHeight,
+      livenessTargetWidth: livenessTargetWidth,
+      livenessTargetHeight: livenessTargetHeight,
+      selfieQuality: selfieQuality,
+      livenessQuality: livenessQuality
+    )
+  }
+}
+
+/// Adapt the partner-supplied JS object (a `[String: Any?]` after
+/// Expo Modules' bridge marshalling) into the strongly-typed
+/// `FaceScanConfig` the native session expects. Every field is
+/// nullable on the wire; the fallbacks below are the production
+/// defaults.
+private extension Dictionary where Key == String, Value == Any? {
+  // JS numbers cross the Expo bridge as `NSNumber`; direct `Int`/`Double` casts
+  // silently fail when the bit pattern doesn't match — funnel through `NSNumber`.
+  func toFaceScanConfig() -> FaceScanConfig {
+    let base = FaceDetectorMode.from(token: self["faceDetectorMode"] as? String).config
+    return FaceScanConfig(
+      selfieCaptureTimeout: (self["selfieCaptureTimeout"] as? NSNumber)?.intValue ?? 100_000,
+      // Default yields 1 selfie + 7 liveness frames — the server requires
+      // `liveness_images >= 6`, so anything below 7 causes submission rejection.
+      numSamples: (self["numSamples"] as? NSNumber)?.intValue ?? 8,
+      sampleInterval: (self["sampleInterval"] as? NSNumber)?.intValue ?? 350,
+      stayInFoundDuration: (self["stayInFoundDuration"] as? NSNumber)?.intValue ?? 3_000,
+      faceDetectorConfig: FaceDetectorConfig(
+        minFillThreshold: (self["minFillThreshold"] as? NSNumber)?.floatValue ?? base.minFillThreshold,
+        maxFillThreshold: (self["maxFillThreshold"] as? NSNumber)?.floatValue ?? base.maxFillThreshold,
+        faceDetectorMinScore: (self["faceDetectorMinScore"] as? NSNumber)?.floatValue ?? base.faceDetectorMinScore,
+        centerToleranceX: (self["centerToleranceX"] as? NSNumber)?.floatValue ?? base.centerToleranceX,
+        centerToleranceY: (self["centerToleranceY"] as? NSNumber)?.floatValue ?? base.centerToleranceY,
+        minFaceBoundsThreshold: (self["minFaceBoundsThreshold"] as? NSNumber)?.floatValue ?? base.minFaceBoundsThreshold,
+        maxFaceBoundsThreshold: (self["maxFaceBoundsThreshold"] as? NSNumber)?.floatValue ?? base.maxFaceBoundsThreshold,
+        motionBlurMinIou: (self["motionBlurMinIou"] as? NSNumber)?.floatValue ?? base.motionBlurMinIou,
+        motionBlurMinDuration: (self["motionBlurMinDuration"] as? NSNumber)?.intValue ?? base.motionBlurMinDuration,
+        minTopPadding: (self["minTopPadding"] as? NSNumber)?.floatValue ?? base.minTopPadding,
+        minSmileProbability: (self["minSmileProbability"] as? NSNumber)?.floatValue ?? base.minSmileProbability
+      ),
+      enableEnhancedLiveness: (self["enableEnhancedLiveness"] as? NSNumber)?.boolValue ?? false
+    )
+  }
+}
+
+// Wire-format converters for the native session result types. Marked
+// `internal` (no access modifier) so both this file and
+// `UseSmileIDVisionFaceSessionHolder` — which builds the same wire dict
+// inside `scanAndDrain` — share one canonical set. The plugin file uses
+// the holder's `scanAndDrain` return value and never calls these directly.
+
+/// Keys must match `faceDetectorOutputSchema` field-for-field.
+extension UseSmileIDBridge.FaceDetectorOutput {
+  func toWireMap() -> [String: Any] {
+    let primaryFace = faces.max { $0.boundingBox.area < $1.boundingBox.area }
+    var map: [String: Any] = [
+      "faces": faces.map { $0.boundingBox.toWireMap() },
+      "brightness": Double(primaryFace?.brightness ?? 0)
+    ]
+    if let headPose = primaryFace?.headPose {
+      map["headPose"] = headPose.toWireMap()
+    }
+    if let smilingProbability = primaryFace?.smilingProbability {
+      map["smilingProbability"] = Double(smilingProbability)
+    }
+    return map
+  }
+}
+
+extension UseSmileIDBridge.BoundingBox {
+  func toWireMap() -> [String: Any] {
+    [
+      "left": Double(left),
+      "top": Double(top),
+      "width": Double(width),
+      "height": Double(height),
+      "score": Double(score)
+    ]
+  }
+}
+
+extension UseSmileIDBridge.HeadPoseResult {
+  func toWireMap() -> [String: Any] {
+    [
+      "yaw": Double(yaw),
+      "pitch": Double(pitch),
+      "roll": Double(roll)
+    ]
+  }
+}
+
+extension UseSmileIDBridge.CaptureReadyEvent {
+  func toWireMap() -> [String: Any] {
+    let kindString: String
+    let captureIndex: Int
+    let urlString: String
+    switch self {
+    case .selfieFrame(let url):
+      kindString = "selfie"
+      captureIndex = 0
+      urlString = url.absoluteString
+    case .livenessFrame(let index, let url):
+      kindString = "liveness"
+      captureIndex = index
+      urlString = url.absoluteString
+    case .documentFrame(let url):
+      kindString = "document"
+      captureIndex = 0
+      urlString = url.absoluteString
+    }
+    return [
+      "kind": kindString,
+      "captureIndex": captureIndex,
+      "url": urlString
+    ]
+  }
+}
+
+/// Map the native state-machine type into the wire-string the JS-side
+/// `scanStateTypeSchema` enum accepts. Keep in lock-step with the
+/// `ScanStateType` enum order so cross-platform analytics/dashboards
+/// see consistent values.
+extension UseSmileIDBridge.UseSmileIDScanState {
+  func toWireMap() -> [String: Any] {
+    let typeString: String
+    switch type {
+    case .initial: typeString = "initial"
+    case .found: typeString = "found"
+    case .satisfied: typeString = "satisfied"
+    case .unsatisfied: typeString = "unsatisfied"
+    case .finished: typeString = "finished"
+    case .timeout: typeString = "timeout"
+    case .headTurn: typeString = "headTurn"
+    }
+    let directionString: String?
+    switch currentDirection {
+    case .left: directionString = "left"
+    case .right: directionString = "right"
+    case .up: directionString = "up"
+    case nil: directionString = nil
+    }
+    var map: [String: Any] = ["type": typeString]
+    if let feedbackName {
+      map["feedback"] = feedbackName
+    }
+    if let unsatisfiedReason {
+      map["reason"] = unsatisfiedReason
+    }
+    if let direction = directionString {
+      map["currentDirection"] = direction
+    }
+    if let captureProgress {
+      map["captureProgress"] = Double(captureProgress)
+    }
+    // Latched pose-match flag for the ESS head turn — drives the grey→green
+    // direction arrow. Emit only while matched (omit ⇒ false on the JS side),
+    // matching the optional-field omission convention above.
+    if poseMatched {
+      map["poseMatched"] = true
+    }
+    return map
+  }
+}

package/ios/UseSmileIDVisionFaceModule/UseSmileIDVisionFaceSessionHolder.swift

@@ -0,0 +1,105 @@
+import Foundation
+import UIKit
+import UseSmileIDBridge
+import UseSmileIDVisionFace
+
+/// Process-wide holder for the active `UseSmileIDFaceSession`.
+///
+/// All session ops (scan+drain, reset, flush, setSession) serialise through one
+/// `operationQueue`. Deadlock invariant: `Task.detached` bodies inside
+/// `scanAndDrain`/`flush` run on the cooperative pool and never re-enter the holder.
+final class UseSmileIDVisionFaceSessionHolder {
+  static let shared = UseSmileIDVisionFaceSessionHolder()
+
+  /// Single serial queue serialising every session operation.
+  private let operationQueue = DispatchQueue(
+    label: "com.usesmileid.vision.face.session.operations",
+    qos: .userInitiated
+  )
+
+  private var session: UseSmileIDFaceSession?
+
+  private init() {}
+
+  /// Replace or clear the active session. Called from the Expo module's
+  /// `configure`, `close`, and `OnDestroy` paths.
+  func setSession(_ newSession: UseSmileIDFaceSession?) {
+    operationQueue.sync {
+      session = newSession
+    }
+  }
+
+  /// Run `session.reset()` serialised with any in-flight scan. Called from
+  /// the Expo module's `reset` AsyncFunction.
+  func reset() {
+    operationQueue.sync {
+      session?.reset()
+    }
+  }
+
+  /// Flush the active session, blocking the caller until completion.
+  /// Semaphore wait runs inside `operationQueue.sync` — blocks concurrent
+  /// scans for the flush duration. Task body runs on cooperative pool; no deadlock.
+  func flush() throws {
+    var flushError: Error?
+    operationQueue.sync {
+      guard let currentSession = session else {
+        return
+      }
+      let errorBox = FlushErrorBox()
+      let semaphore = DispatchSemaphore(value: 0)
+      Task.detached(priority: .userInitiated) {
+        do {
+          try await currentSession.flush()
+        } catch {
+          errorBox.error = error
+        }
+        semaphore.signal()
+      }
+      semaphore.wait()
+      flushError = errorBox.error
+    }
+    if let error = flushError {
+      throw error
+    }
+  }
+
+  /// Run `session.scan` + `drainCaptureReadyEvents` as one atomic unit, blocking the
+  /// caller. Returns `nil` when no session is configured; never throws.
+  func scanAndDrain(image: UIImage, rotation: Int) -> [String: Any]? {
+    var result: [String: Any]?
+    operationQueue.sync {
+      guard let currentSession = session else {
+        return
+      }
+      let resultBox = ScanResultBox()
+      let semaphore = DispatchSemaphore(value: 0)
+      Task.detached(priority: .userInitiated) {
+        let scanResult = await currentSession.scan(image: image, rotation: rotation)
+        let nativeOutput = scanResult.output as? UseSmileIDBridge.FaceDetectorOutput
+        let state = scanResult.state
+        let events = currentSession.drainCaptureReadyEvents()
+        resultBox.value = [
+          "output": nativeOutput?.toWireMap() ?? (["faces": [], "brightness": 0.0] as [String: Any]),
+          "state": state.toWireMap(),
+          "capturedEvents": events.map { $0.toWireMap() }
+        ]
+        semaphore.signal()
+      }
+      semaphore.wait()
+      result = resultBox.value
+    }
+    return result
+  }
+}
+
+/// Shuttles a scan result from the cooperative-pool Task to the semaphore-blocked caller.
+private final class ScanResultBox: @unchecked Sendable {
+  var value: [String: Any] = [:]
+}
+
+/// Reference-type container used to propagate a flush error across the
+/// same semaphore boundary as `ScanResultBox`.
+private final class FlushErrorBox: @unchecked Sendable {
+  var error: Error?
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@smileid/usesmileid_vision_face",
+  "version": "12.0.0-beta01",
+  "description": "UseSmileID v12 — Apple Vision face provider (iOS-only). Thin Expo Module shim around the existing Swift Package `UseSmileIDVisionFace`.",
+  "homepage": "https://usesmileid.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smileidentity/react-native-expo.git",
+    "directory": "usesmileid_vision_face"
+  },
+  "bugs": {
+    "url": "https://github.com/smileidentity/react-native-expo/issues"
+  },
+  "license": "MIT",
+  "author": "Smile Identity <hello@usesmileid.com>",
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-module",
+    "biometric",
+    "kyc",
+    "identity-verification",
+    "face-detection",
+    "document-capture",
+    "smile-id"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./app.plugin.js": "./app.plugin.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "ios",
+    "plugin/build",
+    "plugin/src",
+    "plugin/tsconfig.json",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@smileid/usesmileid_bridge": "12.0.0-beta01",
+    "@smileid/usesmileid_platform_interface": "12.0.0-beta01"
+  },
+  "peerDependencies": {
+    "expo": ">=56.0.0",
+    "expo-modules-core": ">=56.0.0",
+    "react-native": ">=0.83.0"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": "^56.0.8",
+    "@types/node": "^25.9.1",
+    "expo-modules-core": "^56.0.15",
+    "react-native": "^0.85.3",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "scripts": {
+    "build": "pnpm run build:lib && pnpm run build:plugin",
+    "build:lib": "tsc -p tsconfig.json",
+    "build:plugin": "tsc -p plugin/tsconfig.json",
+    "typecheck": "tsc -b && tsc -p plugin/tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist plugin/build .turbo coverage"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+declare const withVisionFaceSpm: ConfigPlugin;
+export default withVisionFaceSpm;

package/plugin/build/index.js

@@ -0,0 +1,115 @@
+"use strict";
+// Expo config plugin that wires the Smile Identity Swift Package
+// (`https://github.com/smileidentity/ios-spm`) into both:
+//   1. The consuming app's Xcode project — so the .xcframeworks ship
+//      and embed in the final .app bundle.
+//   2. The autogenerated Pods.xcodeproj at `pod install` time — so
+//      the Expo Module bridge (`UseSmileIDVisionFaceExpo`) compiles
+//      with `import UseSmileIDVisionFace` / `import UseSmileIDBridge`.
+//
+// Why a plugin: `expo-modules-autolinking@55.0.x`'s
+// `RawModuleConfigApple` schema has no `dependencies` field, so the
+// `apple.dependencies` block in `expo-module.config.json` is silently
+// ignored. Without this plugin, neither the bridge nor the host app
+// know about the SPM package.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const podfile_1 = require("./lib/podfile");
+const spm_1 = require("./lib/spm");
+// Pinned to the exact `12.0.0-beta01` release tag — `from: 12.0.0`
+// would not resolve because `ios-spm` publishes pre-release tags (e.g.
+// `12.0.0-beta01`), and SPM excludes pre-release tags from open-ended
+// major-version requirements.
+const SMILE_ID_PACKAGE = {
+    url: "https://github.com/smileidentity/ios-spm",
+    requirement: {
+        kind: "exactVersion",
+        version: "12.0.0-beta01",
+    },
+};
+const POD_TARGET = "UseSmileIDVisionFaceExpo";
+// `UseSmileIDBridge` is also listed explicitly even though the Vision
+// library product wraps it as a transitive target — empirically this
+// is what makes `import UseSmileIDBridge` resolve in the bridge under
+// SPM-via-CocoaPods. A cleaner config that drops the redundant
+// listing is plausible (the SPM Package.swift declares
+// `targets: ["UseSmileIDVisionFace", "UseSmileIDBridge"]` for the Vision
+// library product) but unverified, and the duplicate produces only a
+// benign "Conflicting parseable interfaces" warning at link time.
+const SPM_PRODUCTS = ["UseSmileIDVisionFace", "UseSmileIDBridge"];
+const PODFILE_MARKER = "usesmileid_vision_face";
+const withVisionFaceSpm = (config) => {
+    // 1. Add the package + products to the host app's Xcode project so
+    //    Xcode resolves the binary xcframeworks and embeds them in the
+    //    .app at link time.
+    config = (0, config_plugins_1.withXcodeProject)(config, (config) => {
+        const appTarget = config.modRequest.projectName;
+        if (!appTarget) {
+            throw new Error("[usesmileid_vision_face] Unable to resolve host app native target name from Expo config.");
+        }
+        (0, spm_1.linkSpmPackage)(config.modResults, SMILE_ID_PACKAGE, {
+            targetName: appTarget,
+            products: [...SPM_PRODUCTS],
+        });
+        return config;
+    });
+    // 2. Inject a Ruby block into the Podfile's post_install hook that
+    //    re-applies the same wiring to Pods.xcodeproj when CocoaPods
+    //    materializes it. The bridge pod target needs the products
+    //    visible at compile time; the host-app step alone isn't enough.
+    config = (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        (config) => {
+            const podfilePath = path.join(config.modRequest.platformProjectRoot, "Podfile");
+            const original = fs.readFileSync(podfilePath, "utf-8");
+            const next = (0, podfile_1.injectPodfileSpmBlock)(original, {
+                marker: PODFILE_MARKER,
+                package: SMILE_ID_PACKAGE,
+                podTarget: POD_TARGET,
+                products: [...SPM_PRODUCTS],
+            });
+            if (next !== original) {
+                fs.writeFileSync(podfilePath, next);
+            }
+            return config;
+        },
+    ]);
+    return config;
+};
+exports.default = withVisionFaceSpm;
+//# sourceMappingURL=index.js.map

package/plugin/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,iEAAiE;AACjE,0DAA0D;AAC1D,qEAAqE;AACrE,2CAA2C;AAC3C,mEAAmE;AACnE,oEAAoE;AACpE,uEAAuE;AACvE,EAAE;AACF,oDAAoD;AACpD,oEAAoE;AACpE,sEAAsE;AACtE,oEAAoE;AACpE,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9B,yDAI8B;AAC9B,uCAAyB;AACzB,2CAA6B;AAE7B,2CAAsD;AACtD,mCAAuD;AAEvD,mEAAmE;AACnE,uEAAuE;AACvE,sEAAsE;AACtE,8BAA8B;AAC9B,MAAM,gBAAgB,GAAe;IACnC,GAAG,EAAE,0CAA0C;IAC/C,WAAW,EAAE;QACX,IAAI,EAAE,cAAc;QACpB,OAAO,EAAE,eAAe;KACzB;CACF,CAAC;AAEF,MAAM,UAAU,GAAG,0BAA0B,CAAC;AAC9C,sEAAsE;AACtE,qEAAqE;AACrE,sEAAsE;AACtE,+DAA+D;AAC/D,uDAAuD;AACvD,yEAAyE;AACzE,qEAAqE;AACrE,kEAAkE;AAClE,MAAM,YAAY,GAAG,CAAC,sBAAsB,EAAE,kBAAkB,CAAU,CAAC;AAC3E,MAAM,cAAc,GAAG,wBAAwB,CAAC;AAEhD,MAAM,iBAAiB,GAAiB,CAAC,MAAM,EAAE,EAAE;IACjD,mEAAmE;IACnE,mEAAmE;IACnE,wBAAwB;IACxB,MAAM,GAAG,IAAA,iCAAgB,EAAC,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE;QAC3C,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC;QAChD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CACb,0FAA0F,CAC3F,CAAC;QACJ,CAAC;QACD,IAAA,oBAAc,EAAC,MAAM,CAAC,UAAU,EAAE,gBAAgB,EAAE;YAClD,UAAU,EAAE,SAAS;YACrB,QAAQ,EAAE,CAAC,GAAG,YAAY,CAAC;SAC5B,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CAAC;IAEH,mEAAmE;IACnE,iEAAiE;IACjE,+DAA+D;IAC/D,oEAAoE;IACpE,MAAM,GAAG,IAAA,iCAAgB,EAAC,MAAM,EAAE;QAChC,KAAK;QACL,CAAC,MAAM,EAAE,EAAE;YACT,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,MAAM,CAAC,UAAU,CAAC,mBAAmB,EACrC,SAAS,CACV,CAAC;YACF,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YACvD,MAAM,IAAI,GAAG,IAAA,+BAAqB,EAAC,QAAQ,EAAE;gBAC3C,MAAM,EAAE,cAAc;gBACtB,OAAO,EAAE,gBAAgB;gBACzB,SAAS,EAAE,UAAU;gBACrB,QAAQ,EAAE,CAAC,GAAG,YAAY,CAAC;aAC5B,CAAC,CAAC;YACH,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;KACF,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,kBAAe,iBAAiB,CAAC"}

package/plugin/build/lib/podfile.d.ts

@@ -0,0 +1,17 @@
+import type { SpmPackage } from "./spm";
+export interface PodfileLinkOptions {
+    /** Marker key — distinct per bridge so each plugin owns its own block. */
+    marker: string;
+    package: SpmPackage;
+    /** Pod target name (e.g. `UseSmileIDVisionFaceExpo`). */
+    podTarget: string;
+    /** SPM library product names to link to the pod target. */
+    products: string[];
+}
+/**
+ * Idempotently injects an SPM-linking Ruby block into the Podfile's
+ * top-level `post_install` block. Re-running on an already-injected
+ * Podfile rewrites the same marker block in place (so version /
+ * product changes flow through cleanly on the next prebuild).
+ */
+export declare function injectPodfileSpmBlock(podfile: string, options: PodfileLinkOptions): string;