@swiftbrowser/native 0.23.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/native",
-  "version": "0.23.0",
+  "version": "0.26.0",
   "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.23.0",
-    "@swiftbrowser/web": "0.23.0",
+    "@swiftbrowser/react": "0.26.0",
+    "@swiftbrowser/web": "0.26.0",
     "esbuild": "^0.28.2",
     "react-refresh": "^0.17.0"
   },

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

@@ -42,7 +42,9 @@ import Foundation
 /// Block processing: a block runs in chunks of 16 frames, each instruction over every frame of the chunk for every
 /// sounding lane, but for a stream's serial part (feedback through state, which it schedules when it loads the
 /// program), which runs frame by frame within the chunk. Unlike the JavaScript machine's, a register holds a frame's lanes side by side,
-/// then the next frame's, so the loops over lanes stay vector loops; the results are the same.
+/// then the next frame's, so the loops over lanes stay vector loops; the results are the same. The lanes side by side are
+/// those that run: the sounding voices' (up to the highest), or the master stage's one, so every instruction runs over
+/// one span of memory, however many voices sound.
 public final class DSPMachine: @unchecked Sendable {
     public let program: DSPProgram
     public let sampleRate: Float
@@ -50,8 +52,8 @@ public final class DSPMachine: @unchecked Sendable {
     private static let lanes = 16
     /// Frames a chunk has: each instruction runs over a chunk's frames together (block processing).
     private static let frames = 16
-    /// The registers, each `width` values: a chunk's frames one after another, each its lanes (as many as the
-    /// program has voices) side by side, so an instruction runs over lanes as a SIMD vector and a builtin's state
+    /// The registers, each `width` values: a chunk's frames one after another, each its lanes (as many as run: the
+    /// sounding voices', or the master stage's one) side by side, so an instruction runs over lanes as a SIMD vector and a builtin's state
     /// follows its lanes; a state register's value is its lane's at the first frame.
     private let registers: UnsafeMutablePointer<Float>
     private let width: Int
@@ -709,6 +711,8 @@ public final class DSPMachine: @unchecked Sendable {
             guard renamedMask[r] == 0, k % 2 == 0 || parameterMask[r] != 0 else { return false }
         }
         let start = index * DSPProgram.routesMax
+        // The same list again: nothing to make again.
+        if routeCounts[index] == list.count && (0..<list.count).allSatisfy({ routeRegisters[start + $0] == Int(list.pointer[$0]) * width }) { return true }
         for k in 0..<list.count {
             let r = Int(list.pointer[k])
             routeRegisters[start + k] = r * width
@@ -1393,6 +1397,8 @@ public final class DSPMachine: @unchecked Sendable {
                 resetLane(l)
             }
             resetMaster()
+            // Nothing sounds: what is set before the next block jumps there, with no glide (a preset loaded as data).
+            snapped = true
         default:
             break
         }
@@ -1529,7 +1535,8 @@ public final class DSPMachine: @unchecked Sendable {
             return
         }
         if any {
-            let V = program.voices
+            // A frame's lanes side by side, as many as sound this block (`run`).
+            let V = lanes
             for l in 0..<V {
                 let note = laneNote[l]
                 let freq = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
@@ -1552,19 +1559,20 @@ public final class DSPMachine: @unchecked Sendable {
                 l >= 0 ? laneVelocity[l] : 0,
                 note >= 0 ? Float(note) : 0,
             ]
-            let V = program.voices
-            for (i, value) in values.enumerated() { for k in 0..<F { R[(7 + i) * W + k * V] = value } }
+            // The master stage's one lane: a frame after another.
+            for (i, value) in values.enumerated() { for k in 0..<F { R[(7 + i) * W + k] = value } }
         }
         let o = R + program.output * W
         let or = R + (program.outputRight ?? program.output) * W
-        let V = program.voices
+        let V = Swift.max(lanes, 1)
         var check: Float = 0
         // A chunk of up to 16 frames at a time: each instruction over all of them, the serial part frame by frame.
         var chunk = 0
         while chunk < n {
             let fc = Swift.min(F, n - chunk)
+            let start = beat
             for k in 0..<fc {
-                for l in 0..<Swift.max(lanes, 1) { R[6 * W + k * V + l] = Float(beat) }
+                for l in 0..<V { R[6 * W + k * V + l] = Float(beat) }
                 beat += beatStep
             }
             if any {
@@ -1585,8 +1593,8 @@ public final class DSPMachine: @unchecked Sendable {
                     }
                 }
                 if let master {
-                    R[master.inputs[0] * W + k * V] = leftSum
-                    R[master.inputs[1] * W + k * V] = rightSum
+                    R[master.inputs[0] * W + k] = leftSum
+                    R[master.inputs[1] * W + k] = rightSum
                 } else {
                     if let right {
                         out[chunk + k] = leftSum
@@ -1598,14 +1606,20 @@ public final class DSPMachine: @unchecked Sendable {
                 }
             }
             if let master {
+                // The beat in the master stage's one lane: a frame after another, added up as the voices' was.
+                var at = start
+                for k in 0..<fc {
+                    R[6 * W + k] = Float(at)
+                    at += beatStep
+                }
                 run(masterCode, 0..<masterSerial.lowerBound, lanes: 1, trigger: masterTrigger, frames: fc)
                 if !masterSerial.isEmpty {
                     for k in 0..<fc { run(masterCode, masterSerial, lanes: 1, trigger: masterTrigger, frames: 1, frame: k) }
                 }
                 run(masterCode, masterSerial.upperBound..<masterCount, lanes: 1, trigger: masterTrigger, frames: fc)
                 for k in 0..<fc {
-                    let leftSum = R[master.outputs[0] * W + k * V]
-                    let rightSum = R[master.outputs[1] * W + k * V]
+                    let leftSum = R[master.outputs[0] * W + k]
+                    let rightSum = R[master.outputs[1] * W + k]
                     if let right {
                         out[chunk + k] = leftSum
                         right[chunk + k] = rightSum
@@ -1675,7 +1689,9 @@ public final class DSPMachine: @unchecked Sendable {
         let sr = sampleRate
         let serial = frame >= 0
         let fc = serial ? 1 : frames
-        let V = program.voices
+        // A frame's lanes side by side, as many as run (the sounding voices', or the master stage's one): every
+        // instruction then runs over one span of memory.
+        let V = Swift.max(lanes, 1)
         let shift = serial ? frame * V : 0
         // A stateless instruction: every lane's frames at once (the chunk's last ones, past fc, go unread), the
         // sounding lanes of each frame; in the serial part, the one frame's.