@swiftbrowser/native 0.21.0 → 0.25.0

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

@@ -40,8 +40,8 @@ import Foundation
 /// reset only in `init` and on `reset`.
 ///
 /// 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 the compiler marks), which runs
-/// frame by frame within the chunk. Unlike the JavaScript machine's, a register holds a frame's lanes side by side,
+/// 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.
 public final class DSPMachine: @unchecked Sendable {
     public let program: DSPProgram
@@ -59,15 +59,77 @@ public final class DSPMachine: @unchecked Sendable {
     private let stateCount: Int
     private let noise: UnsafeMutablePointer<UInt32>
     private let noiseCount: Int
+    /// The streams as they run: what reads a gated region's result reading what the region gives it, `sample` and
+    /// `master` without the regions that are off, and scheduled (their parts that run frame by frame, in instructions).
     private let blockCode: UnsafeMutablePointer<Int32>
     private let blockCount: Int
+    /// How many of `blockCode`'s instructions run (those the streams were last made with).
+    private var blockRunning: Int
     private let sampleCode: UnsafeMutablePointer<Int32>
-    private let sampleCount: Int
+    private var sampleCount: Int
     private let masterCode: UnsafeMutablePointer<Int32>
-    private let masterCount: Int
-    /// The parts of `sample` and `master` that run frame by frame, in instructions.
-    private let sampleSerial: Range<Int>
-    private let masterSerial: Range<Int>
+    private var masterCount: Int
+    private var sampleSerial: Range<Int> = 0..<0
+    private var masterSerial: Range<Int> = 0..<0
+    /// The streams as the program has them, each instruction's region, each region's parameter, parent and results
+    /// (register, then what it reads as on and off, as offsets), whether each is on (2 before the program loads), and
+    /// per register what a result reads as now (-1 for a register that is none).
+    private let fullBlock: UnsafeMutablePointer<Int32>
+    private let fullSample: UnsafeMutablePointer<Int32>
+    private let fullSampleCount: Int
+    private let fullMaster: UnsafeMutablePointer<Int32>
+    private let fullMasterCount: Int
+    private let sampleGates: [Int32]?
+    private let masterGates: [Int32]?
+    private let groupParameters: [Int]
+    private let groupParents: [Int]
+    private let groupOutputs: [[(register: Int, on: Int32, off: Int32)]]
+    private var groupOn: [UInt8]
+    /// What runs: per instruction of the block, sample and master streams as the program has them, whether something
+    /// the outputs need reads it, now and when the streams were last made; per register, whether it is read, now and
+    /// then; whether the streams have been made; and each instruction's builtin (-1 for none). An instruction that comes
+    /// to run again starts over (its builtin, the state it writes), as one in a region coming on does.
+    private let aliveNow: [UnsafeMutablePointer<UInt8>]
+    private let aliveBefore: [UnsafeMutablePointer<UInt8>]
+    private let readNow: UnsafeMutablePointer<UInt8>
+    private let readBefore: UnsafeMutablePointer<UInt8>
+    private var made = false
+    private let streamInstances: [[Int32]]
+    private let streamCounts: [Int]
+    private let renameTable: UnsafeMutablePointer<Int32>
+    /// Scratch for making a stream again: its instructions before they are scheduled, a byte an instruction (touches
+    /// state, computed from it, needed by it) and a byte a register (tainted, needed).
+    private let staging: UnsafeMutablePointer<Int32>
+    private let instructionMarks: UnsafeMutablePointer<UInt8>
+    private let registerMarks: UnsafeMutablePointer<UInt8>
+    /// Choices: each one's parameter, register and options (as offsets); the option each reads as now (the last
+    /// choices with no cycle), the ones last asked for (so choices refused for a cycle are not tried every block),
+    /// and the ones asked for this block.
+    private let choiceParameters: [Int]
+    private let choiceRegisters: [Int]
+    private let choiceOptions: [[Int32]]
+    private let choiceScales: [Double]
+    private var choiceUsed: [Int]
+    private var choiceAsked: [Int]
+    private var choiceNow: [Int]
+    /// The voicing's parameters (nil: the program's own), and the voices and mode last played with (-1 before the
+    /// first block), so a turn lets go of what no longer plays.
+    private let voicesParameter: Int?
+    private let modeParameter: Int?
+    private var voicedLimit = -1
+    private var voicedMode = 0
+    /// Scratch for ordering a stream when choices change (made only when there are choices): the ordered sample and
+    /// master streams; per register its writer (not state) or the first of its writers (state, then linked by
+    /// instruction) and where its readers start in `readers`; per instruction how many it waits on; and a heap.
+    private let orderedSample: UnsafeMutablePointer<Int32>
+    private let orderedMaster: UnsafeMutablePointer<Int32>
+    private let writerOf: UnsafeMutablePointer<Int32>
+    private let stateWriterFirst: UnsafeMutablePointer<Int32>
+    private let stateWriterNext: UnsafeMutablePointer<Int32>
+    private let readerStarts: UnsafeMutablePointer<Int32>
+    private let readers: UnsafeMutablePointer<Int32>
+    private let waiting: UnsafeMutablePointer<Int32>
+    private let heap: UnsafeMutablePointer<Int32>
     /// Per instance: whether the master stage runs it.
     private let instanceMaster: [Bool]
     /// Each instance's builtin and where its state starts (in floats, lanes included; a noise instance's in `noise`).
@@ -80,36 +142,60 @@ public final class DSPMachine: @unchecked Sendable {
     private let parameterIndices: [String: Int]
     private let targets: UnsafeMutablePointer<Float>
     private var snapped = true
-    /// The wavetables' samples (table, level, 2048 samples, each its frames side by side), where each table starts
-    /// and its frames.
-    private let tableSamples: UnsafeMutablePointer<Float>
+    /// Whether a parameter was set since the last block: only then can a region, a choice or the voicing turn.
+    private var retargeted = false
+    /// Each wavetable's samples (level, 2048 samples, each its frames side by side), how many floats, and its frames;
+    /// each its own, so one is replaced (`replaceTable`) by swapping it whole. (`Slots`, not arrays replaced in place,
+    /// which Swift would check for exclusive access at every read as it renders.)
+    private let tablePointers: Slots<UnsafeMutablePointer<Float>>
+    private let tableSizes: Slots<Int>
+    private let tableFrames: Slots<Int>
     private let tableCount: Int
-    /// Envelopes' curves (attack, decay, release exponents), three a curve; an `adsr` names its curve in slot 11.
-    private let curveExponents: [Float]
-    private let tableBases: [Int]
-    private let tableFrames: [Int]
+    /// Envelopes' curves: the registers (as offsets) their attack, decay and release exponents are read from, three a
+    /// curve; an `adsr` names its curve in slot 11.
+    private let curveRegisters: [Int]
     /// The delays' samples: each instance's buffer per lane, a power of two long; by instance, where it starts and its length.
     private let delaySamples: UnsafeMutablePointer<Float>
     private let delaySampleCount: Int
     private let delayBases: [Int]
     private let delayLengths: [Int]
-    /// The shapes' points, one after another; where each starts and its length.
-    private let shapePoints: UnsafeMutablePointer<Float>
-    private let shapeBases: [Int]
-    private let shapeLengths: [Int]
-    /// The samples' audio, one after another; per sample where it starts, its length, its frames a frame at this
-    /// rate, and its spray (20 ms) in frames.
-    private let sampleAudio: UnsafeMutablePointer<Float>
-    private let sampleBases: [Int]
-    private let sampleLengths: [Int]
-    private let sampleRatios: [Float]
-    private let sampleSprays: [UInt32]
-    /// `modsum`'s route lists one after another, as register offsets (× `width`): a source's, then its amount's, pair
-    /// after pair; list i is `routeStarts[i] ..< routeStarts[i + 1]`.
+    /// Each shape's points and how many; each sample's audio, its length, its frames a frame at this rate, and its
+    /// spray (20 ms) in frames. Each its own, so one is replaced by swapping it whole.
+    private let shapePointers: Slots<UnsafeMutablePointer<Float>>
+    private let shapeLengths: Slots<Int>
+    private let samplePointers: Slots<UnsafeMutablePointer<Float>>
+    private let sampleLengths: Slots<Int>
+    private let sampleRatios: Slots<Float>
+    private let sampleSprays: Slots<UInt32>
+    /// `modsum`'s route lists, each with room for `DSPProgram.routesMax` registers (so one is replaced in place), as
+    /// register offsets (× `width`): a source's, then its amount's, pair after pair; list i starts at
+    /// `i × routesMax` and is `routeCounts[i]` long.
     private let routeRegisters: UnsafeMutablePointer<Int>
     /// Whether each route's register is state (one value a lane, not one a frame).
     private let routeState: UnsafeMutablePointer<Bool>
-    private let routeStarts: [Int]
+    private let routeCounts: UnsafeMutablePointer<Int>
+    private let routeCount: Int
+    /// Whether a route list was replaced since the last block: the streams are made again.
+    private var rerouted = false
+    /// Per register: whether it is a parameter, state, or one a machine renames (a choice's, a region's result).
+    private let parameterMask: UnsafeMutablePointer<UInt8>
+    private let stateMask: UnsafeMutablePointer<UInt8>
+    private let renamedMask: UnsafeMutablePointer<UInt8>
+    /// Folding: each register's value where it is a constant (NaN where not), an offset holding 0 (-1 for none), the
+    /// registers nothing may fold away (outputs, state, curves, the master stage's inputs) and those a route list names
+    /// now, and the registers folded when the streams were last made (their renaming undone before the next).
+    private let constantValues: UnsafeMutablePointer<Float>
+    /// Each parameter's range, by its register (NaN elsewhere): a clamp it is inside folds away.
+    private let parameterLowest: UnsafeMutablePointer<Float>
+    private let parameterHighest: UnsafeMutablePointer<Float>
+    private let zeroOffset: Int32
+    private let pinnedMask: UnsafeMutablePointer<UInt8>
+    private let routedMask: UnsafeMutablePointer<UInt8>
+    private let folded: UnsafeMutablePointer<Int32>
+    private var foldedCount = 0
+    /// 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>
 
     private let laneNote: UnsafeMutablePointer<Int32>
     private let laneGate: UnsafeMutablePointer<Float>
@@ -185,22 +271,68 @@ public final class DSPMachine: @unchecked Sendable {
         noiseCount = max(1, noises) * L
         noise = .allocate(capacity: noiseCount)
         noise.initialize(repeating: 1, count: noiseCount)
-        (tableSamples, tableBases, tableFrames) = Self.buildTables(program.tables)
+        let tables = program.tables.isEmpty ? [(Self.zeros(DSPProgram.tableLevels * DSPProgram.tableFrame), DSPProgram.tableLevels * DSPProgram.tableFrame)] : program.tables.map { Self.levels(frames: $0.frames, cosines: $0.cosines) }
+        tablePointers = Slots(tables.map(\.0))
+        tableSizes = Slots(tables.map(\.1))
+        tableFrames = Slots(program.tables.isEmpty ? [1] : program.tables.map(\.frames.count))
         tableCount = program.tables.count
-        (shapePoints, shapeBases, shapeLengths) = Self.concatenate(program.shapes.map(\.points))
-        (sampleAudio, sampleBases, sampleLengths) = Self.concatenate(program.samples.map(\.data))
-        sampleRatios = program.samples.map { Float($0.rate / Double(Float(sampleRate))) }
-        routeStarts = program.routes.reduce(into: [0]) { starts, list in starts.append(starts.last! + list.count) }
-        routeRegisters = .allocate(capacity: Swift.max(1, routeStarts.last!))
-        routeState = .allocate(capacity: Swift.max(1, routeStarts.last!))
-        routeState.initialize(repeating: false, count: Swift.max(1, routeStarts.last!))
+        shapePointers = Slots(program.shapes.isEmpty ? [Self.zeros(2)] : program.shapes.map { Self.copy($0.points) })
+        shapeLengths = Slots(program.shapes.isEmpty ? [2] : program.shapes.map(\.points.count))
+        samplePointers = Slots(program.samples.isEmpty ? [Self.zeros(2)] : program.samples.map { Self.copy($0.data) })
+        sampleLengths = Slots(program.samples.isEmpty ? [2] : program.samples.map(\.data.count))
+        sampleRatios = Slots(program.samples.isEmpty ? [1] : program.samples.map { Float($0.rate / Double(Float(sampleRate))) })
+        let routesMax = DSPProgram.routesMax
+        routeCount = program.routes.count
+        routeCounts = .allocate(capacity: Swift.max(1, routeCount))
+        routeCounts.initialize(repeating: 0, count: Swift.max(1, routeCount))
+        for (i, list) in program.routes.enumerated() { routeCounts[i] = list.count }
+        routeRegisters = .allocate(capacity: Swift.max(1, routeCount * routesMax))
+        routeRegisters.initialize(repeating: 0, count: Swift.max(1, routeCount * routesMax))
+        routeState = .allocate(capacity: Swift.max(1, routeCount * routesMax))
+        routeState.initialize(repeating: false, count: Swift.max(1, routeCount * routesMax))
         for (i, list) in program.routes.enumerated() {
             for (k, r) in list.enumerated() {
-                routeRegisters[routeStarts[i] + k] = r * W
-                routeState[routeStarts[i] + k] = stateRegisters.contains(r)
+                routeRegisters[i * routesMax + k] = r * W
+                routeState[i * routesMax + k] = stateRegisters.contains(r)
             }
         }
-        sampleSprays = program.samples.map { UInt32(Swift.max(1, ($0.rate * 0.02).rounded(.down))) }
+        let registerCount = program.registers
+        func mask() -> UnsafeMutablePointer<UInt8> {
+            let pointer = UnsafeMutablePointer<UInt8>.allocate(capacity: registerCount)
+            pointer.initialize(repeating: 0, count: registerCount)
+            return pointer
+        }
+        parameterMask = mask()
+        stateMask = mask()
+        renamedMask = mask()
+        pinnedMask = mask()
+        routedMask = mask()
+        changing = mask()
+        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 }
+        for g in program.groups { for o in g.outputs { renamedMask[o.register] = 1 } }
+        for r in [program.output, program.outputRight ?? program.output] + (program.master?.outputs ?? []) + (program.master?.inputs ?? []) { pinnedMask[r] = 1 }
+        for r in stateRegisters { pinnedMask[r] = 1 }
+        for c in program.curves { for r in [c.attack, c.decay, c.release] { pinnedMask[r] = 1 } }
+        for list in program.routes { for r in list { routedMask[r] = 1 } }
+        constantValues = .allocate(capacity: registerCount)
+        constantValues.initialize(repeating: .nan, count: registerCount)
+        parameterLowest = .allocate(capacity: registerCount)
+        parameterLowest.initialize(repeating: .nan, count: registerCount)
+        parameterHighest = .allocate(capacity: registerCount)
+        parameterHighest.initialize(repeating: .nan, count: registerCount)
+        for p in program.parameters {
+            parameterLowest[p.register] = p.min
+            parameterHighest[p.register] = p.max
+        }
+        var zero: Int32 = -1
+        for constant in program.constants {
+            constantValues[constant.register] = constant.value
+            if constant.value == 0 && zero < 0 { zero = Int32(constant.register * W) }
+        }
+        zeroOffset = zero
+        sampleSprays = Slots(program.samples.isEmpty ? [1] : program.samples.map { UInt32(Swift.max(1, ($0.rate * 0.02).rounded(.down))) })
         // Each delay's buffer: its longest time (a constant register) at this sample rate, rounded up to a power of
         // two, per voice (the master stage's, once).
         let constantValues = Dictionary(program.constants.map { ($0.register, $0.value) }, uniquingKeysWith: { _, last in last })
@@ -228,13 +360,95 @@ public final class DSPMachine: @unchecked Sendable {
         delaySampleCount = Swift.max(1, delayTotal)
         delaySamples = .allocate(capacity: delaySampleCount)
         delaySamples.initialize(repeating: 0, count: delaySampleCount)
-        curveExponents = program.curves.flatMap { [$0.attack, $0.decay, $0.release] }
+        curveRegisters = program.curves.flatMap { [$0.attack * W, $0.decay * W, $0.release * W] }
         let curves = Dictionary(program.curves.enumerated().map { ($1.instance, $0 + 1) }, uniquingKeysWith: { _, last in last })
-        (blockCode, blockCount, _) = Self.decode(program.block, nil, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
-        (sampleCode, sampleCount, sampleSerial) = Self.decode(
-            program.sample, program.serial, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
-        (masterCode, masterCount, masterSerial) = Self.decode(
-            program.master?.code ?? [], program.master?.serial, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (fullBlock, blockCount) = Self.decode(program.block, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (fullSample, fullSampleCount) = Self.decode(program.sample, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (fullMaster, fullMasterCount) = Self.decode(program.master?.code ?? [], width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        // Each made again (renamed, compacted, scheduled) when the program has loaded, and when a region turns.
+        // The block stream's room takes the sample stream's too: what no longer changes frame by frame moves there.
+        blockCode = .allocate(capacity: max(12, (blockCount + fullSampleCount) * 12))
+        blockCode.initialize(repeating: 0, count: max(12, (blockCount + fullSampleCount) * 12))
+        blockCode.update(from: fullBlock, count: blockCount * 12)
+        keptSample = .allocate(capacity: max(12, fullSampleCount * 12))
+        folded = .allocate(capacity: max(1, blockCount + fullSampleCount + fullMasterCount))
+        blockRunning = blockCount
+        sampleCode = .allocate(capacity: max(12, fullSampleCount * 12))
+        sampleCode.update(from: fullSample, count: max(12, fullSampleCount * 12))
+        masterCode = .allocate(capacity: max(12, fullMasterCount * 12))
+        masterCode.update(from: fullMaster, count: max(12, fullMasterCount * 12))
+        (sampleCount, masterCount) = (fullSampleCount, fullMasterCount)
+        sampleGates = program.sampleGates
+        masterGates = program.masterGates
+        groupParameters = program.groups.map(\.parameter)
+        groupParents = program.groups.map(\.parent)
+        groupOutputs = program.groups.map { $0.outputs.map { (register: $0.register, on: Int32($0.on * W), off: Int32($0.off * W)) } }
+        groupOn = [UInt8](repeating: 2, count: program.groups.count)
+        streamInstances = [program.block, program.sample, program.master?.code ?? []].map { code in
+            var instances: [Int32] = []
+            var pc = 0
+            while pc < code.count, let op = DSPOpcode(rawValue: code[pc]) {
+                instances.append(op.builtin != nil ? code[pc + 2 + op.arity] : -1)
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+            return instances
+        }
+        streamCounts = [blockCount, fullSampleCount, fullMasterCount]
+        aliveNow = [blockCount, fullSampleCount, fullMasterCount].map { count in
+            let marks = UnsafeMutablePointer<UInt8>.allocate(capacity: Swift.max(1, count))
+            marks.initialize(repeating: 0, count: Swift.max(1, count))
+            return marks
+        }
+        aliveBefore = [blockCount, fullSampleCount, fullMasterCount].map { count in
+            let marks = UnsafeMutablePointer<UInt8>.allocate(capacity: Swift.max(1, count))
+            marks.initialize(repeating: 0, count: Swift.max(1, count))
+            return marks
+        }
+        readNow = .allocate(capacity: program.registers)
+        readNow.initialize(repeating: 0, count: program.registers)
+        readBefore = .allocate(capacity: program.registers)
+        readBefore.initialize(repeating: 0, count: program.registers)
+        renameTable = .allocate(capacity: program.registers)
+        renameTable.initialize(repeating: -1, count: program.registers)
+        let longest = max(1, blockCount, fullSampleCount, fullMasterCount)
+        staging = .allocate(capacity: longest * 12)
+        staging.initialize(repeating: 0, count: longest * 12)
+        instructionMarks = .allocate(capacity: longest)
+        instructionMarks.initialize(repeating: 0, count: longest)
+        registerMarks = .allocate(capacity: program.registers)
+        registerMarks.initialize(repeating: 0, count: program.registers)
+        choiceParameters = program.choices.map(\.parameter)
+        choiceRegisters = program.choices.map(\.register)
+        choiceOptions = program.choices.map { $0.options.map { Int32($0 * W) } }
+        choiceScales = program.choices.map(\.scale)
+        choiceUsed = [Int](repeating: -1, count: program.choices.count)
+        choiceAsked = choiceUsed
+        choiceNow = choiceUsed
+        voicesParameter = program.voicingVoices
+        modeParameter = program.voicingMode
+        // The most registers an instruction of the sample or master stream reads: its operands, and a modsum's routes.
+        let ordering = !program.choices.isEmpty || !program.routes.isEmpty
+        // A route list may be replaced by one as long as any may be.
+        let longestRoute = program.routes.isEmpty ? 0 : routesMax
+        func readsIn(_ code: UnsafeMutablePointer<Int32>, _ count: Int) -> Int {
+            (0..<count).reduce(0) { sum, i in
+                let op = DSPOpcode(rawValue: code[i * 12])!
+                return sum + op.arity + (op == .modsum ? longestRoute : 0)
+            }
+        }
+        let readCount = ordering ? Swift.max(readsIn(fullSample, fullSampleCount), readsIn(fullMaster, fullMasterCount)) : 0
+        let orderable = ordering ? longest : 1
+        orderedSample = .allocate(capacity: Swift.max(12, fullSampleCount * 12))
+        orderedMaster = .allocate(capacity: Swift.max(12, fullMasterCount * 12))
+        writerOf = .allocate(capacity: ordering ? program.registers : 1)
+        writerOf.initialize(repeating: -1, count: ordering ? program.registers : 1)
+        stateWriterFirst = .allocate(capacity: ordering ? program.registers : 1)
+        stateWriterFirst.initialize(repeating: -1, count: ordering ? program.registers : 1)
+        stateWriterNext = .allocate(capacity: orderable)
+        readerStarts = .allocate(capacity: ordering ? program.registers + 1 : 1)
+        readers = .allocate(capacity: Swift.max(1, readCount))
+        waiting = .allocate(capacity: orderable)
+        heap = .allocate(capacity: orderable)
         for constant in program.constants {
             (registers + constant.register * W).update(repeating: constant.value, count: W)
         }
@@ -271,18 +485,43 @@ public final class DSPMachine: @unchecked Sendable {
         queueEvent.initialize(repeating: 0, count: Self.queueCapacity * 3)
         for lane in 0..<L { resetLane(lane) }
         resetMaster()
+        // The streams as they run: the regions its parameters turn on, scheduled.
+        turnRegions(loading: true)
+        revoice()
     }
 
     deinit {
-        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger, masterTrigger, shapePoints, sampleAudio] { pointer.deallocate() }
+        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger, masterTrigger] { pointer.deallocate() }
+        for slots in [shapePointers, samplePointers, tablePointers] {
+            for i in 0..<slots.count { slots[i].deallocate() }
+            slots.deallocate()
+        }
+        for slots in [tableSizes, tableFrames, shapeLengths, sampleLengths] { slots.deallocate() }
+        sampleRatios.deallocate()
+        sampleSprays.deallocate()
         noise.deallocate()
         routeRegisters.deallocate()
+        routeCounts.deallocate()
         routeState.deallocate()
-        tableSamples.deallocate()
+        for pointer in [parameterMask, stateMask, renamedMask, pinnedMask, routedMask, changing] { pointer.deallocate() }
+        constantValues.deallocate()
+        parameterLowest.deallocate()
+        parameterHighest.deallocate()
+        keptSample.deallocate()
+        folded.deallocate()
         delaySamples.deallocate()
         blockCode.deallocate()
         sampleCode.deallocate()
         masterCode.deallocate()
+        fullBlock.deallocate()
+        fullSample.deallocate()
+        fullMaster.deallocate()
+        renameTable.deallocate()
+        staging.deallocate()
+        instructionMarks.deallocate()
+        registerMarks.deallocate()
+        for pointer in aliveNow + aliveBefore + [readNow, readBefore] { pointer.deallocate() }
+        for pointer in [orderedSample, orderedMaster, writerOf, stateWriterFirst, stateWriterNext, readerStarts, readers, waiting, heap] { pointer.deallocate() }
         laneNote.deallocate()
         stack.deallocate()
         queueBeat.deallocate()
@@ -293,18 +532,460 @@ public final class DSPMachine: @unchecked Sendable {
 
     /// Instructions at a stride of 12 (op, destination, five operands, state offset, which of slots 1 … 6 are state
     /// registers as bits, then a delay line's buffer: where it starts and its length, then an envelope's curve, 1 up,
-    /// 0 for none), registers as offsets into the file. With the serial part's word offsets, its instructions.
-    private static func decode(
-        _ code: [Int32], _ serial: Range<Int>?, width: Int, state: Set<Int>, offsets: [Int], delays: (bases: [Int], lengths: [Int]),
-        curves: [Int: Int]
-    ) -> (UnsafeMutablePointer<Int32>, Int, Range<Int>) {
-        var out: [Int32] = []
+    /// 0 for none), registers as offsets into the file. With how many there are.
+    /// Gated regions and choices: a region is on while its parameter is set above 0.5 and the region around it is on;
+    /// a choice reads as the option its parameter names. When either changes (or the program loads), the streams are
+    /// made again: without the regions that are off, with what reads a region's result or a choice reading what it
+    /// gives, without what nothing the outputs need reads (an option not chosen), ordered so what a choice reads comes
+    /// first, and scheduled. Into buffers made when the program loaded: nothing is allocated.
+    private func turnRegions(loading: Bool, force: Bool = false) {
+        var changed = loading || force
+        for g in 0..<groupParameters.count {
+            let parent = groupParents[g]
+            let on: UInt8 = (parent < 0 || groupOn[parent] == 1) && targets[groupParameters[g]] > 0.5 ? 1 : 0
+            if on != groupOn[g] {
+                groupOn[g] = on
+                changed = true
+            }
+        }
+        for c in 0..<choiceParameters.count {
+            let value = Float((Double(targets[choiceParameters[c]]) * choiceScales[c]).rounded())
+            let last = choiceOptions[c].count - 1
+            choiceNow[c] = value.isNaN ? 0 : value <= 0 ? 0 : value >= Float(last) ? last : Int(value)
+            if choiceNow[c] != choiceAsked[c] { changed = true }
+        }
+        guard changed else { return }
+        for c in 0..<choiceNow.count { choiceAsked[c] = choiceNow[c] }
+        // The choices asked for; if they would make a cycle, the last that did not (with the regions as they are now);
+        // and on loading, if even those would, the program's own order.
+        if make(choiceNow, sort: true) {
+            for c in 0..<choiceNow.count { choiceUsed[c] = choiceNow[c] }
+        } else if loading || !make(choiceUsed, sort: true) {
+            _ = make(loading ? choiceNow : choiceUsed, sort: false)
+        }
+        if loading { for c in 0..<choiceNow.count { choiceUsed[c] = choiceNow[c] } }
+    }
+
+    /// The streams made again for the regions as they are and the choices `chosen`; false (nothing made) on a cycle.
+    private func make(_ chosen: [Int], sort: Bool) -> Bool {
+        // What was folded last time reads as itself again, until folded again below.
+        for i in 0..<foldedCount { renameTable[Int(folded[i])] = -1 }
+        foldedCount = 0
+        var results = choiceRegisters.count
+        for g in groupOutputs.indices {
+            for output in groupOutputs[g] { renameTable[output.register] = groupOn[g] == 1 ? output.on : output.off }
+            results += groupOutputs[g].count
+        }
+        for c in 0..<choiceRegisters.count { renameTable[choiceRegisters[c]] = choiceOptions[c][chosen[c]] }
+        // A result or a choice may read as another (nested regions, a choice of results): followed, at most once each.
+        let W = Int32(width)
+        func resolve(_ register: Int) {
+            var target = renameTable[register]
+            var steps = 0
+            while steps < results, renameTable[Int(target / W)] >= 0 {
+                target = renameTable[Int(target / W)]
+                steps += 1
+            }
+            renameTable[register] = target
+        }
+        for g in groupOutputs.indices { for output in groupOutputs[g] { resolve(output.register) } }
+        for register in choiceRegisters { resolve(register) }
+        fold()
+        liveness()
+        // Ordered where something may read what comes after it (a choice of a value made later, a route from a source
+        // made later); kept apart from `staging`, which the next stream is compacted into.
+        let ordering = sort && (!choiceRegisters.isEmpty || routeCount > 0)
+        let samples = compact(fullSample, fullSampleCount, aliveNow[1])
+        if ordering {
+            guard order(samples, into: orderedSample) else { return false }
+        } else {
+            orderedSample.update(from: staging, count: samples * 12)
+        }
+        let masters = compact(fullMaster, fullMasterCount, aliveNow[2])
+        if ordering {
+            guard order(masters, into: orderedMaster) else { return false }
+        } else {
+            orderedMaster.update(from: staging, count: masters * 12)
+        }
+        revive()
+        blockRunning = compact(fullBlock, blockCount, aliveNow[0])
+        blockCode.update(from: staging, count: blockRunning * 12)
+        // What in the sample stream no longer changes frame by frame runs once a block (as machine.ts moves it).
+        sampleCount = rerate(samples, from: orderedSample)
+        sampleSerial = reschedule(sampleCount, from: keptSample, into: sampleCode)
+        masterCount = masters
+        masterSerial = reschedule(masters, from: orderedMaster, into: masterCode)
+        return true
+    }
+
+    /// Folds what turned constant, before what runs is found (as machine.ts folds it): an instruction that comes to
+    /// one of its operands (x + 0, x × 1, a mix at 0 or 1, a select of a constant, a mov) or to 0 (x × 0, an empty
+    /// route list) is passed over, what reads it reading that instead. Never one whose register is an output, state, a
+    /// curve or in a route list.
+    private func fold() {
+        let W = Int32(width)
+        let zero = zeroOffset
+        func pass(_ code: UnsafeMutablePointer<Int32>, _ count: Int) {
+            for i in 0..<count {
+                let slot = code + i * 12
+                let d = Int(slot[1] / W)
+                if pinnedMask[d] != 0 || routedMask[d] != 0 { continue }
+                let op = slot[0]
+                let arity = DSPOpcode(rawValue: op)!.arity
+                func operand(_ k: Int) -> Int32 {
+                    guard k < arity else { return -1 }
+                    let t = renameTable[Int(slot[2 + k] / W)]
+                    return t >= 0 ? t : slot[2 + k]
+                }
+                let a = operand(0)
+                let b = operand(1)
+                let c = operand(2)
+                func value(_ offset: Int32) -> Float { offset >= 0 ? constantValues[Int(offset / W)] : .nan }
+                var to: Int32 = -1
+                switch op {
+                case 0: to = a
+                case 1: to = value(a) == 0 ? b : value(b) == 0 ? a : -1
+                case 2: to = value(b) == 0 ? a : -1
+                case 3: to = value(a) == 1 ? b : value(b) == 1 ? a : value(a) == 0 || value(b) == 0 ? zero : -1
+                case 58: to = value(a) == 0 || value(b) == 0 ? c : value(c) == 0 && value(a) == 1 ? b : value(c) == 0 && value(b) == 1 ? a : -1
+                case 59: to = value(c) == 0 ? zero : value(c) == 1 && value(a) == 0 ? b : value(c) == 1 && value(b) == 0 ? a : -1
+                case 30: to = a == b ? b : !value(a).isNaN ? (value(a) != 0 ? b : c) : -1
+                // A parameter clamped to a range its own is inside.
+                case 31: to = a >= 0 && value(b) <= parameterLowest[Int(a / W)] && parameterHighest[Int(a / W)] <= value(c) ? a : -1
+                case 32: to = value(c) == 0 || a == b ? a : value(c) == 1 ? b : -1
+                case 57:
+                    let index = Self.index(registers[Int(slot[2])], routeCount)
+                    to = index >= routeCount || routeCounts[index] == 0 ? zero : -1
+                default: break
+                }
+                if to < 0 || Int(to / W) == d { continue }
+                renameTable[d] = to
+                folded[foldedCount] = Int32(d)
+                foldedCount += 1
+            }
+        }
+        pass(fullBlock, blockCount)
+        pass(fullSample, fullSampleCount)
+        pass(fullMaster, fullMasterCount)
+    }
+
+    /// The `count` instructions of the sample stream at `source`, split (as machine.ts splits them): those that read
+    /// only what is set once a block (no state, nothing worked out frame by frame, not the beat) and are not builtins,
+    /// onto the end of `blockCode`; the rest into `keptSample`, in their order. How many stayed.
+    private func rerate(_ count: Int, from source: UnsafeMutablePointer<Int32>) -> Int {
+        let W = Int32(width)
+        changing[6] = 1
+        var kept = 0
+        for i in 0..<count {
+            let slot = source + i * 12
+            let d = Int(slot[1] / W)
+            var still = DSPOpcode(rawValue: slot[0])!.builtin == nil && stateMask[d] == 0
+            if still { forEachRead(slot) { r, state in if state || changing[r] != 0 { still = false } } }
+            if still {
+                (blockCode + blockRunning * 12).update(from: slot, count: 12)
+                blockRunning += 1
+            } else {
+                changing[d] = 1
+                (keptSample + kept * 12).update(from: slot, count: 12)
+                kept += 1
+            }
+        }
+        // The marks back to none, for the next time.
+        for i in 0..<kept { changing[Int(keptSample[i * 12 + 1] / W)] = 0 }
+        changing[6] = 0
+        return kept
+    }
+
+    /// Replaces route list `index` from the next block with `list`'s registers (a source's, then its amount's, pair
+    /// after pair, as floats), copied in place (as machine.ts `replaceRoutes`): the streams are made again. False where
+    /// there is no such list, or an amount is not a parameter, a register is past the program's or one renamed, or the
+    /// list is past `DSPProgram.routesMax`.
+    public func replaceRoutes(_ index: Int, registers list: DSPBuffer) -> Bool {
+        guard index >= 0, index < routeCount, list.count % 2 == 0, list.count <= DSPProgram.routesMax else { return false }
+        for k in 0..<list.count {
+            let x = list.pointer[k]
+            guard x >= 0, x < Float(program.registers), x == x.rounded(.down) else { return false }
+            let r = Int(x)
+            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
+            routeState[start + k] = stateMask[r] != 0
+        }
+        routeCounts[index] = list.count
+        routedMask.update(repeating: 0, count: program.registers)
+        for i in 0..<routeCount {
+            for k in 0..<routeCounts[i] { routedMask[routeRegisters[i * DSPProgram.routesMax + k] / width] = 1 }
+        }
+        rerouted = true
+        return true
+    }
+
+
+    /// The `count` instructions in `staging` into `out`, ordered so each comes after what writes what it reads (not
+    /// state), and a state register's readers before what writes it (they read the frame before's); program order
+    /// where neither says (as machine.ts orders). False on a cycle.
+    private func order(_ count: Int, into out: UnsafeMutablePointer<Int32>) -> Bool {
+        let W = Int32(width)
+        let registerCount = program.registers
+        for i in 0..<count {
+            let slot = staging + i * 12
+            let d = Int(slot[1] / W)
+            if (slot[8] >> 1) & 1 == 1 {
+                stateWriterNext[i] = stateWriterFirst[d]
+                stateWriterFirst[d] = Int32(i)
+            } else {
+                writerOf[d] = Int32(i)
+            }
+            waiting[i] = 0
+        }
+        // Each register's readers (reading it not as state), in program order: counted, summed to where each ends,
+        // then placed back to front so each ends where it starts.
+        readerStarts.update(repeating: 0, count: registerCount + 1)
+        for i in 0..<count { forEachRead(staging + i * 12) { r, state in if !state { readerStarts[r] += 1 } } }
+        var total: Int32 = 0
+        for r in 0..<registerCount {
+            total += readerStarts[r]
+            readerStarts[r] = total
+        }
+        readerStarts[registerCount] = total
+        for i in stride(from: count - 1, through: 0, by: -1) {
+            forEachRead(staging + i * 12) { r, state in
+                guard !state else { return }
+                readerStarts[r] -= 1
+                readers[Int(readerStarts[r])] = Int32(i)
+            }
+        }
+        for i in 0..<count {
+            forEachRead(staging + i * 12) { r, state in
+                if state {
+                    var w = stateWriterFirst[r]
+                    while w >= 0 {
+                        if Int(w) != i { waiting[Int(w)] += 1 }
+                        w = stateWriterNext[Int(w)]
+                    }
+                } else if writerOf[r] >= 0, Int(writerOf[r]) != i {
+                    waiting[i] += 1
+                }
+            }
+        }
+        // The ready instructions, least first (a binary heap), so program order holds where nothing else decides.
+        var size = 0
+        func push(_ i: Int32) {
+            var k = size
+            heap[k] = i
+            size += 1
+            while k > 0, heap[(k - 1) / 2] > heap[k] {
+                (heap[k], heap[(k - 1) / 2]) = (heap[(k - 1) / 2], heap[k])
+                k = (k - 1) / 2
+            }
+        }
+        func pop() -> Int {
+            let top = heap[0]
+            size -= 1
+            heap[0] = heap[size]
+            var k = 0
+            while true {
+                let l = 2 * k + 1
+                var m = k
+                if l < size, heap[l] < heap[m] { m = l }
+                if l + 1 < size, heap[l + 1] < heap[m] { m = l + 1 }
+                if m == k { break }
+                (heap[k], heap[m]) = (heap[m], heap[k])
+                k = m
+            }
+            return Int(top)
+        }
+        func done(_ j: Int) {
+            waiting[j] -= 1
+            if waiting[j] == 0 { push(Int32(j)) }
+        }
+        for i in 0..<count where waiting[i] == 0 { push(Int32(i)) }
+        var placed = 0
+        while size > 0 {
+            let i = pop()
+            let slot = staging + i * 12
+            (out + placed * 12).update(from: slot, count: 12)
+            placed += 1
+            forEachRead(slot) { r, state in
+                guard state else { return }
+                var w = stateWriterFirst[r]
+                while w >= 0 {
+                    if Int(w) != i { done(Int(w)) }
+                    w = stateWriterNext[Int(w)]
+                }
+            }
+            let d = Int(slot[1] / W)
+            if (slot[8] >> 1) & 1 == 0, Int(writerOf[d]) == i {
+                for k in Int(readerStarts[d])..<Int(readerStarts[d + 1]) where Int(readers[k]) != i { done(Int(readers[k])) }
+            }
+        }
+        // The tables back to none, for the next time.
+        for i in 0..<count {
+            let d = Int(staging[i * 12 + 1] / W)
+            writerOf[d] = -1
+            stateWriterFirst[d] = -1
+        }
+        return placed == count
+    }
+
+    /// An envelope's curve exponent as read: held to 1/16 … 16, 1 for NaN (as machine.ts reads it).
+    @inline(__always) private static func exponent(_ x: Float) -> Double {
+        x >= 0.0625 ? Double(x <= 16 ? x : 16) : x < 0.0625 ? 0.0625 : 1
+    }
+
+    /// Each register the instruction at `slot` reads (its operands, an envelope's curves, and a modsum's routes), and
+    /// whether it is state.
+    private func forEachRead(_ slot: UnsafeMutablePointer<Int32>, _ body: (Int, Bool) -> Void) {
+        let W = Int32(width)
+        let op = DSPOpcode(rawValue: slot[0])!
+        for k in 0..<op.arity { body(Int(slot[2 + k] / W), (slot[8] >> (2 + k)) & 1 == 1) }
+        if op == .adsr, slot[11] > 0 {
+            let curve = Int(slot[11]) - 1
+            for k in 0..<3 { body(curveRegisters[curve * 3 + k] / width, false) }
+        }
+        if op == .modsum {
+            let index = Self.index(registers[Int(slot[2])], routeCount)
+            if index < routeCount {
+                let start = index * DSPProgram.routesMax
+                for k in start..<(start + routeCounts[index]) { body(routeRegisters[k] / width, routeState[k]) }
+            }
+        }
+    }
+
+    /// What runs, into `aliveNow` and `readNow`, with what reads a result or a choice reading what `renameTable` says:
+    /// from the outputs back, each instruction outside a region that is off whose register something running reads,
+    /// and what it reads (a state register read, what writes it). Again until nothing more runs, since a choice or
+    /// state may read what comes after (as machine.ts finds it).
+    private func liveness() {
+        let W = Int32(width)
+        readNow.update(repeating: 0, count: program.registers)
+        readNow[program.output] = 1
+        if let right = program.outputRight { readNow[right] = 1 }
+        for r in program.master?.outputs ?? [] { readNow[r] = 1 }
+        for s in 0..<3 { aliveNow[s].update(repeating: 0, count: streamCounts[s]) }
+        /// One pass over a stream, back to front: whether anything more runs.
+        func sweep(_ code: UnsafeMutablePointer<Int32>, _ count: Int, _ gates: [Int32]?, _ marks: UnsafeMutablePointer<UInt8>) -> Bool {
+            var more = false
+            for i in stride(from: count - 1, through: 0, by: -1) {
+                let slot = code + i * 12
+                guard marks[i] == 0, readNow[Int(slot[1] / W)] != 0 else { continue }
+                if let gates, gates[i] >= 0, groupOn[Int(gates[i])] == 0 { continue }
+                marks[i] = 1
+                more = true
+                forEachRead(slot) { r, _ in
+                    let renamed = renameTable[r]
+                    readNow[renamed >= 0 ? Int(renamed / W) : r] = 1
+                }
+            }
+            return more
+        }
+        var more = true
+        while more {
+            more = sweep(fullMaster, fullMasterCount, masterGates, aliveNow[2])
+            more = sweep(fullSample, fullSampleCount, sampleGates, aliveNow[1]) || more
+            more = sweep(fullBlock, blockCount, nil, aliveNow[0]) || more
+        }
+    }
+
+    /// What comes to run again (it did not when the streams were last made) starts over: a builtin as when a voice
+    /// starts, a state register at its first value. Nothing does when the program loads. Then what runs now is what ran.
+    private func revive() {
+        let counts = streamCounts
+        if made {
+            for s in 0..<3 {
+                for i in 0..<counts[s] where aliveNow[s][i] != 0 && aliveBefore[s][i] == 0 && streamInstances[s][i] >= 0 {
+                    let instance = Int(streamInstances[s][i])
+                    if instanceMaster[instance] { resetInstance(instance, 0) } else { for l in 0..<program.voices { resetInstance(instance, l) } }
+                }
+            }
+            for entry in program.state where readNow[entry.register] != 0 && readBefore[entry.register] == 0 {
+                if entry.master { registers[entry.register * width] = entry.initial } else { for l in 0..<program.voices { registers[entry.register * width + l] = entry.initial } }
+            }
+        }
+        for s in 0..<3 { aliveBefore[s].update(from: aliveNow[s], count: counts[s]) }
+        readBefore.update(from: readNow, count: program.registers)
+        made = true
+    }
+
+    /// A stream's instructions that run (`alive`), their operands renamed, into `staging`: how many instructions.
+    private func compact(_ code: UnsafeMutablePointer<Int32>, _ count: Int, _ alive: UnsafeMutablePointer<UInt8>) -> Int {
+        let W = Int32(width)
+        var kept = 0
+        for i in 0..<count {
+            if alive[i] == 0 { continue }
+            let at = code + i * 12
+            let slot = staging + kept * 12
+            slot.update(from: at, count: 12)
+            for k in 0..<DSPOpcode(rawValue: at[0])!.arity {
+                let r = renameTable[Int(at[2 + k] / W)]
+                if r >= 0 { slot[2 + k] = r }
+            }
+            kept += 1
+        }
+        return kept
+    }
+
+    /// A stream's schedule over the `count` instructions at `source`, into `out`: those reading or writing state, and
+    /// those both computed from state and needed by it this frame, run frame by frame (the serial part, returned); what
+    /// they need comes before, what needs them after; program order kept within each part (as machine.ts schedules).
+    private func reschedule(_ count: Int, from source: UnsafeMutablePointer<Int32>, into out: UnsafeMutablePointer<Int32>) -> Range<Int> {
+        let W = Int32(width)
+        let touches: UInt8 = 1, downstream: UInt8 = 2, upstream: UInt8 = 4
+        let tainted: UInt8 = 1, needed: UInt8 = 2
+        for i in 0..<count {
+            let slot = source + i * 12
+            var marks: UInt8 = (slot[8] >> 1) & 1 == 1 ? touches : 0
+            var fromState = false
+            forEachRead(slot) { r, state in
+                if state { marks |= touches }
+                if registerMarks[r] & tainted != 0 { fromState = true }
+            }
+            if marks & touches != 0 || fromState {
+                marks |= downstream
+                if (slot[8] >> 1) & 1 == 0 { registerMarks[Int(slot[1] / W)] |= tainted }
+            }
+            instructionMarks[i] = marks
+        }
+        for i in stride(from: count - 1, through: 0, by: -1) {
+            let slot = source + i * 12
+            guard instructionMarks[i] & touches != 0 || registerMarks[Int(slot[1] / W)] & needed != 0 else { continue }
+            instructionMarks[i] |= upstream
+            forEachRead(slot) { r, state in if !state { registerMarks[r] |= needed } }
+        }
+        var kept = 0
         var from = 0
         var to = 0
+        for part in 0..<3 {
+            if part == 1 { from = kept }
+            if part == 2 { to = kept }
+            for i in 0..<count {
+                let marks = instructionMarks[i]
+                let serial = marks & touches != 0 || (marks & downstream != 0 && marks & upstream != 0)
+                guard (part == 0 && !serial && marks & downstream == 0) || (part == 1 && serial) || (part == 2 && !serial && marks & downstream != 0) else { continue }
+                (out + kept * 12).update(from: source + i * 12, count: 12)
+                kept += 1
+            }
+        }
+        // The marks back to none, for the next time.
+        for i in 0..<count {
+            let slot = source + i * 12
+            registerMarks[Int(slot[1] / W)] = 0
+            forEachRead(slot) { r, _ in registerMarks[r] = 0 }
+        }
+        return from..<to
+    }
+
+    private static func decode(
+        _ code: [Int32], width: Int, state: Set<Int>, offsets: [Int], delays: (bases: [Int], lengths: [Int]), curves: [Int: Int]
+    ) -> (UnsafeMutablePointer<Int32>, Int) {
+        var out: [Int32] = []
         var pc = 0
         while pc < code.count {
-            if pc == serial?.lowerBound { from = out.count / 12 }
-            if pc == serial?.upperBound { to = out.count / 12 }
             let op = DSPOpcode(rawValue: code[pc])!
             var slot = [Int32](repeating: 0, count: 12)
             slot[0] = op.rawValue
@@ -323,41 +1004,77 @@ public final class DSPMachine: @unchecked Sendable {
             out += slot
             pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
         }
-        if pc == serial?.lowerBound { from = out.count / 12 }
-        if pc == serial?.upperBound { to = out.count / 12 }
         let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(12, out.count))
         pointer.initialize(repeating: 0, count: max(12, out.count))
         out.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: out.count) }
-        return (pointer, out.count / 12, from..<to)
+        return (pointer, out.count / 12)
     }
 
     /// Lists one after another: where each starts and its length.
-    private static func concatenate(_ lists: [[Float]]) -> (UnsafeMutablePointer<Float>, [Int], [Int]) {
-        let total = Swift.max(1, lists.reduce(0) { $0 + $1.count })
-        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: total)
-        pointer.initialize(repeating: 0, count: total)
-        var bases: [Int] = []
-        var at = 0
-        for list in lists {
-            bases.append(at)
-            list.withUnsafeBufferPointer { (pointer + at).update(from: $0.baseAddress!, count: list.count) }
-            at += list.count
-        }
-        return (pointer, bases, lists.map(\.count))
+    private static func zeros(_ count: Int) -> UnsafeMutablePointer<Float> {
+        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: Swift.max(1, count))
+        pointer.initialize(repeating: 0, count: Swift.max(1, count))
+        return pointer
+    }
+
+    private static func copy(_ values: [Float]) -> UnsafeMutablePointer<Float> {
+        let pointer = zeros(values.count)
+        values.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: values.count) }
+        return pointer
+    }
+
+    /// A wavetable's samples as the machine reads them (as machine.ts `tableLevels` makes them), off the audio thread,
+    /// for `replaceTable`.
+    public static func tableLevels(frames: [[Float]], cosines: [[Float]]? = nil) -> DSPBuffer {
+        let (pointer, count) = levels(frames: frames, cosines: cosines)
+        return DSPBuffer(taking: pointer, count: count)
+    }
+
+    /// Replaces table `index`'s samples (`tableLevels`) from the next block, swapping them with `levels`, which then
+    /// holds what the machine let go of, to free off the audio thread. False (nothing swapped) where they do not fit.
+    public func replaceTable(_ index: Int, levels: DSPBuffer, frames: Int) -> Bool {
+        guard index >= 0, index < tableCount, frames >= 1, levels.count == frames * DSPProgram.tableLevels * DSPProgram.tableFrame else { return false }
+        var total = frames
+        for i in 0..<tableFrames.count where i != index { total += tableFrames[i] }
+        guard total <= DSPProgram.tableFramesMax else { return false }
+        swap(&tablePointers[index], &levels.pointer)
+        swap(&tableSizes[index], &levels.count)
+        tableFrames[index] = frames
+        return true
+    }
+
+    /// Replaces shape `index`'s points from the next block, swapping them with `points` (as `replaceTable`).
+    public func replaceShape(_ index: Int, points: DSPBuffer) -> Bool {
+        guard index >= 0, index < program.shapes.count, (2...DSPProgram.shapePointsMax).contains(points.count) else { return false }
+        var total = points.count
+        for i in 0..<shapeLengths.count where i != index { total += shapeLengths[i] }
+        guard total <= DSPProgram.shapesPointsMax else { return false }
+        swap(&shapePointers[index], &points.pointer)
+        swap(&shapeLengths[index], &points.count)
+        return true
     }
 
-    /// The wavetables' samples: per table, per frame, per level (level n keeps the harmonics up to 512 >> n), 2048
-    /// samples from an inverse FFT of the frame's sine harmonics (and cosine ones, when it has them) in doubles, stored as floats, a level's samples in
-    /// order with each sample's frames side by side: the JavaScript machine's `buildTables`, step for step.
-    private static func buildTables(_ tables: [DSPProgram.Table]) -> (UnsafeMutablePointer<Float>, [Int], [Int]) {
+    /// Replaces sample `index`'s audio, at `rate` frames a second, from the next block, swapping it with `audio` (as
+    /// `replaceTable`); a sound playing it goes on from where it is, inside the new length.
+    public func replaceSample(_ index: Int, audio: DSPBuffer, rate: Double) -> Bool {
+        guard index >= 0, index < program.samples.count, rate >= 1000, rate <= 384_000, audio.count >= 2 else { return false }
+        var total = audio.count
+        for i in 0..<sampleLengths.count where i != index { total += sampleLengths[i] }
+        guard total <= DSPProgram.samplesMax else { return false }
+        swap(&samplePointers[index], &audio.pointer)
+        swap(&sampleLengths[index], &audio.count)
+        sampleRatios[index] = Float(rate / Double(Float(sampleRate)))
+        sampleSprays[index] = UInt32(Swift.max(1, (rate * 0.02).rounded(.down)))
+        return true
+    }
+
+    /// A table's samples and how many floats: each level one with the harmonics past 512, 256 … dropped, 2048 samples,
+    /// each its frames side by side.
+    private static func levels(frames tableFrames: [[Float]], cosines tableCosines: [[Float]]?) -> (UnsafeMutablePointer<Float>, Int) {
         let N = DSPProgram.tableFrame
         let levels = DSPProgram.tableLevels
-        let frameCount = tables.reduce(0) { $0 + $1.frames.count }
-        let count = Swift.max(1, frameCount * levels * N)
-        let samples = UnsafeMutablePointer<Float>.allocate(capacity: count)
-        samples.initialize(repeating: 0, count: count)
-        var bases: [Int] = []
-        var frames: [Int] = []
+        let count = Swift.max(1, tableFrames.count) * levels * N
+        let samples = zeros(count)
         var cosT = [Double](repeating: 0, count: N / 2)
         var sinT = [Double](repeating: 0, count: N / 2)
         for j in 0..<(N / 2) {
@@ -366,15 +1083,12 @@ public final class DSPMachine: @unchecked Sendable {
         }
         var re = [Double](repeating: 0, count: N)
         var im = [Double](repeating: 0, count: N)
-        var at = 0
-        for table in tables {
-            bases.append(at)
-            let count = table.frames.count
-            frames.append(count)
+        do {
+            let count = tableFrames.count
             // A level's samples one after another, each its frames side by side: a read between two samples and two
             // frames is one span of memory.
-            func store(_ level: Int, _ n: Int, _ f: Int) -> Int { at + (level * N + n) * count + f }
-            for (f, amplitudes) in table.frames.enumerated() {
+            func store(_ level: Int, _ n: Int, _ f: Int) -> Int { (level * N + n) * count + f }
+            for (f, amplitudes) in tableFrames.enumerated() {
                 for level in 0..<levels {
                     let limit = Swift.min(512 >> level, amplitudes.count)
                     if level > 0 && limit == Swift.min(512 >> (level - 1), amplitudes.count) {
@@ -394,7 +1108,7 @@ public final class DSPMachine: @unchecked Sendable {
                             im[N - k] = a / 2
                         }
                         // cos(kθ) = (e^{ikθ} + e^{−ikθ}) / 2
-                        if let cosines = table.cosines?[f] {
+                        if let cosines = tableCosines?[f] {
                             for k in 1...limit {
                                 let c = Double(cosines[k - 1])
                                 re[k] = c / 2
@@ -439,9 +1153,8 @@ public final class DSPMachine: @unchecked Sendable {
                     for n in 0..<N { samples[store(level, n, f)] = Float(re[n]) }
                 }
             }
-            at += count * levels * N
         }
-        return (samples, bases, frames)
+        return (samples, count)
     }
 
     // MARK: Events
@@ -455,6 +1168,7 @@ public final class DSPMachine: @unchecked Sendable {
     public func setParameter(at index: Int, _ value: Float) {
         guard index >= 0, index < parameterRegisters.count, value.isFinite else { return }
         targets[index] = Swift.min(Swift.max(value, parameterRanges[index].min), parameterRanges[index].max)
+        retargeted = true
     }
 
     /// The transport's tempo, in beats a minute (1 … 999), from the next block.
@@ -544,12 +1258,48 @@ public final class DSPMachine: @unchecked Sendable {
         return frames >= Double(DSPProgram.blockFrames) ? DSPProgram.blockFrames : Swift.max(1, Int(frames))
     }
 
+    /// The mode notes play in now: the voicing's parameter's, else the program's.
+    private func currentMode() -> DSPProgram.Mode? {
+        guard let p = modeParameter else { return program.mode }
+        let m = targets[p].rounded()
+        return m == 1 ? .mono : m == 2 ? .legato : nil
+    }
+
+    /// How many voices play now: the voicing's parameter's (1 … the program's), else the program's.
+    private func voiceLimit() -> Int {
+        guard let p = voicesParameter else { return program.voices }
+        let n = targets[p].rounded()
+        return n.isNaN || n < 1 ? 1 : n >= Float(program.voices) ? program.voices : Int(n)
+    }
+
+    /// At a block's start, where the voicing turned: the voices past those that play now let go, and the held notes a
+    /// mode keeps start again from the one voice that sounds (as machine.ts does).
+    private func revoice() {
+        let mode = currentMode()
+        let modeIndex = mode == .mono ? 1 : mode == .legato ? 2 : 0
+        let limit = mode != nil ? 1 : voiceLimit()
+        guard limit != voicedLimit || modeIndex != voicedMode else { return }
+        let first = voicedLimit < 0
+        voicedLimit = limit
+        voicedMode = modeIndex
+        if first { return }
+        for l in limit..<Self.lanes {
+            laneGate[l] = 0
+            laneHeld[l] = false
+        }
+        stackCount = 0
+        if mode != nil && laneGate[0] > 0.5 {
+            stack[0] = laneNote[0]
+            stackCount = 1
+        }
+    }
+
     private func start(_ note: Int32, velocity: Int32) {
         if velocity <= 0 {
             release(note)
             return
         }
-        if let mode = program.mode {
+        if let mode = currentMode() {
             // One voice: the newest note, legato while another is held.
             unstack(note)
             if stackCount == Self.lanes {
@@ -572,7 +1322,7 @@ public final class DSPMachine: @unchecked Sendable {
             }
             return
         }
-        let voices = program.voices
+        let voices = voiceLimit()
         var lane = -1
         for l in 0..<voices where lane < 0 && laneNote[l] == note && laneGate[l] > 0.5 { lane = l }
         var fresh = false
@@ -602,7 +1352,7 @@ public final class DSPMachine: @unchecked Sendable {
     }
 
     private func release(_ note: Int32) {
-        if let mode = program.mode {
+        if let mode = currentMode() {
             unstack(note)
             guard laneNote[0] == note && laneGate[0] > 0.5 else { return }
             if stackCount > 0 {
@@ -645,6 +1395,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
         }
@@ -747,12 +1499,24 @@ public final class DSPMachine: @unchecked Sendable {
         let W = width
         let R = registers
         let sr = sampleRate
-        // Parameters glide toward their targets, about 20 ms.
+        // Parameters glide toward their targets, about 20 ms, and come to rest on them: one at rest is left as it is.
         let alpha = snapped ? Float(1) : 1 - exp(-Float(n) / (0.02 * sr))
         snapped = false
         for (i, register) in parameterRegisters.enumerated() {
             let at = R + register * W
-            at.update(repeating: at[0] + (targets[i] - at[0]) * alpha, count: W)
+            let now = at[0]
+            let target = targets[i]
+            if now == target { continue }
+            var value = now + (target - now) * alpha
+            if abs(target - value) <= 1e-6 * (1 + abs(target)) { value = target }
+            at.update(repeating: value, count: W)
+        }
+        if retargeted || rerouted {
+            let force = rerouted
+            retargeted = false
+            rerouted = false
+            if !groupParameters.isEmpty || !choiceParameters.isEmpty || force { turnRegions(loading: false, force: force) }
+            if voicesParameter != nil || modeParameter != nil { revoice() }
         }
         (R + 5 * W).update(repeating: Float(tempo), count: W)
         let beatStep = tempo / 60 / Double(sr)
@@ -780,7 +1544,7 @@ public final class DSPMachine: @unchecked Sendable {
                     R[4 * W + k * V + l] = note >= 0 ? Float(note) : 0
                 }
             }
-            run(blockCode, 0..<blockCount, lanes: lanes, trigger: trigger, frames: F)
+            run(blockCode, 0..<blockRunning, lanes: lanes, trigger: trigger, frames: F)
         }
         if master != nil {
             // The newest note, the master stage's inputs (registers 7 … 10), in lane 0.
@@ -930,9 +1694,13 @@ public final class DSPMachine: @unchecked Sendable {
                 }
             }
         }
-        var at = range.lowerBound * 12
+        var next = range.lowerBound * 12
         let end = range.upperBound * 12
-        while at < end {
+        while next < end {
+            // A constant for the instruction: a variable the kernels' closures read would be checked for exclusive
+            // access at every read.
+            let at = next
+            next += 12
             let op = code[at]
             let states = code[at + 8]
             // A register at this frame, or a state register's one value.
@@ -1121,11 +1889,18 @@ public final class DSPMachine: @unchecked Sendable {
                 let releaseIn = register(6)
                 let curve = Int(code[at + 11]) - 1
                 let curved = curve >= 0
-                let ea = curved ? Double(curveExponents[curve * 3]) : 1
-                let ed = curved ? Double(curveExponents[curve * 3 + 1]) : 1
-                let er = curved ? Double(curveExponents[curve * 3 + 2]) : 1
-                for fk in 0..<fc {
-                    for l in 0..<lanes {
+                // The curves' registers (a knob's, or modulated), read at the chunk's first frame a voice (as machine.ts
+                // reads them), 1/16 … 16, 1 for NaN.
+                let ra = curved ? R + curveRegisters[curve * 3] + shift : R
+                let rd = curved ? R + curveRegisters[curve * 3 + 1] + shift : R
+                let rr = curved ? R + curveRegisters[curve * 3 + 2] + shift : R
+                for l in 0..<lanes {
+                    let ea = curved ? Self.exponent(ra[l]) : 1
+                    let ed = curved ? Self.exponent(rd[l]) : 1
+                    let er = curved ? Self.exponent(rr[l]) : 1
+                    // All three 1: no stage bent (what it put out kept all the same, for a curve turned later).
+                    let bent = curved && (ea != 1 || ed != 1 || er != 1)
+                    for fk in 0..<fc {
                         let el = fk * V + l
                         let gate = a[el]
                         var stage = s[l]
@@ -1142,7 +1917,7 @@ public final class DSPMachine: @unchecked Sendable {
                         if curved && stage != before {
                             let last = s[8 * L + l]
                             if stage == 1 {
-                                level = last > 0 ? Float(Foundation.pow(Double(last), 1 / ea)) : 0
+                                level = last > 0 ? (ea == 1 ? last : Float(Foundation.pow(Double(last), 1 / ea))) : 0
                             } else if stage == 4 {
                                 level = last
                                 s[9 * L + l] = last
@@ -1182,18 +1957,21 @@ public final class DSPMachine: @unchecked Sendable {
                         s[l] = stage
                         s[L + l] = level
                         var out = level
-                        if curved {
+                        if bent {
+                            // An exponent of 1 is no bend: the stage as it is, with no power worked out.
                             if stage == 1 {
-                                out = Float(Foundation.pow(Double(level), ea))
+                                out = ea == 1 ? level : Float(Foundation.pow(Double(level), ea))
                             } else if stage == 2 {
                                 let span = 1 - sustain
-                                out = span > 1e-6 ? sustain + span * Float(Foundation.pow(Double(Swift.max(0, (level - sustain) / span)), ed)) : level
+                                let along = Swift.max(0, (level - sustain) / span)
+                                out = span > 1e-6 ? sustain + span * (ed == 1 ? along : Float(Foundation.pow(Double(along), ed))) : level
                             } else if stage == 4 {
                                 let from = s[9 * L + l]
-                                out = from > 0 ? from * Float(Foundation.pow(Double(Swift.min(1, level / from)), er)) : 0
+                                let along = Swift.min(1, level / from)
+                                out = from > 0 ? from * (er == 1 ? along : Float(Foundation.pow(Double(along), er))) : 0
                             }
-                            s[8 * L + l] = out
                         }
+                        if curved { s[8 * L + l] = out }
                         d[el] = out
                     }
                 }
@@ -1234,12 +2012,12 @@ public final class DSPMachine: @unchecked Sendable {
                 // wavetable(table, freq, position): the level that cannot alias at freq (worked out again only when freq
                 // changes), read between samples and between frames.
                 let s = S + Int(code[at + 7])
-                let T = tableSamples
                 // The table is a constant register's, the same in every lane.
                 let index = a[0]
                 let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
                 let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
-                let base = tableBases.isEmpty ? 0 : tableBases[t]
+                let T = tablePointers[t]
+                let base = 0
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
@@ -1306,13 +2084,13 @@ public final class DSPMachine: @unchecked Sendable {
                 }
             case 52:
                 // shape(shape, x): x 0 … 1 along it, between points.
-                let P = shapePoints
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
                         let t = Self.index(a[el], shapeLengths.count)
                         let points = shapeLengths.isEmpty ? 1 : shapeLengths[t]
-                        let base = shapeBases.isEmpty ? 0 : shapeBases[t]
+                        let P = shapePointers[t]
+                        let base = 0
                         let x = b[el]
                         let position = (x > 0 ? (x < 1 ? x : 1) : 0) * Float(points - 1)
                         let i0 = Int(position.rounded(.down))
@@ -1326,13 +2104,13 @@ public final class DSPMachine: @unchecked Sendable {
                 // between samples; silent past either end. Where it plays is a whole sample and the fraction past it,
                 // so it keeps time.
                 let s = S + Int(code[at + 7])
-                let A = sampleAudio
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
                         let t = Self.index(a[el], sampleLengths.count)
                         let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
-                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        let A = samplePointers[t]
+                        let base = 0
                         if s[2 * L + l] != trigger[l] {
                             s[2 * L + l] = trigger[l]
                             let start = c[el]
@@ -1363,13 +2141,13 @@ public final class DSPMachine: @unchecked Sendable {
                 // tableread(table, phase, freq, position): wavetable's read, at a phase the program keeps (wrapped to
                 // 0 … 1), at the level that cannot alias at freq (worked out again only when freq changes).
                 let s = S + Int(code[at + 7])
-                let T = tableSamples
                 let e = register(5)
                 // The table is a constant register's, the same in every lane.
                 let index = a[0]
                 let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
                 let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
-                let base = tableBases.isEmpty ? 0 : tableBases[t]
+                let T = tablePointers[t]
+                let base = 0
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
@@ -1408,13 +2186,13 @@ public final class DSPMachine: @unchecked Sendable {
             case 79:
                 // loop(sample, rate, start): play's, but round and round: past either end it comes in at the other.
                 let s = S + Int(code[at + 7])
-                let A = sampleAudio
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
                         let t = Self.index(a[el], sampleLengths.count)
                         let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
-                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        let A = samplePointers[t]
+                        let base = 0
                         if s[2 * L + l] != trigger[l] {
                             s[2 * L + l] = trigger[l]
                             let start = c[el]
@@ -1443,13 +2221,13 @@ public final class DSPMachine: @unchecked Sendable {
                 let s = S + Int(code[at + 7])
                 let lengthIn = register(5)
                 let pitchIn = register(6)
-                let A = sampleAudio
                 for fk in 0..<fc {
                     for l in 0..<lanes {
                         let el = fk * V + l
                         let t = Self.index(a[el], sampleLengths.count)
                         let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
-                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        let A = samplePointers[t]
+                        let base = 0
                         let ratio = sampleRatios.isEmpty ? 1 : sampleRatios[t]
                         let density = c[el]
                         var countdown = s[l]
@@ -1508,10 +2286,10 @@ public final class DSPMachine: @unchecked Sendable {
                 // modsum(routes): Σ amount × source over the list, route by route. An amount is a parameter, the same
                 // in every lane, so a route at 0 is passed over once for all of them and costs nothing.
                 each { d[$0] = 0 }
-                let index = Self.index(a[0], routeStarts.count - 1)
-                guard index < routeStarts.count - 1 else { break }
-                var k = routeStarts[index]
-                let end = routeStarts[index + 1]
+                let index = Self.index(a[0], routeCount)
+                guard index < routeCount else { break }
+                var k = index * DSPProgram.routesMax
+                let end = k + routeCounts[index]
                 while k < end {
                     let amount = R + routeRegisters[k + 1]
                     let source = R + routeRegisters[k] + (routeState[k] ? 0 : shift)
@@ -1555,7 +2333,57 @@ public final class DSPMachine: @unchecked Sendable {
             default:
                 break
             }
-            at += 12
         }
     }
 }
+
+/// Memory a machine reads (a table's samples, a shape's points, a sample's audio), made off the audio thread and
+/// swapped into a machine whole (`replaceTable` …). After a swap it holds what the machine let go of: freed with it,
+/// off the audio thread.
+/// A fixed number of values in memory of their own, each changed in place: what the machine reads as it renders and
+/// swaps when data is replaced, with no exclusivity checks (as an array property changed in place would need).
+struct Slots<Element> {
+    let base: UnsafeMutablePointer<Element>
+    let count: Int
+
+    init(_ values: [Element]) {
+        count = values.count
+        base = .allocate(capacity: Swift.max(1, values.count))
+        base.initialize(from: values, count: values.count)
+    }
+
+    var isEmpty: Bool { count == 0 }
+
+    subscript(i: Int) -> Element {
+        get { base[i] }
+        nonmutating set { base[i] = newValue }
+    }
+
+    func deallocate() {
+        base.deinitialize(count: count)
+        base.deallocate()
+    }
+}
+
+public final class DSPBuffer: @unchecked Sendable {
+    public fileprivate(set) var pointer: UnsafeMutablePointer<Float>
+    public fileprivate(set) var count: Int
+
+    /// `values`, copied.
+    public init(_ values: [Float]) {
+        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: Swift.max(1, values.count))
+        pointer.initialize(repeating: 0, count: Swift.max(1, values.count))
+        values.withUnsafeBufferPointer { if let base = $0.baseAddress { pointer.update(from: base, count: values.count) } }
+        self.pointer = pointer
+        count = values.count
+    }
+
+    fileprivate init(taking pointer: UnsafeMutablePointer<Float>, count: Int) {
+        self.pointer = pointer
+        self.count = count
+    }
+
+    deinit {
+        pointer.deallocate()
+    }
+}