@swiftbrowser/native 0.26.1 → 0.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/native",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "type": "module",
   "description": "Run a @swiftbrowser/react app natively: the runtime a JavaScriptCore-hosted app needs (timers, console, fetch and the other web globals over the SwiftBrowser Native bridge), the `run` entry that renders into the native SwiftUI renderer, and the bundler that builds app.js for the Xcode target.",
   "repository": {
@@ -63,8 +63,8 @@
   },
   "dependencies": {
     "@babel/core": "^7.29.7",
-    "@swiftbrowser/react": "0.26.1",
-    "@swiftbrowser/web": "0.26.1",
+    "@swiftbrowser/react": "0.26.2",
+    "@swiftbrowser/web": "0.26.2",
     "esbuild": "^0.28.2",
     "react-refresh": "^0.17.0"
   },

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSPCore/Machine.swift

@@ -198,6 +198,11 @@ public final class DSPMachine: @unchecked Sendable {
     /// Re-rating: per register whether it may change from frame to frame, and the sample stream's instructions kept.
     private let changing: UnsafeMutablePointer<UInt8>
     private let keptSample: UnsafeMutablePointer<Int32>
+    /// Per register whether it may change from frame to frame within a block, as the streams were last made: what the
+    /// sample stream (as it stays after re-rating) and the master stage write, state, the beat, a region's results and
+    /// a choice. A filter whose cutoff and resonance do not works out its coefficients once a chunk.
+    private let framewise: UnsafeMutablePointer<UInt8>
+    private let registerCount: Int
 
     private let laneNote: UnsafeMutablePointer<Int32>
     private let laneGate: UnsafeMutablePointer<Float>
@@ -310,6 +315,8 @@ public final class DSPMachine: @unchecked Sendable {
         pinnedMask = mask()
         routedMask = mask()
         changing = mask()
+        framewise = mask()
+        self.registerCount = registerCount
         for p in program.parameters { parameterMask[p.register] = 1 }
         for r in stateRegisters { stateMask[r] = 1 }
         for c in program.choices { renamedMask[c.register] = 1 }
@@ -505,7 +512,7 @@ public final class DSPMachine: @unchecked Sendable {
         routeRegisters.deallocate()
         routeCounts.deallocate()
         routeState.deallocate()
-        for pointer in [parameterMask, stateMask, renamedMask, pinnedMask, routedMask, changing] { pointer.deallocate() }
+        for pointer in [parameterMask, stateMask, renamedMask, pinnedMask, routedMask, changing, framewise] { pointer.deallocate() }
         constantValues.deallocate()
         parameterLowest.deallocate()
         parameterHighest.deallocate()
@@ -617,6 +624,11 @@ public final class DSPMachine: @unchecked Sendable {
         sampleSerial = reschedule(sampleCount, from: keptSample, into: sampleCode)
         masterCount = masters
         masterSerial = reschedule(masters, from: orderedMaster, into: masterCode)
+        let stride = Int32(width)
+        for r in 0..<registerCount { framewise[r] = stateMask[r] | renamedMask[r] }
+        framewise[6] = 1
+        for i in 0..<sampleCount { framewise[Int(keptSample[i * 12 + 1] / stride)] = 1 }
+        for i in 0..<masters { framewise[Int(orderedMaster[i * 12 + 1] / stride)] = 1 }
         return true
     }
 
@@ -1656,17 +1668,49 @@ public final class DSPMachine: @unchecked Sendable {
         }
     }
 
+    /// PolyBLEP's correction near a wrap (`t` the phase, `dt` its step; 0 for a step of 0 or less): both sides worked
+    /// out and one chosen, with no branch, so a loop of them vectorizes.
     @inline(__always)
     private static func blep(_ t: Float, _ dt: Float) -> Float {
-        if t < dt {
-            let x = t / dt
-            return x + x - x * x - 1
-        }
-        if t > 1 - dt {
-            let x = (t - 1) / dt
-            return x * x + x + x + 1
-        }
-        return 0
+        let x0 = t / dt
+        let x1 = (t - 1) / dt
+        let rising = x0 + x0 - x0 * x0 - 1
+        let falling = x1 * x1 + x1 + x1 + 1
+        return dt > 0 ? (t < dt ? rising : t > 1 - dt ? falling : 0) : 0
+    }
+
+    /// sin(2π p) for a phase `p`: folded into a quarter cycle, then Taylor's polynomial to x¹¹, in floats with no
+    /// branch, so a loop of them vectorizes. Within 2e-7 of sin; machine.ts takes JavaScript's own.
+    @inline(__always)
+    static func sin2pi(_ p: Float) -> Float {
+        let q = p - (p + 0.5).rounded(.down)
+        let h = q > 0.25 ? 0.5 - q : q < -0.25 ? -0.5 - q : q
+        let x = h * (2 * Float.pi)
+        let z = x * x
+        var s: Float = -2.5052108e-8
+        s = s * z + 2.7557319e-6
+        s = s * z - 1.9841270e-4
+        s = s * z + 8.3333333e-3
+        s = s * z - 0.16666667
+        return x + x * z * s
+    }
+
+    /// tan(x) for 0 … π/2 (a filter's prewarp): Cephes' tanf polynomial up to π/4, and 1 / tan(π/2 − x) past it, in
+    /// floats with no branch, so a loop of them vectorizes. Within 1.5e-6 of tan (a cutoff 0.0002% off at the top of
+    /// the range), where machine.ts takes JavaScript's own, faster there than any polynomial in emulated floats.
+    @inline(__always)
+    static func tan(_ x: Float) -> Float {
+        let upper = x > 0.78539816
+        let y = upper ? 1.5707964 - x : x
+        let z = y * y
+        var p: Float = 9.38540185543e-3
+        p = p * z + 3.11992232697e-3
+        p = p * z + 2.44301354525e-2
+        p = p * z + 5.34112807005e-2
+        p = p * z + 1.33387994085e-1
+        p = p * z + 3.33331568548e-1
+        let t = p * z * y + y
+        return upper ? 1 / t : t
     }
 
     /// A table's, shape's or sample's index from its register: in range, or the first.
@@ -1851,32 +1895,63 @@ public final class DSPMachine: @unchecked Sendable {
                     }
                 }
             case 40, 41, 42, 43, 44:
-                // Oscillators: the output from the phase now, then the phase steps by freq / sampleRate.
+                // Oscillators: the output from the phase now, then the phase steps by freq / sampleRate. A loop for
+                // each, with no branch in it and its index arithmetic unchecked (an overflow check would keep it from
+                // vectorizing), so each runs across the lanes at once.
                 let s = S + Int(code[at + 7])
-                for fk in 0..<fc {
-                    for l in 0..<lanes {
-                        let el = fk * V + l
-                        let p = s[l]
-                        let dt = a[el] / sr
-                        var v: Float
-                        switch op {
-                        case 40: v = p
-                        case 41: v = Foundation.sin(2 * Float.pi * p)
-                        case 42:
-                            v = 2 * p - 1
-                            if dt > 0 { v -= Self.blep(p, dt) }
-                        case 43:
+                @inline(__always) func step(_ l: Int, _ p: Float, _ dt: Float) {
+                    let next = p + dt
+                    s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
+                }
+                switch op {
+                case 40:
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let p = s[l]
+                            d[el] = p
+                            step(l, p, a[el] / sr)
+                        }
+                    }
+                case 41:
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let p = s[l]
+                            d[el] = Self.sin2pi(p)
+                            step(l, p, a[el] / sr)
+                        }
+                    }
+                case 42:
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let p = s[l]
+                            let dt = a[el] / sr
+                            d[el] = 2 * p - 1 - Self.blep(p, dt)
+                            step(l, p, dt)
+                        }
+                    }
+                case 43:
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let p = s[l]
+                            let dt = a[el] / sr
                             let w = Swift.min(Swift.max(b[el], 0), 1)
-                            v = p < w ? 1 : -1
-                            if dt > 0 {
-                                let q = p + 1 - w
-                                v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
-                            }
-                        default: v = 1 - 4 * Swift.abs(p - 0.5)
+                            let q = p + 1 - w
+                            d[el] = (p < w ? 1 : -1) + Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                            step(l, p, dt)
+                        }
+                    }
+                default:
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let p = s[l]
+                            d[el] = 1 - 4 * Swift.abs(p - 0.5)
+                            step(l, p, a[el] / sr)
                         }
-                        d[el] = v
-                        let next = p + dt
-                        s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
                     }
                 }
             case 45:
@@ -1990,34 +2065,49 @@ public final class DSPMachine: @unchecked Sendable {
             case 47, 48, 49:
                 // A state-variable filter (Simper's form): resonance 0 … 1.
                 let s = S + Int(code[at + 7])
-                for fk in 0..<fc {
+                // Its coefficients with the polynomial tan, in loops with no branch and their index arithmetic
+                // unchecked, so they vectorize: once a chunk where the cutoff and resonance are set once a block, every
+                // frame where they move (an envelope's cutoff), which costs less than keeping them for when they do not.
+                @inline(__always) func coefficients(_ cutoffIn: Float, _ resonanceIn: Float) -> (a1: Float, a2: Float, a3: Float, k: Float) {
+                    let cutoff = Swift.min(Swift.max(cutoffIn, 10), 0.49 * sr)
+                    let resonance = Swift.min(Swift.max(resonanceIn, 0), 0.98)
+                    let g = Self.tan(Float.pi * cutoff / sr)
+                    let k = 2 - 2 * resonance
+                    let a1 = 1 / (1 + g * (g + k))
+                    return (a1, g * a1, g * g * a1, k)
+                }
+                @inline(__always) func step(_ l: Int, _ el: Int, _ a1: Float, _ a2: Float, _ a3: Float, _ k: Float) {
+                    let ic1 = s[l]
+                    let ic2 = s[L &+ l]
+                    let x = a[el]
+                    let v3 = x - ic2
+                    let v1 = a1 * ic1 + a2 * v3
+                    let v2 = ic2 + a2 * ic1 + a3 * v3
+                    s[l] = 2 * v1 - ic1
+                    s[L &+ l] = 2 * v2 - ic2
+                    d[el] = op == 47 ? v2 : op == 49 ? v1 : x - k * v1 - v2
+                }
+                let held = !serial && framewise[Int(code[at + 3]) / width] == 0 && framewise[Int(code[at + 4]) / width] == 0
+                if held {
                     for l in 0..<lanes {
-                        let el = fk * V + l
-                        let cutoff = Swift.min(Swift.max(b[el], 10), 0.49 * sr)
-                        let resonance = Swift.min(Swift.max(c[el], 0), 0.98)
-                        if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
-                            s[2 * L + l] = cutoff
-                            s[3 * L + l] = resonance
-                            let g = Foundation.tan(Float.pi * cutoff / sr)
-                            let k = 2 - 2 * resonance
-                            let a1 = 1 / (1 + g * (g + k))
-                            s[4 * L + l] = a1
-                            s[5 * L + l] = g * a1
-                            s[6 * L + l] = g * g * a1
-                            s[7 * L + l] = k
+                        let (a1, a2, a3, k) = coefficients(b[l], c[l])
+                        s[4 &* L &+ l] = a1
+                        s[5 &* L &+ l] = a2
+                        s[6 &* L &+ l] = a3
+                        s[7 &* L &+ l] = k
+                    }
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            step(l, fk &* V &+ l, s[4 &* L &+ l], s[5 &* L &+ l], s[6 &* L &+ l], s[7 &* L &+ l])
+                        }
+                    }
+                } else {
+                    for fk in 0..<fc {
+                        for l in 0..<lanes {
+                            let el = fk &* V &+ l
+                            let (a1, a2, a3, k) = coefficients(b[el], c[el])
+                            step(l, el, a1, a2, a3, k)
                         }
-                        let a1 = s[4 * L + l]
-                        let a2 = s[5 * L + l]
-                        let a3 = s[6 * L + l]
-                        let ic1 = s[l]
-                        let ic2 = s[L + l]
-                        let x = a[el]
-                        let v3 = x - ic2
-                        let v1 = a1 * ic1 + a2 * v3
-                        let v2 = ic2 + a2 * ic1 + a3 * v3
-                        s[l] = 2 * v1 - ic1
-                        s[L + l] = 2 * v2 - ic2
-                        d[el] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
                     }
                 }
             case 50:

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Shapes.swift

@@ -79,7 +79,9 @@ extension AnyShape {
         case "ellipse": self = AnyShape(Ellipse())
         case "roundedRectangle", "containerRelative": self = AnyShape(RoundedRectangle(cornerRadius: spec.cornerRadius, style: .continuous))
         case "path":
-            if let data = spec.path, !data.isEmpty, let parsed = Path(svg: data) {
+            if let affine = spec.affinePath {
+                self = AnyShape(AffinePathShape(affine: affine))
+            } else if let data = spec.path, !data.isEmpty, let parsed = Path(svg: data) {
                 self = AnyShape(PathShape(path: parsed, size: spec.size.map { CGSize(width: $0.width, height: $0.height) }))
             } else {
                 // No path yet (the size is not reported), or none to read: nothing to draw.
@@ -117,6 +119,15 @@ struct NoPathShape: Shape {
     func path(in rect: CGRect) -> Path { Path() }
 }
 
+/// A custom shape whose path is drawn for the rectangle it is laid out in,
+/// from its first layout (`AffinePath`).
+struct AffinePathShape: Shape {
+    let affine: AffinePath
+    func path(in rect: CGRect) -> Path {
+        (Path(svg: affine.data(width: rect.width, height: rect.height)) ?? Path()).offsetBy(dx: rect.minX, dy: rect.minY)
+    }
+}
+
 struct PathShape: Shape {
     let path: Path
     let size: CGSize?

package/swift/Sources/SwiftBrowserProtocol/Props.swift

@@ -376,6 +376,8 @@ public struct ShapeProps: Equatable, Sendable {
     public var path: String?
     /// The size `path` was drawn for.
     public var size: SizeSpec?
+    /// A path for any size, in place of `path` and `size`.
+    public var affinePath: AffinePath?
     public init(props: JSONObject) {
         shape = props.string("shape") ?? "rectangle"
         cornerRadius = props.double("cornerRadius") ?? 0
@@ -386,6 +388,7 @@ public struct ShapeProps: Equatable, Sendable {
         trimTo = props.object("trim")?.double("to")
         path = props.string("path")
         size = SizeSpec(json: props.value("size"))
+        affinePath = AffinePath(json: props.value("affinePath"))
     }
 }
 

package/swift/Sources/SwiftBrowserProtocol/SVGPath.swift

@@ -258,3 +258,70 @@ private struct PathScanner {
         return byte == UInt8(ascii: "1")
     }
 }
+
+/// A custom shape's path for any size (`affinePath`): SVG path data whose
+/// numbers are their values for an empty rectangle, the `i`th growing
+/// `width[i]` a point of the shape's width and `height[i]` a point of its
+/// height. @swiftbrowser/react sends one for a path whose every number is
+/// such a function of the size, so the shape is drawn at the size it is laid
+/// out at with no size reported.
+public struct AffinePath: Equatable, Sendable {
+    public var path: String
+    public var width: [Double]
+    public var height: [Double]
+
+    public init(path: String, width: [Double], height: [Double]) {
+        self.path = path
+        self.width = width
+        self.height = height
+    }
+
+    public init?(json: JSONValue) {
+        guard let path = json["path"].string else { return nil }
+        self.path = path
+        width = (json["width"].array ?? []).map { $0.double ?? 0 }
+        height = (json["height"].array ?? []).map { $0.double ?? 0 }
+    }
+
+    /// The path data for a `width` by `height` rectangle, its points rounded
+    /// to hundredths as @swiftbrowser/react's `Path` rounds them.
+    public func data(width w: Double, height h: Double) -> String {
+        let bytes = Array(path.utf8)
+        var out = ""
+        out.reserveCapacity(bytes.count + bytes.count / 4)
+        var index = 0
+        var at = 0
+        func isDigit(_ i: Int) -> Bool { i < bytes.count && bytes[i] >= 0x30 && bytes[i] <= 0x39 }
+        while at < bytes.count {
+            let byte = bytes[at]
+            // A number: an optional minus, digits with a point among or before them, an exponent.
+            let starts = isDigit(at) || (byte == 0x2E && isDigit(at + 1)) || (byte == 0x2D && (isDigit(at + 1) || (at + 2 < bytes.count && bytes[at + 1] == 0x2E && isDigit(at + 2))))
+            guard starts else {
+                out.unicodeScalars.append(Unicode.Scalar(byte))
+                at += 1
+                continue
+            }
+            var end = at + (byte == 0x2D ? 1 : 0)
+            while isDigit(end) { end += 1 }
+            if end < bytes.count && bytes[end] == 0x2E {
+                end += 1
+                while isDigit(end) { end += 1 }
+            }
+            if end < bytes.count && (bytes[end] == 0x65 || bytes[end] == 0x45) {
+                var exponent = end + 1
+                if exponent < bytes.count && (bytes[exponent] == 0x2B || bytes[exponent] == 0x2D) { exponent += 1 }
+                if isDigit(exponent) {
+                    end = exponent
+                    while isDigit(end) { end += 1 }
+                }
+            }
+            let value = (Double(String(decoding: bytes[at..<end], as: UTF8.self)) ?? 0)
+                + w * (index < width.count ? width[index] : 0) + h * (index < height.count ? height[index] : 0)
+            let rounded = (value * 100).rounded() / 100
+            out += rounded == 0 ? "0" : rounded == rounded.rounded() && Swift.abs(rounded) < 1e15 ? String(Int(rounded)) : String(rounded)
+            index += 1
+            at = end
+        }
+        return out
+    }
+}

package/wasm/SwiftBrowserNative.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/wasm/SwiftBrowserNative.wasm
-size: 50265117 bytes
-sha256: f7cb92276a436e8c765a5eca556c7436d02752c411256b0d6ff4e2ca33950635
+size: 50270516 bytes
+sha256: 4ab90fcf8d11104965a65927418d4cf6f47e4595cfc42a018cecb08ee849644e