diff --git a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
index b89de500..b25a65e1 100644
--- a/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
+++ b/Sources/FluidAudio/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderState.swift
@@ -94,17 +94,3 @@ public struct TdtDecoderState: Sendable {
         // Keep LSTM states as they represent the final linguistic context
     }
 }
-
-extension MLMultiArray {
-    func resetData(to value: NSNumber) {
-        for i in 0..<count {
-            self[i] = value
-        }
-    }
-
-    func copyData(from source: MLMultiArray) {
-        for i in 0..<count {
-            self[i] = source[i]
-        }
-    }
-}
diff --git a/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift b/Sources/FluidAudio/Shared/ANEMemoryOptimizer.swift
index aab43bc8..4541e473 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/Sources/FluidAudio/Shared/MLArrayCache.swift b/Sources/FluidAudio/Shared/MLArrayCache.swift
index b62ba4fb..29ea5995 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/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
index 779ece06..a6d6c399 100644
--- a/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
+++ b/Sources/FluidAudio/Shared/MLMultiArray+Extensions.swift
@@ -1,15 +1,70 @@
 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 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 {
+            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
+            }
+        }
+        let values = (0..<count).map { source[$0] }
+        for i in 0..<count {
+            self[i] = values[i]
         }
     }
 }
diff --git a/Sources/FluidAudio/Shared/ModelWarmup.swift b/Sources/FluidAudio/Shared/ModelWarmup.swift
index 6928fa1a..23054566 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/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
index 9bb0173a..3da64d91 100644
--- a/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
+++ b/Tests/FluidAudioTests/ASR/Parakeet/SlidingWindow/TDT/Decoder/TdtDecoderStateV3Tests.swift
@@ -183,6 +183,34 @@ 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)
+
+        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)
+        verifyArrayHasValue(array, value: 1.5)
+
+        array.resetData(to: 0)
+        verifyArrayIsZero(array)
+    }
+
     func testMLMultiArrayResetDataNonFloat() throws {
         let array = try MLMultiArray(shape: [5, 3], dataType: .int32)
 
@@ -200,6 +228,79 @@ 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] 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 outside {
+            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 outside {
+            XCTAssertEqual(storage[i], sentinel, "Storage outside the elements 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)
@@ -214,6 +315,124 @@ 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. 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)
+        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)
+
+        fillArrayWithTestData(sourceArray, multiplier: 1.5)
+
+        destArray.copyData(from: sourceArray)
+
+        verifyArraysEqual(destArray, sourceArray)
+    }
+
+    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)
+
+        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)
+
+        array.copyData(from: array)
+
+        verifyArraysEqual(array, expected)
+    }
+
+    func testMLMultiArrayCopyDataStaysInsideTheLogicalElements() throws {
+        // Same padded layout as the reset test: the copy must land every element and leave the
+        // 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 {
+            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 outside {
+            XCTAssertEqual(destinationStorage[i], sentinel, "Storage outside the elements 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)
diff --git a/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift b/Tests/FluidAudioTests/Shared/ANEMemoryOptimizerTests.swift
index 0bf57ba4..af6d5f2d 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] = []
diff --git a/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift b/Tests/FluidAudioTests/Shared/MLArrayCacheTests.swift
index 09673423..16728596 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 {
diff --git a/Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift b/Tests/FluidAudioTests/Shared/MLMultiArrayExtensionsTests.swift
new file mode 100644
index 00000000..08b5f381
--- /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")
+        }
+    }
+}