From 70993ea330cc37a0e8d55cac13ff736dc449cc66 Mon Sep 17 00:00:00 2001
From: Oddur Sigurdsson <oddurs@gmail.com>
Date: Fri, 11 Sep 2026 02:00:58 -0400
Subject: [PATCH] fix: split the bloom blur so every toolchain can type-check
 it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Swift 6.3.1 compiles the nested closure fine; the toolchain on the macOS runner
gives up on it, which is the worst way to find out — green locally, red in CI.

The two passes are now separate methods with explicit signatures and the index
arithmetic hoisted into named locals, so nothing in the expression is large
enough to strain inference. The composited frame is byte-identical before and
after at a fixed seed.
---
 Sources/Windflow/Canvas.swift | 80 +++++++++++++++++++++++------------
 1 file changed, 53 insertions(+), 27 deletions(-)

diff --git a/Sources/Windflow/Canvas.swift b/Sources/Windflow/Canvas.swift
index c176c37..c9ecd93 100644
--- a/Sources/Windflow/Canvas.swift
+++ b/Sources/Windflow/Canvas.swift
@@ -444,38 +444,64 @@ final class Canvas {
         blurBloom(radius: 4)
     }
 
+    /// Separable box blur over the bloom buffer.
+    ///
+    /// The two passes are separate methods with explicit signatures rather than
+    /// index arithmetic inlined into nested closures. Written that way, the
+    /// expression is large enough that some Swift toolchains give up type-checking
+    /// it — it compiles locally and fails on CI, which is the worst way to find out.
     private func blurBloom(radius: Int) {
-        let bw = bloomW, bh = bloomH
+        let bw = bloomW
+        let bh = bloomH
+        let inv = 1 / Float(radius * 2 + 1)
         bloom.withUnsafeMutableBufferPointer { src in
             bloomScratch.withUnsafeMutableBufferPointer { dst in
-                let inv = 1 / Float(radius * 2 + 1)
-                for y in 0..<bh {
-                    for c in 0..<3 {
-                        var acc: Float = 0
-                        for k in -radius...radius {
-                            acc += src[(y * bw + min(max(k, 0), bw - 1)) * 3 + c]
-                        }
-                        for x in 0..<bw {
-                            dst[(y * bw + x) * 3 + c] = acc * inv
-                            acc +=
-                                src[(y * bw + min(x + radius + 1, bw - 1)) * 3 + c]
-                                - src[(y * bw + max(x - radius, 0)) * 3 + c]
-                        }
-                    }
+                Canvas.blurRows(src: src, dst: dst, bw: bw, bh: bh, radius: radius, inv: inv)
+                Canvas.blurColumns(src: dst, dst: src, bw: bw, bh: bh, radius: radius, inv: inv)
+            }
+        }
+    }
+
+    private static func blurRows(
+        src: UnsafeMutableBufferPointer<Float>, dst: UnsafeMutableBufferPointer<Float>,
+        bw: Int, bh: Int, radius: Int, inv: Float
+    ) {
+        for y in 0..<bh {
+            let row = y * bw
+            for c in 0..<3 {
+                var acc: Float = 0
+                for k in -radius...radius {
+                    let x = min(max(k, 0), bw - 1)
+                    acc += src[(row + x) * 3 + c]
                 }
                 for x in 0..<bw {
-                    for c in 0..<3 {
-                        var acc: Float = 0
-                        for k in -radius...radius {
-                            acc += dst[(min(max(k, 0), bh - 1) * bw + x) * 3 + c]
-                        }
-                        for y in 0..<bh {
-                            src[(y * bw + x) * 3 + c] = acc * inv
-                            acc +=
-                                dst[(min(y + radius + 1, bh - 1) * bw + x) * 3 + c]
-                                - dst[(max(y - radius, 0) * bw + x) * 3 + c]
-                        }
-                    }
+                    dst[(row + x) * 3 + c] = acc * inv
+                    let incoming = min(x + radius + 1, bw - 1)
+                    let outgoing = max(x - radius, 0)
+                    acc += src[(row + incoming) * 3 + c]
+                    acc -= src[(row + outgoing) * 3 + c]
+                }
+            }
+        }
+    }
+
+    private static func blurColumns(
+        src: UnsafeMutableBufferPointer<Float>, dst: UnsafeMutableBufferPointer<Float>,
+        bw: Int, bh: Int, radius: Int, inv: Float
+    ) {
+        for x in 0..<bw {
+            for c in 0..<3 {
+                var acc: Float = 0
+                for k in -radius...radius {
+                    let y = min(max(k, 0), bh - 1)
+                    acc += src[(y * bw + x) * 3 + c]
+                }
+                for y in 0..<bh {
+                    dst[(y * bw + x) * 3 + c] = acc * inv
+                    let incoming = min(y + radius + 1, bh - 1)
+                    let outgoing = max(y - radius, 0)
+                    acc += src[(incoming * bw + x) * 3 + c]
+                    acc -= src[(outgoing * bw + x) * 3 + c]
                 }
             }
         }