From ebe56401275348e3d1988ce072545e5f25983234 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Sun, 20 Sep 2026 12:57:00 +0530
Subject: [PATCH 1/9] perf(asr): bulk-fill MLMultiArray resets and copies

MLArrayCache.returnArray reset the 240000-sample preprocessor input one
NSNumber at a time, about 20 ms per transcription on the path that
returns the transcript, and TdtDecoderState(from:) copied the LSTM state
the same way before every recoverable decode. Reset through memset over
the backing extent, fill other values through a typed pointer, and
memcpy between identical layouts; the element loops remain as fallbacks.
---
 .../TDT/Decoder/TdtDecoderState.swift         | 42 +++++++++++++
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 62 +++++++++++++++++++
 .../Shared/MLArrayCacheTests.swift            | 39 ++++++++++++
 3 files changed, 143 insertions(+)

diff --git a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
index b89de5005..d0a1fc7bc 100644
--- a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
+++ b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
@@ -96,13 +96,55 @@ public struct TdtDecoderState: Sendable {
 }
 
 extension MLMultiArray {
+    /// Fills every element with `value` through the backing storage, so padded strides are covered.
+    /// Zero is a single `memset`; other values fill through a typed pointer where the type allows.
     func resetData(to value: NSNumber) {
+        let filled = withUnsafeMutableBytes { bytes, _ -> Bool in
+            guard let base = bytes.baseAddress else {
+                return true
+            }
+            if value == 0 {
+                memset(base, 0, bytes.count)
+                return true
+            }
+            switch dataType {
+            case .float32:
+                bytes.bindMemory(to: Float.self).update(repeating: value.floatValue)
+            case .float64:
+                bytes.bindMemory(to: Double.self).update(repeating: value.doubleValue)
+            case .int32:
+                bytes.bindMemory(to: Int32.self).update(repeating: value.int32Value)
+            default:
+                return false
+            }
+            return true
+        }
+        if filled {
+            return
+        }
         for i in 0..<count {
             self[i] = value
         }
     }
 
+    /// Copies every element from `source`. Identical layouts copy the backing storage in one
+    /// `memcpy`; anything else goes element by element.
     func copyData(from source: MLMultiArray) {
+        let copied = withUnsafeMutableBytes { destination, _ -> Bool in
+            source.withUnsafeBytes { origin -> Bool in
+                guard dataType == source.dataType, shape == source.shape, strides == source.strides,
+                    destination.count == origin.count, let to = destination.baseAddress,
+                    let from = origin.baseAddress
+                else {
+                    return false
+                }
+                memcpy(to, from, destination.count)
+                return true
+            }
+        }
+        if copied {
+            return
+        }
         for i in 0..<count {
             self[i] = source[i]
         }
diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index 9bb0173af..c46bca83f 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -183,6 +183,28 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         verifyArrayHasValue(array, value: 3.14)
     }
 
+    func testMLMultiArrayResetDataInt32Value() throws {
+        let array = try MLMultiArray(shape: [4, 6], dataType: .int32)
+
+        array.resetData(to: 7)
+
+        for i in 0..<array.count {
+            XCTAssertEqual(array[i].intValue, 7, "Array should hold 7 at index \(i)")
+        }
+    }
+
+    func testMLMultiArrayResetDataFloat16Value() throws {
+        let array = try MLMultiArray(shape: [3, 5], dataType: .float16)
+
+        array.resetData(to: 1.5)
+        for i in 0..<array.count {
+            XCTAssertEqual(array[i].floatValue, 1.5, "Array should hold 1.5 at index \(i)")
+        }
+
+        array.resetData(to: 0)
+        verifyArrayIsZero(array)
+    }
+
     func testMLMultiArrayResetDataNonFloat() throws {
         let array = try MLMultiArray(shape: [5, 3], dataType: .int32)
 
@@ -214,6 +236,46 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         verifyArraysEqual(destArray, sourceArray)
     }
 
+    func testMLMultiArrayCopyDataLargeArrayWithinBudget() throws {
+        // The decoder state is snapshotted before every inference, so the copy must be a bulk
+        // transfer. A per-element copy of 240000 samples costs tens of milliseconds.
+        let shape: [NSNumber] = [1, NSNumber(value: ASRConstants.maxModelSamples)]
+        let sourceArray = try MLMultiArray(shape: shape, dataType: .float32)
+        let destArray = try MLMultiArray(shape: shape, dataType: .float32)
+        sourceArray[sourceArray.count - 1] = NSNumber(value: Float(3))
+        let clock = ContinuousClock()
+        var best = Double.infinity
+
+        for _ in 0..<5 {
+            let elapsed = clock.measure {
+                destArray.copyData(from: sourceArray)
+            }
+            best = min(best, elapsed / .milliseconds(1))
+        }
+
+        XCTAssertEqual(destArray[destArray.count - 1].floatValue, 3)
+        XCTAssertLessThan(best, 5, "copyData took \(best) ms for \(ASRConstants.maxModelSamples) elements")
+    }
+
+    func testMLMultiArrayCopyDataAcrossStrideLayouts() throws {
+        // A plain array and an ANE-aligned array of the same shape have different strides;
+        // the copy must still land every element.
+        let shape: [NSNumber] = [10, 10]
+        let sourceArray = try ANEMemoryUtils.createAlignedArray(shape: shape, dataType: .float32)
+        let destArray = try MLMultiArray(shape: shape, dataType: .float32)
+        XCTAssertNotEqual(sourceArray.strides, destArray.strides)
+
+        for i in 0..<sourceArray.count {
+            sourceArray[i] = NSNumber(value: Float(i) + 0.5)
+        }
+
+        destArray.copyData(from: sourceArray)
+
+        for i in 0..<destArray.count {
+            XCTAssertEqual(destArray[i].floatValue, Float(i) + 0.5, "Element \(i) should match the source")
+        }
+    }
+
     func testMLMultiArrayCopyDataNonFloat() throws {
         let sourceArray = try MLMultiArray(shape: [2, 3], dataType: .int32)
         let destArray = try MLMultiArray(shape: [2, 3], dataType: .int32)
diff --git a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
index 09673423b..9f70e2365 100644
--- a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
+++ b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
@@ -204,6 +204,45 @@ final class MLArrayCacheTests: XCTestCase {
 
     // Removed performance test - can cause timing issues
 
+    // MARK: - Reset Cost
+
+    func testReturnArrayResetsPreprocessorBufferWithinBudget() async throws {
+        // The preprocessor input is returned after every transcription. A per-element reset of
+        // 240000 samples costs about 20 ms; a bulk reset is well under a millisecond.
+        let shape: [NSNumber] = [1, NSNumber(value: ASRConstants.maxModelSamples)]
+        let clock = ContinuousClock()
+        var best = Double.infinity
+
+        for _ in 0..<5 {
+            let array = try await cache.getArray(shape: shape, dataType: .float32)
+            array[0] = NSNumber(value: Float(1))
+            let elapsed = await clock.measure {
+                await cache.returnArray(array)
+            }
+            best = min(best, elapsed / .milliseconds(1))
+        }
+
+        XCTAssertLessThan(best, 5, "returnArray took \(best) ms for \(ASRConstants.maxModelSamples) samples")
+    }
+
+    func testReturnArrayResetsPaddedStrideArray() async throws {
+        // Aligned arrays pad the innermost stride to a tile boundary, so the reset must cover
+        // the padded layout, not just the first `count` elements.
+        let shape: [NSNumber] = [10, 10]
+        let array = try await cache.getArray(shape: shape, dataType: .float32)
+
+        for i in 0..<array.count {
+            array[i] = NSNumber(value: Float(i) + 1)
+        }
+
+        await cache.returnArray(array)
+        let cachedArray = try await cache.getArray(shape: shape, dataType: .float32)
+
+        for i in 0..<cachedArray.count {
+            XCTAssertEqual(cachedArray[i].floatValue, 0.0, "Element \(i) should be zero")
+        }
+    }
+
     // MARK: - Global Cache Tests
 
     func testSharedCacheInstance() async throws {

From 56c6fe3c312d8f0d5419388d233aa681f0dfd215 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Sun, 20 Sep 2026 14:18:23 +0530
Subject: [PATCH 2/9] fix(asr): memmove for overlapping MLMultiArray copies

memcpy is undefined when source and destination overlap, which zero-copy
views of one allocation and a self-copy can produce. memmove keeps the
bulk path correct there, a self-copy returns early, and the tests cover
overlapping views, self-copy, and the padding bytes of an aligned array.
---
 .../TDT/Decoder/TdtDecoderState.swift         |  8 +++--
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 34 +++++++++++++++++++
 .../Shared/MLArrayCacheTests.swift            |  5 +++
 3 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
index d0a1fc7bc..33214afc4 100644
--- a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
+++ b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
@@ -128,8 +128,12 @@ extension MLMultiArray {
     }
 
     /// Copies every element from `source`. Identical layouts copy the backing storage in one
-    /// `memcpy`; anything else goes element by element.
+    /// `memmove`, which stays correct when the two arrays are views of one allocation; anything else
+    /// goes element by element.
     func copyData(from source: MLMultiArray) {
+        if self === source {
+            return
+        }
         let copied = withUnsafeMutableBytes { destination, _ -> Bool in
             source.withUnsafeBytes { origin -> Bool in
                 guard dataType == source.dataType, shape == source.shape, strides == source.strides,
@@ -138,7 +142,7 @@ extension MLMultiArray {
                 else {
                     return false
                 }
-                memcpy(to, from, destination.count)
+                memmove(to, from, destination.count)
                 return true
             }
         }
diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index c46bca83f..dd577bf58 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -276,6 +276,40 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         }
     }
 
+    func testMLMultiArrayCopyDataBetweenOverlappingViews() throws {
+        // Two zero-copy views of one allocation, offset by 16 elements, overlap on 48 of their 64
+        // elements; the copy must behave as if the source were read completely first.
+        let backing = try ANEMemoryUtils.createAlignedArray(shape: [1, 96], dataType: .float32)
+        for i in 0..<backing.count {
+            backing[i] = NSNumber(value: Float(i))
+        }
+        let strides: [NSNumber] = [64, 1]
+        let sourceView = try ANEMemoryUtils.createZeroCopyView(
+            from: backing, offset: 0, shape: [1, 64], strides: strides)
+        let destinationView = try ANEMemoryUtils.createZeroCopyView(
+            from: backing, offset: 16, shape: [1, 64], strides: strides)
+
+        destinationView.copyData(from: sourceView)
+
+        for j in 0..<64 {
+            XCTAssertEqual(
+                destinationView[j].floatValue, Float(j), "Element \(j) should hold the original source value")
+        }
+    }
+
+    func testMLMultiArrayCopyDataFromItselfLeavesValues() throws {
+        let array = try MLMultiArray(shape: [2, 1, 640], dataType: .float32)
+        for i in 0..<array.count {
+            array[i] = NSNumber(value: Float(i) * 0.5)
+        }
+
+        array.copyData(from: array)
+
+        for i in stride(from: 0, to: array.count, by: 97) {
+            XCTAssertEqual(array[i].floatValue, Float(i) * 0.5, "Element \(i) should be unchanged")
+        }
+    }
+
     func testMLMultiArrayCopyDataNonFloat() throws {
         let sourceArray = try MLMultiArray(shape: [2, 3], dataType: .int32)
         let destArray = try MLMultiArray(shape: [2, 3], dataType: .int32)
diff --git a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
index 9f70e2365..a38846dda 100644
--- a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
+++ b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
@@ -241,6 +241,11 @@ final class MLArrayCacheTests: XCTestCase {
         for i in 0..<cachedArray.count {
             XCTAssertEqual(cachedArray[i].floatValue, 0.0, "Element \(i) should be zero")
         }
+        cachedArray.withUnsafeBytes { bytes in
+            let values = bytes.bindMemory(to: Float.self)
+            XCTAssertGreaterThan(values.count, cachedArray.count, "The aligned layout should carry padding")
+            XCTAssertTrue(values.allSatisfy { $0 == 0 }, "Padding bytes should be zero too")
+        }
     }
 
     // MARK: - Global Cache Tests

From 82c8bcc6afb634352bc26e9c2d6462427dac6473 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Mon, 21 Sep 2026 00:46:21 +0530
Subject: [PATCH 3/9] fix(asr): bulk-fill only contiguous MLMultiArray storage

withUnsafeMutableBytes reports the padded byte span, so a view built with
padded strides over a tighter allocation would be overrun by a span-wide
memset or copy. The bulk paths now require the span to equal count times
the element size; padded layouts keep the element loop, so nothing past
the last element is written. The copy goes through copyMemory, which is
overlap-safe, and the doc comments state the overlap and -0.0 behavior.
---
 .../TDT/Decoder/TdtDecoderState.swift         | 42 ++++++++-------
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 53 +++++++++++++++++++
 2 files changed, 75 insertions(+), 20 deletions(-)

diff --git a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
index 33214afc4..41ed5988d 100644
--- a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
+++ b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
@@ -96,12 +96,17 @@ public struct TdtDecoderState: Sendable {
 }
 
 extension MLMultiArray {
-    /// Fills every element with `value` through the backing storage, so padded strides are covered.
-    /// Zero is a single `memset`; other values fill through a typed pointer where the type allows.
+    /// Fills every element with `value`.
+    ///
+    /// Contiguous storage fills in bulk: zero is one `memset` for every data type, other values
+    /// fill through a typed pointer for float32, float64 and int32. Padded strides and other data
+    /// types fill element by element, so nothing past the last element is ever written. `value` is
+    /// compared as an `NSNumber`, so `-0.0` takes the zero path and lands as `+0.0`.
     func resetData(to value: NSNumber) {
+        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
         let filled = withUnsafeMutableBytes { bytes, _ -> Bool in
-            guard let base = bytes.baseAddress else {
-                return true
+            guard bytes.count == count * elementSize, let base = bytes.baseAddress else {
+                return false
             }
             if value == 0 {
                 memset(base, 0, bytes.count)
@@ -127,27 +132,24 @@ extension MLMultiArray {
         }
     }
 
-    /// Copies every element from `source`. Identical layouts copy the backing storage in one
-    /// `memmove`, which stays correct when the two arrays are views of one allocation; anything else
-    /// goes element by element.
+    /// Copies every element from `source`.
+    ///
+    /// Identical contiguous layouts copy the storage in bulk; that copy is overlap-safe, so two
+    /// views of one allocation may overlap. Any other pair copies element by element and assumes
+    /// the two arrays do not share storage.
     func copyData(from source: MLMultiArray) {
-        if self === source {
-            return
-        }
-        let copied = withUnsafeMutableBytes { destination, _ -> Bool in
-            source.withUnsafeBytes { origin -> Bool in
-                guard dataType == source.dataType, shape == source.shape, strides == source.strides,
-                    destination.count == origin.count, let to = destination.baseAddress,
-                    let from = origin.baseAddress
-                else {
+        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
+        if dataType == source.dataType, shape == source.shape, strides == source.strides {
+            let copied = withUnsafeMutableBytes { destination, _ -> Bool in
+                guard destination.count == count * elementSize else {
                     return false
                 }
-                memmove(to, from, destination.count)
+                source.withUnsafeBytes { destination.copyMemory(from: $0) }
                 return true
             }
-        }
-        if copied {
-            return
+            if copied {
+                return
+            }
         }
         for i in 0..<count {
             self[i] = source[i]
diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index dd577bf58..4c53844a6 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -222,6 +222,30 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         }
     }
 
+    func testMLMultiArrayResetDataStaysInsideTheLogicalElements() throws {
+        // A padded layout reports a byte span past its last element: shape [2, 10] with strides
+        // [16, 1] ends at element 26 while the span covers 32. Storage beyond the last element can
+        // belong to someone else, so the reset must not touch it.
+        let elements = 32
+        let storage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
+        defer { storage.deallocate() }
+        storage.initialize(repeating: 1, count: elements)
+        let sentinel: Float = 12345
+        for i in 26..<elements {
+            storage[i] = sentinel
+        }
+        let view = try MLMultiArray(
+            dataPointer: UnsafeMutableRawPointer(storage), shape: [2, 10], dataType: .float32,
+            strides: [16, 1], deallocator: nil)
+
+        view.resetData(to: 0)
+
+        verifyArrayIsZero(view)
+        for i in 26..<elements {
+            XCTAssertEqual(storage[i], sentinel, "Storage past the last element was written at \(i)")
+        }
+    }
+
     func testMLMultiArrayCopyData() throws {
         let sourceArray = try MLMultiArray(shape: [3, 4], dataType: .float32)
         let destArray = try MLMultiArray(shape: [3, 4], dataType: .float32)
@@ -310,6 +334,35 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         }
     }
 
+    func testMLMultiArrayCopyDataStaysInsideTheLogicalElements() throws {
+        // Same padded layout as the reset test: the copy must land every element and leave the
+        // destination's storage past its last element alone.
+        let elements = 32
+        let sourceStorage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
+        let destinationStorage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
+        defer {
+            sourceStorage.deallocate()
+            destinationStorage.deallocate()
+        }
+        sourceStorage.initialize(repeating: 1, count: elements)
+        let sentinel: Float = 12345
+        destinationStorage.initialize(repeating: sentinel, count: elements)
+        let sourceView = try MLMultiArray(
+            dataPointer: UnsafeMutableRawPointer(sourceStorage), shape: [2, 10], dataType: .float32,
+            strides: [16, 1], deallocator: nil)
+        let destinationView = try MLMultiArray(
+            dataPointer: UnsafeMutableRawPointer(destinationStorage), shape: [2, 10], dataType: .float32,
+            strides: [16, 1], deallocator: nil)
+        fillArrayWithTestData(sourceView, multiplier: 3)
+
+        destinationView.copyData(from: sourceView)
+
+        verifyArraysEqual(destinationView, sourceView)
+        for i in 26..<elements {
+            XCTAssertEqual(destinationStorage[i], sentinel, "Storage past the last element was written at \(i)")
+        }
+    }
+
     func testMLMultiArrayCopyDataNonFloat() throws {
         let sourceArray = try MLMultiArray(shape: [2, 3], dataType: .int32)
         let destArray = try MLMultiArray(shape: [2, 3], dataType: .int32)

From 3f677ab10af12b457746a216a7a281633a1afc6b Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Mon, 21 Sep 2026 00:48:56 +0530
Subject: [PATCH 4/9] refactor(shared): one MLMultiArray fill helper

resetData and copyData move next to reset(to:) in Shared, and reset(to:)
delegates to them, so MLArrayCache no longer reaches into the decoder for
its helper. reset(to:) used to walk count contiguous slots, which skipped
the last rows of a padded array; the stride-aware fill covers them. The
warm-up's private vDSP fill goes the same way.
---
 .../TDT/Decoder/TdtDecoderState.swift         | 62 -----------------
 .../Shared/MLMultiArray+Extensions.swift      | 68 +++++++++++++++++--
 Sources/FluidAudio/Shared/ModelWarmup.swift   | 22 ++----
 .../Shared/MLMultiArrayExtensionsTests.swift  | 22 ++++++
 4 files changed, 89 insertions(+), 85 deletions(-)
 create mode 100644 Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift

diff --git a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
index 41ed5988d..b25a65e1e 100644
--- a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
+++ b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
@@ -94,65 +94,3 @@ public struct TdtDecoderState: Sendable {
         // Keep LSTM states as they represent the final linguistic context
     }
 }
-
-extension MLMultiArray {
-    /// Fills every element with `value`.
-    ///
-    /// Contiguous storage fills in bulk: zero is one `memset` for every data type, other values
-    /// fill through a typed pointer for float32, float64 and int32. Padded strides and other data
-    /// types fill element by element, so nothing past the last element is ever written. `value` is
-    /// compared as an `NSNumber`, so `-0.0` takes the zero path and lands as `+0.0`.
-    func resetData(to value: NSNumber) {
-        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
-        let filled = withUnsafeMutableBytes { bytes, _ -> Bool in
-            guard bytes.count == count * elementSize, let base = bytes.baseAddress else {
-                return false
-            }
-            if value == 0 {
-                memset(base, 0, bytes.count)
-                return true
-            }
-            switch dataType {
-            case .float32:
-                bytes.bindMemory(to: Float.self).update(repeating: value.floatValue)
-            case .float64:
-                bytes.bindMemory(to: Double.self).update(repeating: value.doubleValue)
-            case .int32:
-                bytes.bindMemory(to: Int32.self).update(repeating: value.int32Value)
-            default:
-                return false
-            }
-            return true
-        }
-        if filled {
-            return
-        }
-        for i in 0..<count {
-            self[i] = value
-        }
-    }
-
-    /// Copies every element from `source`.
-    ///
-    /// Identical contiguous layouts copy the storage in bulk; that copy is overlap-safe, so two
-    /// views of one allocation may overlap. Any other pair copies element by element and assumes
-    /// the two arrays do not share storage.
-    func copyData(from source: MLMultiArray) {
-        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
-        if dataType == source.dataType, shape == source.shape, strides == source.strides {
-            let copied = withUnsafeMutableBytes { destination, _ -> Bool in
-                guard destination.count == count * elementSize else {
-                    return false
-                }
-                source.withUnsafeBytes { destination.copyMemory(from: $0) }
-                return true
-            }
-            if copied {
-                return
-            }
-        }
-        for i in 0..<count {
-            self[i] = source[i]
-        }
-    }
-}
diff --git a/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
index 779ece06a..705bfad97 100644
--- a/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
+++ b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
@@ -1,15 +1,69 @@
 import CoreML
+import Foundation
 
 extension MLMultiArray {
     /// Reset all elements in the array to the given value.
     func reset(to value: NSNumber) {
-        let count = self.count
-        if self.dataType == .float32 {
-            let ptr = self.dataPointer.bindMemory(to: Float.self, capacity: count)
-            ptr.update(repeating: value.floatValue, count: count)
-        } else if self.dataType == .int32 {
-            let intPtr = self.dataPointer.bindMemory(to: Int32.self, capacity: count)
-            intPtr.update(repeating: value.int32Value, count: count)
+        resetData(to: value)
+    }
+
+    /// Fills every element with `value`.
+    ///
+    /// Contiguous storage fills in bulk: zero is one `memset` for every data type, other values
+    /// fill through a typed pointer for float32, float64 and int32. Padded strides and other data
+    /// types fill element by element, so nothing past the last element is ever written. `value` is
+    /// compared as an `NSNumber`, so `-0.0` takes the zero path and lands as `+0.0`.
+    func resetData(to value: NSNumber) {
+        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
+        let filled = withUnsafeMutableBytes { bytes, _ -> Bool in
+            guard bytes.count == count * elementSize, let base = bytes.baseAddress else {
+                return false
+            }
+            if value == 0 {
+                memset(base, 0, bytes.count)
+                return true
+            }
+            switch dataType {
+            case .float32:
+                bytes.bindMemory(to: Float.self).update(repeating: value.floatValue)
+            case .float64:
+                bytes.bindMemory(to: Double.self).update(repeating: value.doubleValue)
+            case .int32:
+                bytes.bindMemory(to: Int32.self).update(repeating: value.int32Value)
+            default:
+                return false
+            }
+            return true
+        }
+        if filled {
+            return
+        }
+        for i in 0..<count {
+            self[i] = value
+        }
+    }
+
+    /// Copies every element from `source`.
+    ///
+    /// Identical contiguous layouts copy the storage in bulk; that copy is overlap-safe, so two
+    /// views of one allocation may overlap. Any other pair copies element by element and assumes
+    /// the two arrays do not share storage.
+    func copyData(from source: MLMultiArray) {
+        let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
+        if dataType == source.dataType, shape == source.shape, strides == source.strides {
+            let copied = withUnsafeMutableBytes { destination, _ -> Bool in
+                guard destination.count == count * elementSize else {
+                    return false
+                }
+                source.withUnsafeBytes { destination.copyMemory(from: $0) }
+                return true
+            }
+            if copied {
+                return
+            }
+        }
+        for i in 0..<count {
+            self[i] = source[i]
         }
     }
 }
diff --git a/Sources/FluidAudio/Shared/ModelWarmup.swift b/Sources/FluidAudio/Shared/ModelWarmup.swift
index 6928fa1a1..230545662 100644
--- a/Sources/FluidAudio/Shared/ModelWarmup.swift
+++ b/Sources/FluidAudio/Shared/ModelWarmup.swift
@@ -1,4 +1,3 @@
-import Accelerate
 import CoreML
 import Foundation
 
@@ -27,7 +26,7 @@ enum ModelWarmup {
             shape: inputShape.map { NSNumber(value: $0) },
             dataType: .float32
         )
-        array.resetToZeros()
+        array.resetData(to: 0)
 
         let features = try MLDictionaryFeatureProvider(dictionary: [
             inputName: MLFeatureValue(multiArray: array)
@@ -85,13 +84,13 @@ enum ModelWarmup {
                 shape: featureShape.map { NSNumber(value: $0) },
                 dataType: .float32
             )
-            featureArray.resetToZeros()
+            featureArray.resetData(to: 0)
 
             let weightArray = try MLMultiArray(
                 shape: weightsShape.map { NSNumber(value: $0) },
                 dataType: .float32
             )
-            weightArray.resetToZeros()
+            weightArray.resetData(to: 0)
 
             let provider = try MLDictionaryFeatureProvider(dictionary: [
                 "fbank_features": MLFeatureValue(multiArray: featureArray),
@@ -110,7 +109,7 @@ enum ModelWarmup {
                 shape: [1, 1, 1, NSNumber(value: totalElements)],
                 dataType: .float32
             )
-            combinedArray.resetToZeros()
+            combinedArray.resetData(to: 0)
 
             let provider = try MLDictionaryFeatureProvider(dictionary: [
                 "audio_and_weights": MLFeatureValue(multiArray: combinedArray)
@@ -126,13 +125,13 @@ enum ModelWarmup {
             shape: [1, 1, NSNumber(value: audioSamples)],
             dataType: .float32
         )
-        audioArray.resetToZeros()
+        audioArray.resetData(to: 0)
 
         let weightArray = try MLMultiArray(
             shape: [1, NSNumber(value: weightFrames)],
             dataType: .float32
         )
-        weightArray.resetToZeros()
+        weightArray.resetData(to: 0)
 
         let provider = try MLDictionaryFeatureProvider(dictionary: [
             "audio": MLFeatureValue(multiArray: audioArray),
@@ -142,12 +141,3 @@ enum ModelWarmup {
         _ = try model.prediction(from: provider)
     }
 }
-
-extension MLMultiArray {
-    fileprivate func resetToZeros() {
-        let pointer = dataPointer.assumingMemoryBound(to: Float.self)
-        let count = self.count
-        var zero: Float = 0
-        vDSP_vfill(&zero, pointer, 1, vDSP_Length(count))
-    }
-}
diff --git a/Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift b/Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift
new file mode 100644
index 000000000..08b5f3810
--- /dev/null
+++ b/Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift
@@ -0,0 +1,22 @@
+@preconcurrency import CoreML
+import XCTest
+
+@testable import FluidAudio
+
+final class MLMultiArrayExtensionsTests: XCTestCase {
+
+    func testResetClearsEveryElementOfPaddedStrides() throws {
+        // An aligned [10, 10] array pads its rows to 16 elements, so the storage holds 160 slots
+        // for 100 elements. A fill that walks `count` contiguous slots misses the last rows.
+        let array = try ANEMemoryUtils.createAlignedArray(shape: [10, 10], dataType: .float32)
+        for i in 0..<array.count {
+            array[i] = NSNumber(value: Float(i) + 1)
+        }
+
+        array.reset(to: 0)
+
+        for i in 0..<array.count {
+            XCTAssertEqual(array[i].floatValue, 0, "Element \(i) should be zero")
+        }
+    }
+}

From 02602d4587adc90b82fdeb4319ffc07206d310ad Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Mon, 21 Sep 2026 00:49:14 +0530
Subject: [PATCH 5/9] test: cover padded fills and gate fill budgets in CI

---
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 92 ++++++++++++++-----
 1 file changed, 68 insertions(+), 24 deletions(-)

diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index 4c53844a6..ff91d7719 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -188,18 +188,24 @@ final class TdtDecoderStateV3Tests: XCTestCase {
 
         array.resetData(to: 7)
 
-        for i in 0..<array.count {
-            XCTAssertEqual(array[i].intValue, 7, "Array should hold 7 at index \(i)")
-        }
+        verifyArrayHasValue(array, value: 7)
+    }
+
+    func testMLMultiArrayResetDataFloat64Value() throws {
+        let array = try MLMultiArray(shape: [3, 4], dataType: .float64)
+
+        array.resetData(to: 2.25)
+        verifyArrayHasValue(array, value: 2.25)
+
+        array.resetData(to: 0)
+        verifyArrayIsZero(array)
     }
 
     func testMLMultiArrayResetDataFloat16Value() throws {
         let array = try MLMultiArray(shape: [3, 5], dataType: .float16)
 
         array.resetData(to: 1.5)
-        for i in 0..<array.count {
-            XCTAssertEqual(array[i].floatValue, 1.5, "Array should hold 1.5 at index \(i)")
-        }
+        verifyArrayHasValue(array, value: 1.5)
 
         array.resetData(to: 0)
         verifyArrayIsZero(array)
@@ -222,6 +228,53 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         }
     }
 
+    func testMLMultiArrayResetDataClearsEveryElementOfPaddedStrides() throws {
+        // Aligned arrays are zero-cleared on allocation, so the storage is poisoned first;
+        // otherwise a fill that skips elements would still look clean.
+        let array = try ANEMemoryUtils.createAlignedArray(shape: [10, 10], dataType: .float32)
+        array.withUnsafeMutableBytes { bytes, _ in
+            bytes.bindMemory(to: Float.self).update(repeating: .nan)
+        }
+
+        array.resetData(to: 0)
+
+        verifyArrayIsZero(array)
+    }
+
+    func testMLMultiArrayResetDataClearsTheWholeContiguousStorage() throws {
+        let array = try ANEMemoryUtils.createAlignedArray(shape: [1, 64], dataType: .float32)
+        array.withUnsafeMutableBytes { bytes, _ in
+            bytes.bindMemory(to: Float.self).update(repeating: .nan)
+        }
+
+        array.resetData(to: 0)
+
+        array.withUnsafeBytes { bytes in
+            XCTAssertTrue(bytes.bindMemory(to: Float.self).allSatisfy { $0 == 0 }, "Every stored value should be zero")
+        }
+    }
+
+    func testMLMultiArrayResetDataLargeArrayWithinBudget() throws {
+        // A per-element reset of 240000 samples costs tens of milliseconds; the bulk path is well
+        // under a millisecond. Timed locally only: the parallel CI job shares its machine.
+        try XCTSkipIf(ProcessInfo.processInfo.environment["CI"] != nil, "Timing budgets run locally only")
+        let shape: [NSNumber] = [1, NSNumber(value: ASRConstants.maxModelSamples)]
+        let array = try MLMultiArray(shape: shape, dataType: .float32)
+        let clock = ContinuousClock()
+        var best = Double.infinity
+
+        for _ in 0..<5 {
+            array[0] = NSNumber(value: Float(1))
+            let elapsed = clock.measure {
+                array.resetData(to: 0)
+            }
+            best = min(best, elapsed / .milliseconds(1))
+        }
+
+        XCTAssertEqual(array[0].floatValue, 0)
+        XCTAssertLessThan(best, 5, "resetData took \(best) ms for \(ASRConstants.maxModelSamples) elements")
+    }
+
     func testMLMultiArrayResetDataStaysInsideTheLogicalElements() throws {
         // A padded layout reports a byte span past its last element: shape [2, 10] with strides
         // [16, 1] ends at element 26 while the span covers 32. Storage beyond the last element can
@@ -262,7 +315,9 @@ final class TdtDecoderStateV3Tests: XCTestCase {
 
     func testMLMultiArrayCopyDataLargeArrayWithinBudget() throws {
         // The decoder state is snapshotted before every inference, so the copy must be a bulk
-        // transfer. A per-element copy of 240000 samples costs tens of milliseconds.
+        // transfer. A per-element copy of 240000 samples costs tens of milliseconds. Timed locally
+        // only: the parallel CI job shares its machine.
+        try XCTSkipIf(ProcessInfo.processInfo.environment["CI"] != nil, "Timing budgets run locally only")
         let shape: [NSNumber] = [1, NSNumber(value: ASRConstants.maxModelSamples)]
         let sourceArray = try MLMultiArray(shape: shape, dataType: .float32)
         let destArray = try MLMultiArray(shape: shape, dataType: .float32)
@@ -289,15 +344,11 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         let destArray = try MLMultiArray(shape: shape, dataType: .float32)
         XCTAssertNotEqual(sourceArray.strides, destArray.strides)
 
-        for i in 0..<sourceArray.count {
-            sourceArray[i] = NSNumber(value: Float(i) + 0.5)
-        }
+        fillArrayWithTestData(sourceArray, multiplier: 1.5)
 
         destArray.copyData(from: sourceArray)
 
-        for i in 0..<destArray.count {
-            XCTAssertEqual(destArray[i].floatValue, Float(i) + 0.5, "Element \(i) should match the source")
-        }
+        verifyArraysEqual(destArray, sourceArray)
     }
 
     func testMLMultiArrayCopyDataBetweenOverlappingViews() throws {
@@ -315,23 +366,16 @@ final class TdtDecoderStateV3Tests: XCTestCase {
 
         destinationView.copyData(from: sourceView)
 
-        for j in 0..<64 {
-            XCTAssertEqual(
-                destinationView[j].floatValue, Float(j), "Element \(j) should hold the original source value")
-        }
+        verifyArraysEqual(destinationView, try createTestArray(shape: [1, 64], multiplier: 1))
     }
 
     func testMLMultiArrayCopyDataFromItselfLeavesValues() throws {
-        let array = try MLMultiArray(shape: [2, 1, 640], dataType: .float32)
-        for i in 0..<array.count {
-            array[i] = NSNumber(value: Float(i) * 0.5)
-        }
+        let array = try createTestArray(shape: decoderStateShape, multiplier: 0.5)
+        let expected = try createTestArray(shape: decoderStateShape, multiplier: 0.5)
 
         array.copyData(from: array)
 
-        for i in stride(from: 0, to: array.count, by: 97) {
-            XCTAssertEqual(array[i].floatValue, Float(i) * 0.5, "Element \(i) should be unchanged")
-        }
+        verifyArraysEqual(array, expected)
     }
 
     func testMLMultiArrayCopyDataStaysInsideTheLogicalElements() throws {

From bcc4666385299bfb66e44bb62f7de87e1ece3ad5 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Mon, 21 Sep 2026 00:50:06 +0530
Subject: [PATCH 6/9] perf(asr): stop zero-filling arrays returned to the cache

The only getArray consumer overwrites the full extent of the preprocessor
input with memcpy, and every caller pads the audio before that, so the
reset on return was dead work: 240000 boxed stores, about 20 ms, on the
path that returns the transcript.
---
 Sources/FluidAudio/Shared/MLArrayCache.swift  |  4 +-
 .../Shared/MLArrayCacheTests.swift            | 65 -------------------
 2 files changed, 2 insertions(+), 67 deletions(-)

diff --git a/Sources/FluidAudio/Shared/MLArrayCache.swift b/Sources/FluidAudio/Shared/MLArrayCache.swift
index b62ba4fbd..29ea5995c 100644
--- a/Sources/FluidAudio/Shared/MLArrayCache.swift
+++ b/Sources/FluidAudio/Shared/MLArrayCache.swift
@@ -31,7 +31,8 @@ actor MLArrayCache {
         return try ANEMemoryUtils.createAlignedArray(shape: shape, dataType: dataType)
     }
 
-    /// Return an array to the cache for reuse
+    /// Return an array to the cache for reuse. Its contents are kept: every consumer of `getArray`
+    /// overwrites the full extent before use, so clearing here would be wasted work.
     func returnArray(_ array: MLMultiArray) {
         let key = CacheKey(
             shape: array.shape.map { $0.intValue },
@@ -42,7 +43,6 @@ actor MLArrayCache {
 
         // Limit cache size per key
         if arrays.count < maxCacheSize / max(cache.count, 1) {
-            array.resetData(to: 0)
             arrays.append(array)
             cache[key] = arrays
         }
diff --git a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
index a38846dda..167285969 100644
--- a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
+++ b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
@@ -47,27 +47,6 @@ final class MLArrayCacheTests: XCTestCase {
         XCTAssertEqual(array2.dataType, .float32)
     }
 
-    func testReturnArrayResetsData() async throws {
-        let shape: [NSNumber] = [10]
-        let array = try await cache.getArray(shape: shape, dataType: .float32)
-
-        // Set some values
-        for i in 0..<array.count {
-            array[i] = NSNumber(value: Float(i) * 2.0)
-        }
-
-        // Return to cache
-        await cache.returnArray(array)
-
-        // Get from cache again
-        let cachedArray = try await cache.getArray(shape: shape, dataType: .float32)
-
-        // Data should be reset to zero
-        for i in 0..<cachedArray.count {
-            XCTAssertEqual(cachedArray[i].floatValue, 0.0)
-        }
-    }
-
     // MARK: - Cache Size Management
 
     func testCacheSizeLimit() async throws {
@@ -204,50 +183,6 @@ final class MLArrayCacheTests: XCTestCase {
 
     // Removed performance test - can cause timing issues
 
-    // MARK: - Reset Cost
-
-    func testReturnArrayResetsPreprocessorBufferWithinBudget() async throws {
-        // The preprocessor input is returned after every transcription. A per-element reset of
-        // 240000 samples costs about 20 ms; a bulk reset is well under a millisecond.
-        let shape: [NSNumber] = [1, NSNumber(value: ASRConstants.maxModelSamples)]
-        let clock = ContinuousClock()
-        var best = Double.infinity
-
-        for _ in 0..<5 {
-            let array = try await cache.getArray(shape: shape, dataType: .float32)
-            array[0] = NSNumber(value: Float(1))
-            let elapsed = await clock.measure {
-                await cache.returnArray(array)
-            }
-            best = min(best, elapsed / .milliseconds(1))
-        }
-
-        XCTAssertLessThan(best, 5, "returnArray took \(best) ms for \(ASRConstants.maxModelSamples) samples")
-    }
-
-    func testReturnArrayResetsPaddedStrideArray() async throws {
-        // Aligned arrays pad the innermost stride to a tile boundary, so the reset must cover
-        // the padded layout, not just the first `count` elements.
-        let shape: [NSNumber] = [10, 10]
-        let array = try await cache.getArray(shape: shape, dataType: .float32)
-
-        for i in 0..<array.count {
-            array[i] = NSNumber(value: Float(i) + 1)
-        }
-
-        await cache.returnArray(array)
-        let cachedArray = try await cache.getArray(shape: shape, dataType: .float32)
-
-        for i in 0..<cachedArray.count {
-            XCTAssertEqual(cachedArray[i].floatValue, 0.0, "Element \(i) should be zero")
-        }
-        cachedArray.withUnsafeBytes { bytes in
-            let values = bytes.bindMemory(to: Float.self)
-            XCTAssertGreaterThan(values.count, cachedArray.count, "The aligned layout should carry padding")
-            XCTAssertTrue(values.allSatisfy { $0 == 0 }, "Padding bytes should be zero too")
-        }
-    }
-
     // MARK: - Global Cache Tests
 
     func testSharedCacheInstance() async throws {

From 9a3b03b2cd938736f8be61dad31bcd6f52428fd7 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Mon, 21 Sep 2026 00:50:16 +0530
Subject: [PATCH 7/9] fix(diarizer): bound zero-copy views by their padded span

createZeroCopyView checked the logical element count against the source
but built the view with padded strides, so a view whose innermost
dimension is not a multiple of 16 could extend past the source storage.
The check now uses the span the strides imply, as ANEMemoryUtils does.
---
 .../Shared/ANEMemoryOptimizer.swift           | 15 +++++++++------
 .../Shared/ANEMemoryOptimizerTests.swift      | 19 +++++++++++++++++++
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift b/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift
index aab43bc83..4541e473e 100644
--- a/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift
+++ b/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift
@@ -88,11 +88,14 @@ public final class ANEMemoryOptimizer {
         shape: [NSNumber],
         offset: Int = 0
     ) throws -> MLMultiArray {
-        // Ensure we have enough data
-        let sourceElements = sourceArray.shape.map { $0.intValue }.reduce(1, *)
-        let viewElements = shape.map { $0.intValue }.reduce(1, *)
-
-        guard offset + viewElements <= sourceElements else {
+        // The view pads its innermost stride, so its storage span can exceed its element count;
+        // bound the span, not the count, or a padded view would run past a tighter source.
+        let strides = calculateOptimalStrides(for: shape, dataType: sourceArray.dataType)
+        let viewSpan = shape.isEmpty ? 0 : strides[0].intValue * shape[0].intValue
+        let sourceSpan =
+            sourceArray.shape.isEmpty ? 0 : sourceArray.strides[0].intValue * sourceArray.shape[0].intValue
+
+        guard offset + viewSpan <= sourceSpan else {
             throw DiarizerError.invalidArrayBounds
         }
 
@@ -107,7 +110,7 @@ public final class ANEMemoryOptimizer {
             dataPointer: offsetPointer,
             shape: shape,
             dataType: sourceArray.dataType,
-            strides: calculateOptimalStrides(for: shape, dataType: sourceArray.dataType),
+            strides: strides,
             deallocator: nil  // No deallocation since it's a view
         )
     }
diff --git a/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift b/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift
index 0bf57ba40..af6d5f2da 100644
--- a/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift
+++ b/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift
@@ -193,6 +193,25 @@ final class ANEMemoryOptimizerTests: XCTestCase {
 
     // MARK: - Memory Pressure Tests
 
+    // MARK: - Zero-Copy View Bounds
+
+    func testZeroCopyViewRejectsPaddedSpanBeyondSource() throws {
+        // A [10, 10] view pads its rows to 16 elements, so its storage span is 160 elements; a
+        // 100-element source cannot back it even though it holds 100 logical elements.
+        let source = try optimizer.createAlignedArray(shape: [100], dataType: .float32)
+
+        XCTAssertThrowsError(try optimizer.createZeroCopyView(from: source, shape: [10, 10]))
+    }
+
+    func testZeroCopyViewAcceptsSpanWithinSource() throws {
+        let source = try optimizer.createAlignedArray(shape: [1024], dataType: .float32)
+
+        let view = try optimizer.createZeroCopyView(from: source, shape: [256], offset: 768)
+
+        XCTAssertEqual(view.shape, [256])
+        XCTAssertEqual(view.dataPointer, source.dataPointer.advanced(by: 768 * MemoryLayout<Float>.stride))
+    }
+
     func testMemoryPressureHandling() throws {
         // Create many buffers to simulate memory pressure
         var buffers: [MLMultiArray] = []

From 2d0d727af2765cd4d9957a5c21e84aad545cee74 Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Tue, 22 Sep 2026 10:37:01 +0530
Subject: [PATCH 8/9] fix(shared): snapshot copyData fallback source

The element-wise fallback read the source while writing the destination,
so two views of one allocation with different layouts clobbered source
elements before they were read. Read the whole source first; the bulk
path for identical layouts was already overlap-safe. Test case from
Nathan Roll.
---
 .../Shared/MLMultiArray+Extensions.swift      |  7 +++---
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 23 +++++++++++++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
index 705bfad97..a6d6c399a 100644
--- a/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
+++ b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
@@ -46,8 +46,8 @@ extension MLMultiArray {
     /// Copies every element from `source`.
     ///
     /// Identical contiguous layouts copy the storage in bulk; that copy is overlap-safe, so two
-    /// views of one allocation may overlap. Any other pair copies element by element and assumes
-    /// the two arrays do not share storage.
+    /// views of one allocation may overlap. Any other pair reads the whole source before writing,
+    /// so overlapping views with different layouts stay safe too.
     func copyData(from source: MLMultiArray) {
         let elementSize = ANEMemoryUtils.getElementSize(for: dataType)
         if dataType == source.dataType, shape == source.shape, strides == source.strides {
@@ -62,8 +62,9 @@ extension MLMultiArray {
                 return
             }
         }
+        let values = (0..<count).map { source[$0] }
         for i in 0..<count {
-            self[i] = source[i]
+            self[i] = values[i]
         }
     }
 }
diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index ff91d7719..6d622b73e 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -369,6 +369,29 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         verifyArraysEqual(destinationView, try createTestArray(shape: [1, 64], multiplier: 1))
     }
 
+    func testMLMultiArrayCopySnapshotsOverlappingDifferentLayouts() throws {
+        // Two views of one allocation with different strides: the source holds storage slots
+        // 0, 1, 4, 5 and the destination slots 1, 2, 4, 5. Writing the destination in place would
+        // clobber source element 1 before it is read, so the copy must read the whole source first.
+        let backing = try ANEMemoryUtils.createAlignedArray(shape: [1, 8], dataType: .float32)
+        for i in 0..<backing.count {
+            backing[i] = NSNumber(value: Float(i))
+        }
+        let source = try ANEMemoryUtils.createZeroCopyView(
+            from: backing, offset: 0, shape: [2, 2], strides: [4, 1])
+        let destination = try ANEMemoryUtils.createZeroCopyView(
+            from: backing, offset: 1, shape: [2, 2], strides: [3, 1])
+
+        destination.copyData(from: source)
+
+        for (i, expected) in [Float(0), 1, 4, 5].enumerated() {
+            XCTAssertEqual(destination[i].floatValue, expected, "Element \(i) should come from the source")
+        }
+        for i in [0, 3, 6, 7] {
+            XCTAssertEqual(backing[i].floatValue, Float(i), "Storage outside the destination was written at \(i)")
+        }
+    }
+
     func testMLMultiArrayCopyDataFromItselfLeavesValues() throws {
         let array = try createTestArray(shape: decoderStateShape, multiplier: 0.5)
         let expected = try createTestArray(shape: decoderStateShape, multiplier: 0.5)

From 325ce6bd1abb0f86b360eeffe33866b8b26f2f0b Mon Sep 17 00:00:00 2001
From: vakharwalad23 <vakharwala.d@gmail.com>
Date: Tue, 22 Sep 2026 10:37:28 +0530
Subject: [PATCH 9/9] test: check row gaps in padded-view fills

The padded-view sentinel tests only checked storage past the last
element. A bulk write covering the logical byte count would clobber the
slots between the rows and still pass, so the sentinels now cover those
slots too.
---
 .../TDT/Decoder/TdtDecoderStateV3Tests.swift  | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index 6d622b73e..3da64d912 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -277,14 +277,16 @@ final class TdtDecoderStateV3Tests: XCTestCase {
 
     func testMLMultiArrayResetDataStaysInsideTheLogicalElements() throws {
         // A padded layout reports a byte span past its last element: shape [2, 10] with strides
-        // [16, 1] ends at element 26 while the span covers 32. Storage beyond the last element can
-        // belong to someone else, so the reset must not touch it.
+        // [16, 1] skips slots 10 to 15 between its rows and ends at element 26 while the span
+        // covers 32. Storage between the rows or beyond the last element can belong to someone
+        // else, so the reset must not touch it.
         let elements = 32
+        let outside = Array(10..<16) + Array(26..<elements)
         let storage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
         defer { storage.deallocate() }
         storage.initialize(repeating: 1, count: elements)
         let sentinel: Float = 12345
-        for i in 26..<elements {
+        for i in outside {
             storage[i] = sentinel
         }
         let view = try MLMultiArray(
@@ -294,8 +296,8 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         view.resetData(to: 0)
 
         verifyArrayIsZero(view)
-        for i in 26..<elements {
-            XCTAssertEqual(storage[i], sentinel, "Storage past the last element was written at \(i)")
+        for i in outside {
+            XCTAssertEqual(storage[i], sentinel, "Storage outside the elements was written at \(i)")
         }
     }
 
@@ -403,8 +405,9 @@ final class TdtDecoderStateV3Tests: XCTestCase {
 
     func testMLMultiArrayCopyDataStaysInsideTheLogicalElements() throws {
         // Same padded layout as the reset test: the copy must land every element and leave the
-        // destination's storage past its last element alone.
+        // destination's storage between the rows and past its last element alone.
         let elements = 32
+        let outside = Array(10..<16) + Array(26..<elements)
         let sourceStorage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
         let destinationStorage = UnsafeMutablePointer<Float>.allocate(capacity: elements)
         defer {
@@ -425,8 +428,8 @@ final class TdtDecoderStateV3Tests: XCTestCase {
         destinationView.copyData(from: sourceView)
 
         verifyArraysEqual(destinationView, sourceView)
-        for i in 26..<elements {
-            XCTAssertEqual(destinationStorage[i], sentinel, "Storage past the last element was written at \(i)")
+        for i in outside {
+            XCTAssertEqual(destinationStorage[i], sentinel, "Storage outside the elements was written at \(i)")
         }
     }