@mleonard9/vin-scanner 0.2.5 → 0.2.6

package/README.md

@@ -102,8 +102,15 @@ type VinScannerEvent = {
 | `options.detection.preferBarcode` | boolean | Prefer barcode hits when selecting the best VIN | `true` |
 | `options.detection.validateChecksum` | boolean | Run VIN checksum validation | `true` |
 | `options.detection.emitDuplicates` | boolean | Emit unchanged payloads every frame | `false` for `'best'`, `true` for `'all'` |
+| `options.detection.maxFrameRate` | number | Max FPS budget for frame processing (drops surplus frames to avoid blocking) | `30` |
 | `options.onResult` | `(result, event) => void` | Convenience callback when using `useVinScanner`; receives either the best candidate, all candidates, or `null` plus the raw event | `undefined` |
 
+### Advanced frame-processor controls
+
+- **Per-frame plugin overrides:** both barcode and text frame processor plugins accept per-frame arguments, so you can dynamically change ML Kit barcode formats or text recognition language without reinitializing the plugin. Call `barcodeScanner.scanBarcodes(frame, { 'pdf-417': true })` or `textScanner.scanText(frame, { language: 'japanese' })` inside your worklet to override the resolved defaults for a single frame.
+- **Shared bounding boxes:** native plugins now stream bounding box coordinates via zero-copy shared arrays, minimizing JSI serialization. The hook translates these buffers into the familiar `BoundingBox` structures before running VIN heuristics, so no API change is required.
+- **Orientation-safe processing:** the native plugins forward VisionCamera’s frame orientation metadata directly into ML Kit as recommended in the [VisionCamera orientation guide](https://react-native-vision-camera.com/docs/guides/orientation), ensuring portrait VIN scans stay upright.
+
 ### Hook-only usage
 
 If you prefer to configure `react-native-vision-camera` yourself, grab the frame processor from the hook:

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerModule.kt

@@ -1,8 +1,6 @@
 package com.visioncamerabarcodescanner
 
 import android.media.Image
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
 import com.google.android.gms.tasks.Task
 import com.google.android.gms.tasks.Tasks
 import com.google.mlkit.vision.barcode.BarcodeScannerOptions
@@ -25,69 +23,101 @@ import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_EAN_13
 import com.google.mlkit.vision.common.InputImage
 import com.mrousavy.camera.frameprocessors.Frame
 import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.SharedArray
 import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.nio.ByteOrder
+import java.util.HashMap
 
-class VisionCameraBarcodeScannerModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
+private const val BOX_STRIDE = 6
 
-  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
-    try {
-     val optionsBuilder = BarcodeScannerOptions.Builder()
-      if (arguments?.get("code-128").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_128)
-      else if (arguments?.get("code-39").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_39)
-      else if (arguments?.get("code-93").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_93)
-      else if (arguments?.get("codabar").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODABAR)
-      else if (arguments?.get("ean-13").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_13)
-      else if (arguments?.get("ean-8").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_8)
-      else if (arguments?.get("itf").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ITF)
-      else if (arguments?.get("upc-e").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_E)
-      else if (arguments?.get("upc-a").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_A)
-      else if (arguments?.get("qr").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_QR_CODE)
-      else if (arguments?.get("pdf-417").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_PDF417)
-      else if (arguments?.get("aztec").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_AZTEC)
-      else if (arguments?.get("data-matrix").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_DATA_MATRIX)
-      else if (arguments?.get("all").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
-      else optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+class VisionCameraBarcodeScannerModule(
+  private val proxy : VisionCameraProxy,
+  options: Map<String, Any>?
+): FrameProcessorPlugin() {
+
+  private val initializerOptions: Map<String, Any> = options ?: emptyMap()
+
+  private fun mergedOptions(overrides: Map<String, Any>?): Map<String, Any> {
+    if (overrides == null || overrides.isEmpty()) {
+      return initializerOptions
+    }
+    val merged = HashMap(initializerOptions)
+    merged.putAll(overrides)
+    return merged
+  }
+
+  private fun buildScannerOptions(effective: Map<String, Any>): BarcodeScannerOptions {
+    val builder = BarcodeScannerOptions.Builder()
+    when {
+      effective["code-128"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_128)
+      effective["code-39"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_39)
+      effective["code-93"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_93)
+      effective["codabar"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODABAR)
+      effective["ean-13"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_EAN_13)
+      effective["ean-8"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_EAN_8)
+      effective["itf"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_ITF)
+      effective["upc-e"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_UPC_E)
+      effective["upc-a"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_UPC_A)
+      effective["qr"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_QR_CODE)
+      effective["pdf-417"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_PDF417)
+      effective["aztec"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_AZTEC)
+      effective["data-matrix"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_DATA_MATRIX)
+      effective["all"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+      else -> builder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+    }
+    return builder.build()
+  }
 
-      val scanner = BarcodeScanning.getClient(optionsBuilder.build())
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
+    return try {
+      val options = mergedOptions(arguments)
+      val scanner = BarcodeScanning.getClient(buildScannerOptions(options))
       val mediaImage: Image = frame.image
       val image = InputImage.fromMediaImage(mediaImage, frame.imageProxy.imageInfo.rotationDegrees)
       val task: Task<List<Barcode>> = scanner.process(image)
       val barcodes: List<Barcode> = Tasks.await(task)
-      val array = WritableNativeArray()
-      for (barcode in barcodes) {
-        val map = WritableNativeMap()
-        val bounds = barcode.boundingBox
-        if (bounds != null) {
-          map.putInt("width",bounds.width())
-          map.putInt("height",bounds.height())
-          map.putInt("top",bounds.top)
-          map.putInt("bottom",bounds.bottom)
-          map.putInt("left",bounds.left)
-          map.putInt("right",bounds.right)
-        }
-        val rawValue = barcode.rawValue
-        map.putString("rawValue",rawValue)
-        val valueType = barcode.valueType
-        when (valueType) {
-          Barcode.TYPE_WIFI -> {
-            val ssid = barcode.wifi!!.ssid
-            map.putString("ssid",ssid)
-            val password = barcode.wifi!!.password
-            map.putString("password",password)
-          }
-          Barcode.TYPE_URL -> {
-            val title = barcode.url!!.title
-            map.putString("title",title)
-            val url = barcode.url!!.url
-            map.putString("url",url)
+
+      val detections = ArrayList<Map<String, Any?>>()
+      val sharedArray =
+        if (barcodes.isNotEmpty()) SharedArray(proxy, barcodes.size * BOX_STRIDE * java.lang.Float.BYTES)
+        else null
+      val floatBuffer = sharedArray?.byteBuffer
+        ?.order(ByteOrder.nativeOrder())
+        ?.asFloatBuffer()
+
+      barcodes.forEachIndexed { index, barcode ->
+        val detection = HashMap<String, Any?>()
+        detection["rawValue"] = barcode.rawValue
+        detection["displayValue"] = barcode.displayValue
+        detection["format"] = barcode.format
+        detection["boxIndex"] = index
+        floatBuffer?.let { buffer ->
+          val bounds = barcode.boundingBox
+          val floatIndex = index * BOX_STRIDE
+          if (bounds != null) {
+            buffer.put(floatIndex, bounds.top.toFloat())
+            buffer.put(floatIndex + 1, bounds.bottom.toFloat())
+            buffer.put(floatIndex + 2, bounds.left.toFloat())
+            buffer.put(floatIndex + 3, bounds.right.toFloat())
+            buffer.put(floatIndex + 4, bounds.width().toFloat())
+            buffer.put(floatIndex + 5, bounds.height().toFloat())
+          } else {
+            for (offset in 0 until BOX_STRIDE) {
+              buffer.put(floatIndex + offset, -1f)
+            }
           }
         }
-        array.pushMap(map)
+        detections.add(detection)
+      }
+
+      val response = HashMap<String, Any?>()
+      response["detections"] = detections
+      if (sharedArray != null) {
+        response["boxes"] = sharedArray
       }
-      return array.toArrayList()
+      response
     } catch (e: Exception) {
-       throw  Exception("Error processing barcode scanner: $e ")
+      throw Exception("Error processing barcode scanner: $e")
     }
   }
-
 }

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerPackage.kt

@@ -10,10 +10,10 @@ import com.visioncameratextrecognition.VisionCameraTextRecognitionModule
 class VisionCameraBarcodeScannerPackage : ReactPackage {
   companion object {
     init {
-      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanBarcodes") {proxy,options ->
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("vinScannerBarcode") {proxy,options ->
         VisionCameraBarcodeScannerModule(proxy,options)
       }
-      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanText") { proxy, options ->
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("vinScannerText") { proxy, options ->
         VisionCameraTextRecognitionModule(proxy, options)
       }
     }

package/android/src/main/java/com/visioncameratextrecognition/VisionCameraTextRecognitionModule.kt

@@ -1,8 +1,6 @@
 package com.visioncameratextrecognition
 
 import android.media.Image
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
 import com.google.android.gms.tasks.Task
 import com.google.android.gms.tasks.Tasks
 import com.google.mlkit.vision.common.InputImage
@@ -14,114 +12,149 @@ import com.google.mlkit.vision.text.devanagari.DevanagariTextRecognizerOptions
 import com.google.mlkit.vision.text.japanese.JapaneseTextRecognizerOptions
 import com.google.mlkit.vision.text.korean.KoreanTextRecognizerOptions
 import com.google.mlkit.vision.text.latin.TextRecognizerOptions
-import com.mrousavy.camera.frameprocessor.Frame
-import com.mrousavy.camera.frameprocessor.FrameProcessorPlugin
-import com.mrousavy.camera.frameprocessor.VisionCameraProxy
-import com.mrousavy.camera.types.Orientation
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.SharedArray
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.nio.ByteOrder
+import java.util.HashMap
 import java.util.ArrayList
 
+private const val TEXT_BOX_STRIDE = 12
 
-class VisionCameraTextRecognitionModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
-  private var recognizer: TextRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
-  private var language = options?.get("language").toString()
+class VisionCameraTextRecognitionModule(
+  private val proxy : VisionCameraProxy,
+  options: Map<String, Any>?
+): FrameProcessorPlugin() {
+  private var language = options?.get("language").toString().ifEmpty { "latin" }
+  private val recognizers = mutableMapOf<String, TextRecognizer>()
 
-  init {
-    recognizer = when (language) {
-      "latin" -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
-      "chinese" -> TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())
-      "devanagari" -> TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())
-      "japanese" -> TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())
-      "korean" -> TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
-      else -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+  private fun recognizerFor(languageCode: String): TextRecognizer {
+    return recognizers.getOrPut(languageCode) {
+      when (languageCode) {
+        "latin" -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+        "chinese" -> TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())
+        "devanagari" -> TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())
+        "japanese" -> TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())
+        "korean" -> TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
+        else -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+      }
     }
   }
-  override fun callback(frame: Frame, arguments: Map<String, Any>?): ArrayList<Any> {
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
       try {
         val mediaImage: Image = frame.image
-        val orientation : Orientation = frame.orientation
-        val array = WritableNativeArray()
-        val image = InputImage.fromMediaImage(mediaImage, orientation.toDegrees())
+        val rotationDegrees = frame.imageProxy.imageInfo.rotationDegrees
+        val requestedLanguage = arguments?.get("language")?.toString()?.ifEmpty { null }
+        val effectiveLanguage = requestedLanguage ?: language
+        val recognizer = recognizerFor(effectiveLanguage)
+        val image = InputImage.fromMediaImage(mediaImage, rotationDegrees)
         val task: Task<Text> = recognizer.process(image)
         val result: Text? = Tasks.await(task)
-          val resultText = result?.text
-          for (block in result?.textBlocks!!) {
-            val map = WritableNativeMap()
-            map.putString("resultText",resultText)
-            val blockText = block.text
-            map.putString("blockText",blockText)
-            val blockCornerPoints = block.cornerPoints?.size
-            if (blockCornerPoints != null) {
-              map.putInt("size",blockCornerPoints)
-            }
-            val blockFrameBottom = block.boundingBox?.bottom
-            val blockFrameTop = block.boundingBox?.top
-            val blockFrameLeft = block.boundingBox?.left
-            val blockFrameRight = block.boundingBox?.right
-            if (blockFrameBottom != null) {
-              map.putInt("blockFrameBottom",blockFrameBottom)
-            }
-            if (blockFrameLeft != null) {
-              map.putInt("blockFrameLeft",blockFrameLeft)
-            }
-            if (blockFrameTop != null) {
-              map.putInt("blockFrameTop",blockFrameTop)
+        val resultText = result?.text
+        val detections = ArrayList<Map<String, Any?>>()
+        val boxValues = ArrayList<FloatArray>()
+
+        result?.textBlocks?.forEach { block ->
+          val blockBounds = block.boundingBox
+          if (block.lines.isEmpty()) {
+            val detection = HashMap<String, Any?>()
+            detection["resultText"] = resultText
+            detection["blockText"] = block.text
+            detection["boxIndex"] = boxValues.size
+            detections.add(detection)
+            boxValues.add(
+              floatArrayOf(
+                blockBounds?.top?.toFloat() ?: -1f,
+                blockBounds?.bottom?.toFloat() ?: -1f,
+                blockBounds?.left?.toFloat() ?: -1f,
+                blockBounds?.right?.toFloat() ?: -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+              )
+            )
+          }
+          block.lines.forEach { line ->
+            if (line.elements.isEmpty()) {
+              val detection = HashMap<String, Any?>()
+              detection["resultText"] = resultText
+              detection["blockText"] = block.text
+              detection["lineText"] = line.text
+              detection["boxIndex"] = boxValues.size
+              detections.add(detection)
+              boxValues.add(
+                floatArrayOf(
+                  blockBounds?.top?.toFloat() ?: -1f,
+                  blockBounds?.bottom?.toFloat() ?: -1f,
+                  blockBounds?.left?.toFloat() ?: -1f,
+                  blockBounds?.right?.toFloat() ?: -1f,
+                  line.boundingBox?.top?.toFloat() ?: -1f,
+                  line.boundingBox?.bottom?.toFloat() ?: -1f,
+                  line.boundingBox?.left?.toFloat() ?: -1f,
+                  line.boundingBox?.right?.toFloat() ?: -1f,
+                  -1f,
+                  -1f,
+                  -1f,
+                  -1f,
+                )
+              )
             }
-            if (blockFrameRight != null) {
-              map.putInt("blockFrameRight",blockFrameRight)
+            line.elements.forEach { element ->
+              val detection = HashMap<String, Any?>()
+              detection["resultText"] = resultText
+              detection["blockText"] = block.text
+              detection["lineText"] = line.text
+              detection["elementText"] = element.text
+              detection["boxIndex"] = boxValues.size
+              detections.add(detection)
+              boxValues.add(
+                floatArrayOf(
+                  blockBounds?.top?.toFloat() ?: -1f,
+                  blockBounds?.bottom?.toFloat() ?: -1f,
+                  blockBounds?.left?.toFloat() ?: -1f,
+                  blockBounds?.right?.toFloat() ?: -1f,
+                  line.boundingBox?.top?.toFloat() ?: -1f,
+                  line.boundingBox?.bottom?.toFloat() ?: -1f,
+                  line.boundingBox?.left?.toFloat() ?: -1f,
+                  line.boundingBox?.right?.toFloat() ?: -1f,
+                  element.boundingBox?.top?.toFloat() ?: -1f,
+                  element.boundingBox?.bottom?.toFloat() ?: -1f,
+                  element.boundingBox?.left?.toFloat() ?: -1f,
+                  element.boundingBox?.right?.toFloat() ?: -1f,
+                )
+              )
             }
-            for (line in block.lines) {
-              val lineText = line.text
-              map.putString("lineText",lineText)
-              val lineCornerPoints = line.cornerPoints?.size
-              if (lineCornerPoints != null) {
-                map.putInt("size",lineCornerPoints)
-              }
-              val lineFrameBottom = line.boundingBox?.bottom
-              val lineFrameTop = line.boundingBox?.top
-              val lineFrameLeft = line.boundingBox?.left
-              val lineFrameRight = line.boundingBox?.right
-              if (lineFrameBottom != null) {
-                map.putInt("lineFrameBottom",lineFrameBottom)
-              }
-              if (lineFrameLeft != null) {
-                map.putInt("lineFrameLeft",lineFrameLeft)
-              }
-              if (lineFrameTop != null) {
-                map.putInt("lineFrameTop",lineFrameTop)
-              }
-              if (lineFrameRight != null) {
-                map.putInt("lineFrameRight",lineFrameRight)
-              }
-              for (element in line.elements) {
-                val elementText = element.text
-                map.putString("elementText",elementText)
-
-                val elementCornerPoints = line.cornerPoints?.size
-                if (elementCornerPoints != null) {
-                  map.putInt("size",elementCornerPoints)
-                }
-                val elementFrameBottom = line.boundingBox?.bottom
-                val elementFrameTop = line.boundingBox?.top
-                val elementFrameLeft = line.boundingBox?.left
-                val elementFrameRight = line.boundingBox?.right
-                if (elementFrameBottom != null) {
-                  map.putInt("elementFrameBottom",elementFrameBottom)
-                }
-                if (elementFrameLeft != null) {
-                  map.putInt("elementFrameLeft",elementFrameLeft)
-                }
-                if (elementFrameTop != null) {
-                  map.putInt("elementFrameTop",elementFrameTop)
-                }
-                if (elementFrameRight != null) {
-                  map.putInt("elementFrameRight",elementFrameRight)
-                }
-              }
-              array.pushMap(map)
+          }
+        }
 
+        val sharedArray =
+          if (boxValues.isNotEmpty()) SharedArray(proxy, boxValues.size * TEXT_BOX_STRIDE * java.lang.Float.BYTES)
+          else null
+        val floatBuffer = sharedArray?.byteBuffer
+          ?.order(ByteOrder.nativeOrder())
+          ?.asFloatBuffer()
+        floatBuffer?.let { buffer ->
+          boxValues.forEachIndexed { index, values ->
+            val floatIndex = index * TEXT_BOX_STRIDE
+            for (offset in 0 until TEXT_BOX_STRIDE) {
+              buffer.put(floatIndex + offset, values[offset])
             }
           }
-        return array.toArrayList()
+        }
+
+        val response = HashMap<String, Any?>()
+        response["detections"] = detections
+        if (sharedArray != null) {
+          response["boxes"] = sharedArray
+        }
+        return response
       } catch (e: Exception) {
        throw  Exception("Error processing text recognition: $e ")
       }

package/ios/VisionCameraBarcodeScanner.m

@@ -3,12 +3,14 @@
 #import <VisionCamera/FrameProcessorPlugin.h>
 #import <VisionCamera/FrameProcessorPluginRegistry.h>
 #import <VisionCamera/Frame.h>
+#import <VisionCamera/SharedArray.h>
 #import <React/RCTBridgeModule.h>
 @import MLKitVision;
 
 @interface VisionCameraBarcodeScannerPlugin : FrameProcessorPlugin
 
 @property(nonatomic, strong) NSDictionary *configuration;
+@property(nonatomic, strong) VisionCameraProxyHolder *proxyHolder;
 
 @end
 
@@ -28,13 +30,18 @@
     self = [super initWithProxy:proxy withOptions:options];
     if (self) {
         _configuration = options ?: @{};
+        _proxyHolder = proxy;
     }
     return self;
 }
 
 - (id _Nullable)callback:(Frame* _Nonnull)frame
            withArguments:(NSDictionary* _Nullable)arguments {
-    NSDictionary *config = arguments ?: self.configuration ?: @{};
+    NSMutableDictionary *config = [self.configuration mutableCopy];
+    if (!config) {
+        config = [NSMutableDictionary dictionary];
+    }
+    [config addEntriesFromDictionary:arguments ?: @{}];
     MLKBarcodeFormat formatMask = [self formatMaskFromConfig:config];
     options = [[MLKBarcodeScannerOptions alloc] initWithFormats:formatMask];
 
@@ -42,9 +49,12 @@
 
     CMSampleBufferRef buffer = frame.buffer;
     UIImageOrientation orientation = frame.orientation;
+    // VisionCamera already normalizes orientation per https://react-native-vision-camera.com/docs/guides/orientation,
+    // so ML Kit just needs the frame’s orientation metadata instead of rotating pixels manually.
     MLKVisionImage *image = [[MLKVisionImage alloc] initWithBuffer:buffer];
     image.orientation = orientation;
-    NSMutableArray *data = [NSMutableArray array];
+    NSMutableArray *detections = [NSMutableArray array];
+    __block NSDictionary *resultPayload = @{};
     dispatch_group_t dispatchGroup = dispatch_group_create();
     dispatch_group_enter(dispatchGroup);
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
@@ -52,54 +62,66 @@
                           completion:^(NSArray<MLKBarcode *> *_Nullable barcodes,
                                        NSError *_Nullable error) {
             if (error != nil) {
-                RCTResponseErrorBlock error;
+                dispatch_group_leave(dispatchGroup);
                 return;
             }
-            if (barcodes.count > 0) {
-                for (MLKBarcode *barcode in barcodes) {
-                    NSMutableDictionary *obj = [[NSMutableDictionary alloc] init];
-
-                    NSString *displayValue = barcode.displayValue;
-                    obj[@"displayValue"] = displayValue;
-                    NSString *rawValue = barcode.rawValue;
-                    obj[@"rawValue"] = rawValue;
-                    obj[@"format"] = [self stringFromFormat:barcode.format];
-                    obj[@"left"] = @(CGRectGetMinX(barcode.frame));
-                    obj[@"top"] = @(CGRectGetMinY(barcode.frame));
-                    obj[@"right"] = @(CGRectGetMaxX(barcode.frame));
-                    obj[@"bottom"] = @(CGRectGetMaxY(barcode.frame));
-                    obj[@"width"] = @(barcode.frame.size.width);
-                    obj[@"height"] = @(barcode.frame.size.height);
-
-                    MLKBarcodeValueType valueType = barcode.valueType;
-
-                    switch (valueType) {
-                        case MLKBarcodeValueTypeWiFi:
-                            obj[@"ssid"] = barcode.wifi.ssid;
-                            obj[@"password"] = barcode.wifi.password;
-                            break;
-                        case MLKBarcodeValueTypeURL:
-                            obj[@"url"] = barcode.URL.url;
-                            obj[@"title"] = barcode.URL.title;
-                            break;
-                        default:
-                            break;
-                    }
-                    [data addObject:obj];
+            SharedArray *sharedBoxes = nil;
+            float *boxData = nil;
+            const NSUInteger count = barcodes.count;
+            if (count > 0 && self.proxyHolder != nil) {
+                sharedBoxes = [[SharedArray alloc] initWithProxy:self.proxyHolder
+                                                allocateWithSize:count * sizeof(float) * 6];
+                boxData = (float *)sharedBoxes.data;
+            }
+            [barcodes enumerateObjectsUsingBlock:^(MLKBarcode * _Nonnull barcode, NSUInteger idx, BOOL * _Nonnull stop) {
+                NSMutableDictionary *obj = [[NSMutableDictionary alloc] init];
+                obj[@"displayValue"] = barcode.displayValue ?: (id)kCFNull;
+                obj[@"rawValue"] = barcode.rawValue ?: (id)kCFNull;
+                obj[@"format"] = [self stringFromFormat:barcode.format];
+                obj[@"boxIndex"] = @(idx);
+
+                if (boxData != nil) {
+                    CGRect frameRect = barcode.frame;
+                    const NSUInteger baseIndex = idx * 6;
+                    boxData[baseIndex] = CGRectGetMinY(frameRect);
+                    boxData[baseIndex + 1] = CGRectGetMaxY(frameRect);
+                    boxData[baseIndex + 2] = CGRectGetMinX(frameRect);
+                    boxData[baseIndex + 3] = CGRectGetMaxX(frameRect);
+                    boxData[baseIndex + 4] = CGRectGetWidth(frameRect);
+                    boxData[baseIndex + 5] = CGRectGetHeight(frameRect);
+                }
 
+                MLKBarcodeValueType valueType = barcode.valueType;
+                switch (valueType) {
+                    case MLKBarcodeValueTypeWiFi:
+                        obj[@"ssid"] = barcode.wifi.ssid ?: (id)kCFNull;
+                        obj[@"password"] = barcode.wifi.password ?: (id)kCFNull;
+                        break;
+                    case MLKBarcodeValueTypeURL:
+                        obj[@"url"] = barcode.URL.url ?: (id)kCFNull;
+                        obj[@"title"] = barcode.URL.title ?: (id)kCFNull;
+                        break;
+                    default:
+                        break;
                 }
+                [detections addObject:obj];
+            }];
 
+            NSMutableDictionary *payload = [NSMutableDictionary dictionary];
+            payload[@"detections"] = detections;
+            if (sharedBoxes != nil) {
+                payload[@"boxes"] = sharedBoxes;
             }
-
+            resultPayload = payload;
             dispatch_group_leave(dispatchGroup);
         }];
     });
 
     dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER);
-    return data;
+    return resultPayload;
 }
 
-VISION_EXPORT_FRAME_PROCESSOR(VisionCameraBarcodeScannerPlugin, scanBarcodes)
+VISION_EXPORT_FRAME_PROCESSOR(VisionCameraBarcodeScannerPlugin, vinScannerBarcode)
 
 @end