Fix Swift 6.4 build errors from state handler refactor

Three issues introduced by apple#132 on the current toolchain:

1. StateHandler+MTLBuffer.swift: Remove insertAll(into: inout
   AsyncMutableViews). The CoreAI framework's @Lifetime(self:
   &mutableValue) on AsyncMutableViews.insert makes it impossible to
   abstract state insertion into a helper — all AsyncMutableValue
   declarations must live in the same flat scope as the consume site.
   Call sites now simply omit additional state insertion (the pipelined
   engine's hybrid model support needs a different approach — tracked
   separately).

2. CoreAISequentialEngine.swift: Delete dead ensureKVCapacity(),
   copyCache(), and zeroFill() methods that reference properties
   removed by the state handler refactor (kvCache: SyncStateHandler
   supersedes them).

3. StateHandler+NDArray.swift: Change zeroFillNDArray from private to
   internal so StateHandlerTests can access it via @testable import.

Author: stikves

swift/Sources/CoreAILanguageModels/Handlers/StateHandler+MTLBuffer.swift

@@ -48,16 +48,6 @@ public struct FixedMTLBufferState {
         get { bindings[index] }
     }
 
-    /// Insert all states into AsyncMutableViews for pipelined encoding.
-    public func insertAll(into views: inout InferenceFunction.AsyncMutableViews) {
-        for (name, buffer, scalarType, shape, strides) in bindings {
-            var value = unsafe InferenceFunction.AsyncMutableValue(
-                unsafeBuffer: buffer, byteOffset: 0,
-                scalarType: scalarType, shape: shape, strides: strides)
-            views.insert(&value, for: name)
-        }
-    }
-
     /// Zero all state buffers. Caller must ensure no in-flight GPU work references these.
     public mutating func reset() {
         for (_, buffer, _, _, _) in bindings {

swift/Sources/CoreAILanguageModels/Handlers/StateHandler+NDArray.swift

@@ -176,7 +176,7 @@ public struct GrowingNDArrayState: SyncStateHandler {
 // MARK: - Shared Utilities
 
 /// Zero-initialize an NDArray, dispatching on scalar type.
-private func zeroFillNDArray(_ array: inout NDArray) {
+func zeroFillNDArray(_ array: inout NDArray) {
     let count = array.shape.reduce(1, *)
     switch array.scalarType {
     case .float16, .bfloat16:

swift/Sources/CoreAILanguageModels/InferenceEngines/CoreAIPipelinedEngine.swift

@@ -829,7 +829,6 @@ private struct EngineImpl: ~Copyable {
         var asyncStates = InferenceFunction.AsyncMutableViews()
         asyncStates.insert(&keyState, for: keyCacheName)
         asyncStates.insert(&valState, for: valueCacheName)
-        additionalStates?.insertAll(into: &asyncStates)
 
         // Build Output as AsyncMutableValue (logits)
         // Decode uses per-step rotating buffer; prefill uses the shared growing buffer.
@@ -1141,7 +1140,6 @@ private struct EngineImpl: ~Copyable {
         var asyncStates = InferenceFunction.AsyncMutableViews()
         asyncStates.insert(&keyState, for: keyCacheName)
         asyncStates.insert(&valState, for: valueCacheName)
-        additionalStates?.insertAll(into: &asyncStates)
 
         let logitsShape = [1, queryLength, vocabSize]
         let logitsStrides = try resolvedStrides(descriptor: logitsBaseDesc, shape: logitsShape)
@@ -1248,7 +1246,6 @@ private struct EngineImpl: ~Copyable {
             var asyncStates = InferenceFunction.AsyncMutableViews()
             asyncStates.insert(&keyState, for: keyCacheName)
             asyncStates.insert(&valState, for: valueCacheName)
-            additionalStates?.insertAll(into: &asyncStates)
 
             let lShape = [1, shape, vocabSize]
             let lStrides = try resolvedStrides(descriptor: logitsBaseDesc, shape: lShape)

swift/Sources/CoreAILanguageModels/InferenceEngines/CoreAISequentialEngine.swift

@@ -475,84 +475,7 @@ public final class CoreAISequentialEngine: InferenceEngine, @unchecked Sendable
         cleanupSpan.end()
     }
 
-    // MARK: - KV Cache (dynamic growth)
-
-    private func ensureKVCapacity(forContextLength needed: Int) throws {
-        guard needed > currentKVCapacity else { return }
-        guard needed <= config.maxContextLength else {
-            throw InferenceRuntimeError.invalidState(
-                "Context length \(needed) exceeds maximum \(config.maxContextLength)")
-        }
-
-        var newCapacity = currentKVCapacity
-        while newCapacity < needed { newCapacity *= 2 }
-        newCapacity = min(newCapacity, config.maxContextLength)
-
-        let resolvedKeyDesc = keyCacheDescriptor.resolvingDynamicDimensions(
-            keyCacheDescriptor.shape.map { $0 < 0 ? newCapacity : $0 })
-        let resolvedValueDesc = valueCacheDescriptor.resolvingDynamicDimensions(
-            valueCacheDescriptor.shape.map { $0 < 0 ? newCapacity : $0 })
-
-        var newKeyCache = NDArray(descriptor: resolvedKeyDesc)
-        var newValueCache = NDArray(descriptor: resolvedValueDesc)
-        _ = newKeyCache.mutableRawView()
-        _ = newValueCache.mutableRawView()
-
-        try Self.copyCache(from: keyCache, to: &newKeyCache)
-        try Self.copyCache(from: valueCache, to: &newValueCache)
-
-        CLILogger.log("KV cache grew: \(currentKVCapacity) → \(newCapacity)")
-        keyCache = newKeyCache
-        valueCache = newValueCache
-        currentKVCapacity = newCapacity
-    }
-
-    private static func copyCache(from source: NDArray, to destination: inout NDArray) throws {
-        let srcShape = source.shape
-        let dstShape = destination.shape
-        guard let headDim = srcShape.last else {
-            throw InferenceRuntimeError.invalidState("KV cache has empty shape — cannot copy")
-        }
-        let seqDim = KVCacheFactory.detectSequenceDim(shape: srcShape)
-
-        // Number of independent blocks before the sequence dimension (L * B * H or B * H)
-        let numBlocks = srcShape[..<seqDim].reduce(1, *)
-        let oldSeqLen = srcShape[seqDim]
-        let copySize = oldSeqLen * headDim
-
-        // Strides in elements for the sequence block
-        let srcBlockStride = srcShape[seqDim...].reduce(1, *)  // S_old * D
-        let dstBlockStride = dstShape[seqDim...].reduce(1, *)  // S_new * D
-
-        source.view(as: LogitsScalarType.self).withUnsafePointer { srcPtr, _, _ in
-            let dstView = destination.mutableView(as: LogitsScalarType.self)
-            dstView.withUnsafeMutablePointer { dstPtr, _, _ in
-                for block in 0..<numBlocks {
-                    let srcOff = block * srcBlockStride
-                    let dstOff = block * dstBlockStride
-                    dstPtr.advanced(by: dstOff).update(
-                        from: srcPtr.advanced(by: srcOff), count: copySize)
-                }
-            }
-        }
-    }
-
     // MARK: - Helpers
-
-    private func zeroFill(_ array: inout NDArray) {
-        let count = array.shape.reduce(1, *)
-        let view = array.mutableView(as: LogitsScalarType.self)
-        // Inlined constant write — under -Onone, fillNDArray's
-        // `(Int) -> LogitsScalarType` closure is invoked per element (no inlining),
-        // which made zeroing the KV cache (~14.7M elements for a 32K-context
-        // Qwen3) take ~6 seconds per `reset()`. Direct loop keeps this in
-        // the few-ms range even unoptimized; under -O it lowers to memset.
-        view.withUnsafeMutablePointer { ptr, _, _ in
-            for i in 0..<count {
-                ptr[i] = 0
-            }
-        }
-    }
 }
 
 extension CoreAISequentialEngine {