@swiftbrowser/native 0.21.0 → 0.25.0

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

@@ -8,8 +8,8 @@ import Foundation
 /// register, the opcode's operands and, for a stateful builtin, its instance.
 /// A voice may have a right side (`outputRight`), and the `master` stage
 /// runs after the voices (in lane 0). The machine runs `sample` and `master`
-/// a chunk of frames at a time, all but their `serial` parts (word offsets),
-/// which touch state and run frame by frame (block processing).
+/// a chunk of frames at a time, all but the parts that touch state, which it
+/// schedules to run frame by frame when it loads them (block processing).
 public struct DSPProgram: Sendable, Equatable {
     public struct Parameter: Sendable, Equatable {
         public let name: String
@@ -53,8 +53,6 @@ public struct DSPProgram: Sendable, Equatable {
     /// over at every note.
     public struct Master: Sendable, Equatable {
         public let code: [Int32]
-        /// The part of `code` that runs frame by frame, in words.
-        public let serial: Range<Int>?
         public let inputs: [Int]
         public let outputs: [Int]
     }
@@ -68,6 +66,10 @@ public struct DSPProgram: Sendable, Equatable {
     public let voices: Int
     /// Absent, polyphonic.
     public let mode: Mode?
+    /// The voicing as parameters (program.ts `voicing`, their indices), read at each note: how many voices play
+    /// (rounded, 1 … `voices`), and the mode (rounded: 0 as many, 1 mono, 2 legato) in place of `mode`.
+    public let voicingVoices: Int?
+    public let voicingMode: Int?
     public let registers: Int
     public let constants: [(register: Int, value: Float)]
     public let parameters: [Parameter]
@@ -82,18 +84,50 @@ public struct DSPProgram: Sendable, Equatable {
     public let curves: [Curve]
     public let block: [Int32]
     public let sample: [Int32]
-    /// The part of `sample` that runs frame by frame, in words.
-    public let serial: Range<Int>?
     /// The voice's left side, or both with no `outputRight`.
     public let output: Int
     public let outputRight: Int?
     public let master: Master?
+    /// Gated regions (program.ts `groups`): each one's parameter, the region it is inside (-1 none) and its results.
+    public let groups: [Gate]
+    /// Each instruction's region in `sample` and `master` (-1 none).
+    public let sampleGates: [Int32]?
+    public let masterGates: [Int32]?
+    /// Choices (program.ts `choices`): each a register read as one of its options, the one its parameter names.
+    public let choices: [Choice]
+
+    /// A choice: `register`, which no instruction writes, read as `options[round(parameter's set value × scale)]`
+    /// (clamped). What no choice picks, nor anything else needs, the machine does not run.
+    public struct Choice: Sendable, Equatable {
+        public let parameter: Int
+        public let register: Int
+        public let options: [Int]
+        /// What the parameter's value is multiplied by before it is rounded to an option.
+        public var scale: Double = 1
+    }
+
+    /// The most options a choice has.
+    public static let choiceOptionsMax = 256
+
+    /// A region: it runs while `parameter` (its index) is set above 0.5 and the region around it runs.
+    public struct Gate: Sendable, Equatable {
+        public let parameter: Int
+        public let parent: Int
+        public let outputs: [Output]
+    }
+
+    /// A region's result: a register no instruction writes, read as `on` while the region runs and `off` while not.
+    public struct Output: Sendable, Equatable {
+        public let register: Int
+        public let on: Int
+        public let off: Int
+    }
 
     public static func == (a: DSPProgram, b: DSPProgram) -> Bool {
         a.voices == b.voices && a.mode == b.mode && a.registers == b.registers && a.constants.map(\.register) == b.constants.map(\.register)
             && a.constants.map(\.value) == b.constants.map(\.value) && a.parameters == b.parameters && a.state == b.state
             && a.instances == b.instances && a.tables == b.tables && a.shapes == b.shapes && a.samples == b.samples && a.routes == b.routes && a.curves == b.curves
-            && a.block == b.block && a.sample == b.sample && a.serial == b.serial && a.output == b.output && a.outputRight == b.outputRight && a.master == b.master
+            && a.block == b.block && a.sample == b.sample && a.output == b.output && a.outputRight == b.outputRight && a.master == b.master
     }
 
     public static let format = "swiftbrowser-dsp"
@@ -116,9 +150,10 @@ public struct DSPProgram: Sendable, Equatable {
     /// An envelope's curves: the exponents its attack, decay and release are bent by (1 as without).
     public struct Curve: Equatable, Sendable {
         public let instance: Int
-        public let attack: Float
-        public let decay: Float
-        public let release: Float
+        /// The registers its exponents are read from, each frame (held to 1/16 … 16).
+        public let attack: Int
+        public let decay: Int
+        public let release: Int
     }
     /// The longest a delay may be, in seconds.
     public static let delaySecondsMax: Float = 2
@@ -126,6 +161,8 @@ public struct DSPProgram: Sendable, Equatable {
     public static let shapePointsMax = 4096
     public static let shapesPointsMax = 65_536
     public static let samplesMax = 8_000_000
+    /// The most registers a route list has (128 routes): a machine keeps room for a list this long.
+    public static let routesMax = 256
 
     /// The program the JSON describes, checked: every register, operand and instance in range.
     public init(json: String) throws {
@@ -279,6 +316,7 @@ public struct DSPProgram: Sendable, Equatable {
             guard let lists = routes as? [[Any]] else { throw DSPProgramError("routes must be an array of lists") }
             parsedRoutes = try lists.map { list in
                 guard list.count % 2 == 0 else { throw DSPProgramError("a route list is source and amount registers, pair after pair") }
+                guard list.count <= Self.routesMax else { throw DSPProgramError("a route list has more than \(Self.routesMax) registers") }
                 let registers = try list.map { try register($0, "route") }
                 // An amount is a parameter, the same in every lane: the machine tests it once for all of them.
                 for k in stride(from: 1, to: registers.count, by: 2) where !parsedParameters.contains(where: { $0.register == registers[k] }) {
@@ -294,8 +332,7 @@ public struct DSPProgram: Sendable, Equatable {
                 guard entry.count == 4, let instance = Self.int(entry[0]), instances.indices.contains(instance), instances[instance] == .adsr else {
                     throw DSPProgramError("a curve is [instance, attack, decay, release] for an adsr")
                 }
-                let exponents = try entry.dropFirst().map { try number($0, "curve") }
-                guard exponents.allSatisfy({ Self.curveRange.contains($0) }) else { throw DSPProgramError("a curve's exponents are 1/16 … 16") }
+                let exponents = try entry.dropFirst().map { try register($0, "curve") }
                 return Curve(instance: instance, attack: exponents[0], decay: exponents[1], release: exponents[2])
             }
         }
@@ -304,33 +341,21 @@ public struct DSPProgram: Sendable, Equatable {
         for r in [output, outputRight].compactMap({ $0 }) + (masterParts?.outputs ?? []) where stateRegisters.contains(r) {
             throw DSPProgramError("output register \(r) is state")
         }
-        func serial(_ key: String) throws -> Range<Int>? {
-            guard let value = root[key] else { return nil }
-            guard let pair = value as? [Any], pair.count == 2, let from = Self.int(pair[0]), let to = Self.int(pair[1]), from >= 0, from <= to else {
-                throw DSPProgramError("\(key) is not [from, to)")
-            }
-            return from..<to
-        }
-        func code(_ key: String, serial: Range<Int>?) throws -> [Int32] {
+        /// Every register an instruction writes.
+        var written = Set<Int>()
+        func code(_ key: String) throws -> [Int32] {
             guard let words = root[key] as? [Any] else { throw DSPProgramError("\(key) must be an array") }
             let code = try words.map { word -> Int32 in
                 guard let n = Self.int(word), n >= Int(Int32.min), n <= Int(Int32.max) else { throw DSPProgramError("\(key): a word is not a whole number") }
                 return Int32(n)
             }
-            if let serial, serial.upperBound > code.count { throw DSPProgramError("\(key)'s serial part is not [from, to) within it") }
-            var boundaries = 0
             var pc = 0
             while pc < code.count {
-                if let serial { boundaries += (pc == serial.lowerBound ? 1 : 0) + (pc == serial.upperBound ? 1 : 0) }
                 guard let op = DSPOpcode(rawValue: code[pc]) else { throw DSPProgramError("\(key): unknown opcode \(code[pc]) at \(pc)") }
                 let length = 2 + op.arity + (op.builtin == nil ? 0 : 1)
                 guard pc + length <= code.count else { throw DSPProgramError("\(key): \(op) at \(pc) is cut off") }
                 for i in 1..<(2 + op.arity) { _ = try register(Int(code[pc + i]), "\(key) \(op) at \(pc)") }
-                // State is a voice's value, not a frame's: only the part that runs frame by frame reads or writes it.
-                let inSerial = serial?.contains(pc) ?? false
-                if !inSerial && (1..<(2 + op.arity)).contains(where: { stateRegisters.contains(Int(code[pc + $0])) }) {
-                    throw DSPProgramError("\(key): \(op) at \(pc) reads or writes state outside the serial part")
-                }
+                written.insert(Int(code[pc + 1]))
                 if let builtin = op.builtin {
                     let instance = Int(code[pc + length - 1])
                     guard instances.indices.contains(instance), instances[instance] == builtin else {
@@ -351,9 +376,6 @@ public struct DSPProgram: Sendable, Equatable {
                     guard !parsedRoutes[Int(index)].contains(Int(code[pc + 1])) else {
                         throw DSPProgramError("\(key): modsum at \(pc) writes a register its routes read")
                     }
-                    guard inSerial || !parsedRoutes[Int(index)].contains(where: { stateRegisters.contains($0) }) else {
-                        throw DSPProgramError("\(key): modsum at \(pc) reads state outside the serial part")
-                    }
                 } else if let longestAt = op.longest {
                     guard let longest = constantValues[Int(code[pc + 1 + longestAt])], longest > 0, longest <= Self.delaySecondsMax else {
                         throw DSPProgramError("\(key): \(op) at \(pc)'s longest time is not a constant up to \(Self.delaySecondsMax) s")
@@ -361,10 +383,6 @@ public struct DSPProgram: Sendable, Equatable {
                 }
                 pc += length
             }
-            if let serial {
-                boundaries += (pc == serial.lowerBound ? 1 : 0) + (pc == serial.upperBound ? 1 : 0)
-                guard boundaries == 2 else { throw DSPProgramError("\(key)'s serial part does not fall between instructions") }
-            }
             return code
         }
         self.voices = voices
@@ -379,14 +397,92 @@ public struct DSPProgram: Sendable, Equatable {
         self.samples = parsedSamples
         self.routes = parsedRoutes
         self.curves = parsedCurves
-        self.block = try code("block", serial: nil)
-        let sampleSerial = try serial("serial")
-        self.serial = sampleSerial
-        self.sample = try code("sample", serial: sampleSerial)
+        self.block = try code("block")
+        self.sample = try code("sample")
         self.output = output
         self.outputRight = outputRight
-        let masterSerial = try serial("masterSerial")
-        self.master = try masterParts.map { Master(code: try code("master", serial: masterSerial), serial: masterSerial, inputs: $0.inputs, outputs: $0.outputs) }
+        self.master = try masterParts.map { Master(code: try code("master"), inputs: $0.inputs, outputs: $0.outputs) }
+        // Gated regions: each one's parameter one of the program's, the region around it an earlier one, and its
+        // results registers no instruction writes and nothing else names (no output, state, parameter, constant, route
+        // or another result), each read as a register while on and one while off, neither of them state (one value a
+        // voice, not one a frame).
+        var named = Set([output, outputRight].compactMap { $0 } + (masterParts?.inputs ?? []) + (masterParts?.outputs ?? []) + parsedRoutes.flatMap { $0 })
+        named.formUnion(stateRegisters)
+        named.formUnion(parsedParameters.map(\.register))
+        named.formUnion(parsedConstants.map(\.register))
+        named.formUnion(parsedCurves.flatMap { [$0.attack, $0.decay, $0.release] })
+        var results = Set<Int>()
+        var parsedGroups: [Gate] = []
+        for (index, item) in (root["groups"] as? [Any] ?? []).enumerated() {
+            guard let group = item as? [String: Any], let parameter = Self.int(group["parameter"]), parsedParameters.indices.contains(parameter) else {
+                throw DSPProgramError("groups[\(index)] does not name a parameter")
+            }
+            guard let parent = Self.int(group["parent"]), parent >= -1, parent < index else { throw DSPProgramError("groups[\(index)]'s parent is not an earlier region") }
+            guard let list = group["outputs"] as? [Any] else { throw DSPProgramError("groups[\(index)]'s outputs must be an array") }
+            let outputs = try list.map { entry -> Output in
+                guard let triple = entry as? [Any], triple.count == 3 else { throw DSPProgramError("groups[\(index)]: a result is [register, on, off]") }
+                let (r, on, off) = (try register(triple[0], "groups[\(index)]"), try register(triple[1], "groups[\(index)]"), try register(triple[2], "groups[\(index)]"))
+                guard r >= Self.machineRegisters, !written.contains(r), !named.contains(r), !results.contains(r) else {
+                    throw DSPProgramError("groups[\(index)]: result register \(r) is written or named elsewhere")
+                }
+                guard !stateRegisters.contains(on), !stateRegisters.contains(off) else { throw DSPProgramError("groups[\(index)]: result register \(r) reads as state") }
+                results.insert(r)
+                return Output(register: r, on: on, off: off)
+            }
+            parsedGroups.append(Gate(parameter: parameter, parent: parent, outputs: outputs))
+        }
+        self.groups = parsedGroups
+        // Choices: each one's parameter one of the program's, its register one nothing else writes or names (nor a
+        // region's result, nor another choice), its options 1 … choiceOptionsMax registers, none of them state.
+        let voicing = root["voicing"] as? [String: Any] ?? [:]
+        for key in voicing.keys {
+            guard ["voices", "mode"].contains(key), let index = Self.int(voicing[key]), parsedParameters.indices.contains(index) else {
+                throw DSPProgramError("voicing.\(key) does not name a parameter")
+            }
+        }
+        self.voicingVoices = Self.int(voicing["voices"])
+        self.voicingMode = Self.int(voicing["mode"])
+        self.choices = try (root["choices"] as? [Any] ?? []).enumerated().map { index, item in
+            guard let choice = item as? [String: Any], let parameter = Self.int(choice["parameter"]), parsedParameters.indices.contains(parameter) else {
+                throw DSPProgramError("choices[\(index)] does not name a parameter")
+            }
+            var scale = 1.0
+            if let value = choice["scale"] {
+                guard let number = value as? NSNumber, !(value is Bool), number.doubleValue.isFinite, number.doubleValue > 0 else {
+                    throw DSPProgramError("choices[\(index)]'s scale is not a number above 0")
+                }
+                scale = number.doubleValue
+            }
+            let r = try register(choice["register"], "choices[\(index)]")
+            guard r >= Self.machineRegisters, !written.contains(r), !named.contains(r), !results.contains(r) else {
+                throw DSPProgramError("choices[\(index)]: register \(r) is written or named elsewhere")
+            }
+            results.insert(r)
+            guard let list = choice["options"] as? [Any], (1...Self.choiceOptionsMax).contains(list.count) else {
+                throw DSPProgramError("choices[\(index)] has 1 … \(Self.choiceOptionsMax) options")
+            }
+            let options = try list.map { try register($0, "choices[\(index)]") }
+            guard !options.contains(where: stateRegisters.contains) else { throw DSPProgramError("choices[\(index)]: an option is state") }
+            return Choice(parameter: parameter, register: r, options: options, scale: scale)
+        }
+        /// One region (or -1) per instruction of `code`.
+        func regions(_ key: String, _ code: [Int32]?) throws -> [Int32]? {
+            guard let value = root[key] else { return nil }
+            guard let list = value as? [Any], let code else { throw DSPProgramError("\(key) must be an array") }
+            var count = 0
+            var pc = 0
+            while pc < code.count, let op = DSPOpcode(rawValue: code[pc]) {
+                count += 1
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+            guard list.count == count else { throw DSPProgramError("\(key) has \(list.count) entries for \(count) instructions") }
+            return try list.map { item in
+                guard let g = Self.int(item), g >= -1, g < parsedGroups.count else { throw DSPProgramError("\(key): a region is out of range") }
+                return Int32(g)
+            }
+        }
+        self.sampleGates = try regions("sampleGates", sample)
+        self.masterGates = try regions("masterGates", master?.code)
     }
 
     private static func int(_ value: Any?) -> Int? {

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

@@ -224,7 +224,10 @@ struct TextEditorElement: View {
 #if !canImport(FoundationBridge)
 /// The plain `texteditor` with `selection` (iOS 18, `TextEditor(text:selection:)`):
 /// the viewer's selection reported in UTF-16 offsets, and the caret moved
-/// to one the app sets, as the rich editor does.
+/// to one the app sets, as the rich editor does. A text that arrives from
+/// outside (not the echo of what the viewer typed) keeps the caret: the
+/// app's selection is applied even when its numbers did not change, else
+/// the caret is moved past the change (`caretAfterChange`).
 @available(iOS 18, macOS 15, *)
 struct PlainTextEditorElement: View {
     let node: ElementNode
@@ -232,16 +235,22 @@ struct PlainTextEditorElement: View {
     @State private var selection: TextSelection?
     @State private var shown = Shown()
 
-    /// The selection last sent, or last moved to (a class: set while drawing).
+    /// The selection last sent, or last moved to, and the text last sent (a class: set while drawing).
     final class Shown {
         var sent: TextSelectionSpec?
+        var sentText: String?
     }
 
     var body: some View {
         TextEditor(
             text: Binding(
                 get: { node.props.string("text") ?? "" },
-                set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
+                set: { edited in
+                    if let event = textChange(of: node, to: edited) {
+                        shown.sentText = edited
+                        app?.dispatch(event)
+                    }
+                }
             ),
             selection: Binding(
                 get: { selection },
@@ -256,12 +265,25 @@ struct PlainTextEditorElement: View {
             )
         )
         .onChange(of: TextEditorProps(props: node.props).selection) { _, wanted in move(to: wanted) }
+        .onChange(of: node.props.string("text") ?? "") { old, new in textArrived(from: old, to: new) }
         .onAppear { move(to: TextEditorProps(props: node.props).selection) }
     }
 
-    /// A selection the app set (not the one this editor sent): the caret goes there.
-    private func move(to wanted: TextSelectionSpec?) {
-        guard let wanted, wanted != shown.sent else { return }
+    /// The app's text changed: the echo of what the viewer typed leaves the caret alone; a text from outside keeps it in place.
+    private func textArrived(from old: String, to new: String) {
+        if new == shown.sentText { return }
+        if let wanted = TextEditorProps(props: node.props).selection {
+            move(to: wanted, force: true)
+        } else if let current = selection, let range = offsets(of: current, in: old) {
+            let start = stringIndex(utf16: caretAfterChange(before: old, after: new, offset: range.start), in: new)
+            let end = stringIndex(utf16: caretAfterChange(before: old, after: new, offset: range.end), in: new)
+            selection = start == end ? TextSelection(insertionPoint: start) : TextSelection(range: start..<end)
+        }
+    }
+
+    /// A selection the app set (not the one this editor sent): the caret goes there; `force` moves even to the numbers last sent (the text changed under them).
+    private func move(to wanted: TextSelectionSpec?, force: Bool = false) {
+        guard let wanted, force || wanted != shown.sent else { return }
         shown.sent = wanted
         let text = node.props.string("text") ?? ""
         let start = stringIndex(utf16: wanted.start, in: text)

package/swift/Sources/SwiftBrowserProtocol/TextChange.swift

@@ -0,0 +1,17 @@
+/// Where a caret goes when a text changes under it from outside (another
+/// person's edit arriving in a `texteditor`): an offset before the change
+/// (the common prefix of the two texts) stays; one after it (the common
+/// suffix) moves by the change's length; one inside the change goes to the
+/// change's end. Offsets are UTF-16 units, as a `selection` is on the wire.
+public func caretAfterChange(before: String, after: String, offset: Int) -> Int {
+    let a = Array(before.utf16)
+    let b = Array(after.utf16)
+    let shortest = min(a.count, b.count)
+    var prefix = 0
+    while prefix < shortest, a[prefix] == b[prefix] { prefix += 1 }
+    var suffix = 0
+    while suffix < shortest - prefix, a[a.count - 1 - suffix] == b[b.count - 1 - suffix] { suffix += 1 }
+    if offset <= prefix { return offset }
+    if offset >= a.count - suffix { return offset + (b.count - a.count) }
+    return b.count - suffix
+}

package/wasm/SwiftBrowserNative.wasm

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