Merge branch 'main' into busparts

Revert "state twiddles wip"
This reverts commit 55839e7ee8.
2026-09-17 03:06:55 -04:00 · 2025-10-30 21:37:48 +00:00 · 2025-10-30 21:28:58 +00:00 · 2025-10-26 21:14:11 +00:00 · 2025-10-24 20:51:12 +01:00 · 2025-10-24 20:48:35 +01:00
72 changed files with 6784 additions and 7290 deletions
@@ -1 +0,0 @@
-22
@@ -13,7 +13,7 @@ https://strudel.cc/

 After cloning the project, you can run the REPL locally:

-1. Install [Node.js](https://nodejs.org/) 18 or newer
+1. Install [Node.js](https://nodejs.org/)
 2. Install [pnpm](https://pnpm.io/installation)
 3. Install dependencies by running the following command:
   ```bash
@@ -20,8 +20,5 @@
    "@strudel/tonal": "workspace:*",
    "@strudel/transpiler": "workspace:*",
    "@strudel/webaudio": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -14,8 +14,5 @@
  },
  "dependencies": {
    "@strudel/web": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -18,8 +18,5 @@
    "@strudel/transpiler": "workspace:*",
    "@strudel/webaudio": "workspace:*",
    "@strudel/tonal": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -13,8 +13,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -32,8 +32,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -73,8 +73,5 @@
    "prettier": "^3.4.2",
    "vitest": "^3.0.4",
    "vite-plugin-bundle-audioworklet": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
-}
+}
@@ -1,10 +1,8 @@
 import jsdoc from '../../doc.json';
 import { autocompletion } from '@codemirror/autocomplete';
 import { h } from './html';
-//TODO: fix tonal scale import
-// import { Scale } from '@tonaljs/tonal';
-// import { soundMap } from '@strudel/webaudio';
-let soundMap = undefined;
+import { Scale } from '@tonaljs/tonal';
+import { soundMap } from 'superdough';
 import { complex } from '@strudel/tonal';

 const escapeHtml = (str) => {
@@ -81,9 +79,7 @@ const hasExcludedTags = (doc) =>
  ['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag));

 export function bankCompletions() {
-  // TODO: FIX IMPORT
-  const soundDict = soundMap?.get() ?? {};
-
+  const soundDict = soundMap.get();
  const banks = new Set();
  for (const key of Object.keys(soundDict)) {
    const [bank, suffix] = key.split('_');
@@ -94,13 +90,13 @@ export function bankCompletions() {
    .map((name) => ({ label: name, type: 'bank' }));
 }

-// Attempt to get all scale names from Tonal TODO: FIX IMPORT
+// Attempt to get all scale names from Tonal
 let scaleCompletions = [];
-// try {
-//   scaleCompletions = (Scale.names ? Scale.names() : []).map((name) => ({ label: name, type: 'scale' }));
-// } catch (e) {
-//   console.warn('[autocomplete] Could not load scale names from Tonal:', e);
-// }
+try {
+  scaleCompletions = (Scale.names ? Scale.names() : []).map((name) => ({ label: name, type: 'scale' }));
+} catch (e) {
+  console.warn('[autocomplete] Could not load scale names from Tonal:', e);
+}

 // Valid mode values for voicing
 const modeCompletions = [
@@ -272,7 +268,7 @@ function soundHandler(context) {
  const inside = text.slice(quoteIdx + 1);
  const fragMatch = inside.match(SOUND_FRAGMENT_MATCH_REGEX);
  const fragment = fragMatch ? fragMatch[1] : inside;
-  const soundNames = Object.keys(soundMap?.get() ?? {}).sort();
+  const soundNames = Object.keys(soundMap.get()).sort();
  const filteredSounds = soundNames.filter((name) => name.includes(fragment));
  let options = filteredSounds.map((name) => ({ label: name, type: 'sound' }));
  const from = soundContext.to - fragment.length;
@@ -54,8 +54,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -72,6 +72,15 @@ export function registerControl(names, ...aliases) {
  return bag;
 }

+// Constructs a superdirt effect bus control
+const bus = register('bus', function (busid, control_name, busval, pat) {
+  return pat[control_name]('c' + busid).withValue((val) => {
+    const newval = { ...val };
+    newval['^' + control_name] = [busid, busval];
+    return newval;
+  });
+});
+
 /**
 * Select a sound / sample by name. When using mininotation, you can also optionally supply 'n' and 'gain' parameters
 * separated by ':'.
@@ -1288,151 +1297,6 @@ export const { fanchor } = registerControl('fanchor');
 */
 // currently an alias of 'hcutoff' https://codeberg.org/uzu/strudel/issues/496
 // ['hpf'],
-
-/**
- * Rate of the LFO for the lowpass filter
- *
- * @name lprate
- * @param {number | Pattern} rate rate in hertz
- */
-export const { lprate } = registerControl('lprate');
-
-/**
- * Cycle-synced rate of the LFO for the lowpass filter
- *
- * @name lpsync
- * @param {number | Pattern} rate rate in cycles
- */
-export const { lpsync } = registerControl('lpsync');
-
-/**
- * Depth of the LFO for the lowpass filter
- *
- * @name lpdepth
- * @param {number | Pattern} depth depth of modulation
- */
-export const { lpdepth } = registerControl('lpdepth');
-
-/**
- * Shape of the LFO for the lowpass filter
- *
- * @name lpshape
- * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
- */
-export const { lpshape } = registerControl('lpshape');
-
-/**
- * DC offset of the LFO for the lowpass filter
- *
- * @name lpdc
- * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
- */
-export const { lpdc } = registerControl('lpdc');
-
-/**
- * Skew of the LFO for the lowpass filter
- *
- * @name lpskew
- * @param {number | Pattern} skew How much to bend the LFO shape
- */
-export const { lpskew } = registerControl('lpskew');
-
-/**
- * Rate of the LFO for the bandpass filter
- *
- * @name bprate
- * @param {number | Pattern} rate rate in hertz
- */
-export const { bprate } = registerControl('bprate');
-
-/**
- * Cycle-synced rate of the LFO for the bandpass filter
- *
- * @name bpsync
- * @param {number | Pattern} rate rate in cycles
- */
-export const { bpsync } = registerControl('bpsync');
-
-/**
- * Depth of the LFO for the bandpass filter
- *
- * @name bpdepth
- * @param {number | Pattern} depth depth of modulation
- */
-export const { bpdepth } = registerControl('bpdepth');
-
-/**
- * Shape of the LFO for the bandpass filter
- *
- * @name bpshape
- * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
- */
-export const { bpshape } = registerControl('bpshape');
-
-/**
- * DC offset of the LFO for the bandpass filter
- *
- * @name bpdc
- * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
- */
-export const { bpdc } = registerControl('bpdc');
-
-/**
- * Skew of the LFO for the bandpass filter
- *
- * @name bpskew
- * @param {number | Pattern} skew How much to bend the LFO shape
- */
-export const { bpskew } = registerControl('bpskew');
-
-/**
- * Rate of the LFO for the highpass filter
- *
- * @name hprate
- * @param {number | Pattern} rate rate in hertz
- */
-export const { hprate } = registerControl('hprate');
-
-/**
- * Cycle-synced rate of the LFO for the highpass filter
- *
- * @name hpsync
- * @param {number | Pattern} rate rate in cycles
- */
-export const { hpsync } = registerControl('hpsync');
-
-/**
- * Depth of the LFO for the highpass filter
- *
- * @name hpdepth
- * @param {number | Pattern} depth depth of modulation
- */
-export const { hpdepth } = registerControl('hpdepth');
-
-/**
- * Shape of the LFO for the highpass filter
- *
- * @name hpshape
- * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
- */
-export const { hpshape } = registerControl('hpshape');
-
-/**
- * DC offset of the LFO for the highpass filter
- *
- * @name hpdc
- * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
- */
-export const { hpdc } = registerControl('hpdc');
-
-/**
- * Skew of the LFO for the highpass filter
- *
- * @name hpskew
- * @param {number | Pattern} skew How much to bend the LFO shape
- */
-export const { hpskew } = registerControl('hpskew');
-
 /**
 * Applies a vibrato to the frequency of the oscillator.
 *
@@ -1895,64 +1759,17 @@ export const { semitone } = registerControl('semitone');
 // TODO: synth param
 export const { voice } = registerControl('voice');
 // voicings // https://codeberg.org/uzu/strudel/issues/506
-/**
- * The chord to voice
- * @name chord
- * @param {string | Pattern} symbols chord symbols to voice e.g., C, Eb, Fm7, G7. The symbols can be defined via addVoicings
- * @example
- * chord("<Am C D F Am E Am E>").voicing()
- **/
+// chord to voice, like C Eb Fm7 G7. the symbols can be defined via addVoicings
 export const { chord } = registerControl('chord');
-/**
- * Which dictionary to use for the voicings. This falls back to the default dictionary if not provided
- *
- * @name dictionary
- * @param {string} dictionaryName which dictionary (having been defined with `addVoicings`) to use
- * @example
- * addVoicings('house', {
-'': ['7 12 16', '0 7 16', '4 7 12'],
-'m': ['0 3 7']
-})
-chord("<Am C D F Am E Am E>")
-.dict('house').anchor(66)
-.voicing().room(.5)
- **/
+// which dictionary to use for the voicings
 export const { dictionary, dict } = registerControl('dictionary', 'dict');
-/** The top note to align the voicing to. Defaults to c5
- *
- * @name anchor
- * @param {string | Pattern} anchorNote the note to align the voicings to
- * @example
- * anchor("<c4 g4 c5 g5>").chord("C").voicing()
- **/
+// the top note to align the voicing to, defaults to c5
 export const { anchor } = registerControl('anchor');
-/**
- * Sets how the voicing is offset from the anchored position
- *
- * @name offset
- * @param {number | Pattern} shift the amount to shift the voicing up or down
- * @example
- * chord("<Am C D F Am E Am E>").offset("<0 1 2 3 4 5>") // alter the voicing each time
- **/
+// how the voicing is offset from the anchored position
 export const { offset } = registerControl('offset');
-/**
- *  How many octaves are voicing steps spread apart, defaults to 1
- *
- *  @name octaves
- *  @param {number | Pattern} count the number of octaves
- *  @example
- *  chord("<Am C D F Am E Am E>").octaves("<2 4>").voicing()
- **/
+// how many octaves are voicing steps spread apart, defaults to 1
 export const { octaves } = registerControl('octaves');
-/**
- * Remove anchor note from the voicing. Useful for melody harmonization
- *
- * @name mode
- * @param {string | Pattern} modeName one of {below | above | duck | root}
- * @example
- * mode("<below above duck root>").chord("C").voicing()
- *
- **/
+// below = anchor note will be removed from the voicing, useful for melody harmonization
 export const { mode } = registerControl(['mode', 'anchor']);

 /**
@@ -58,11 +58,10 @@ export class Cyclist {

          // query the pattern for events
          const haps = this.pattern.queryArc(begin, end, { _cps: this.cps, cyclist: 'cyclist' });
-
          haps.forEach((hap) => {
-            if (hap.hasOnset()) {
+            if (hap.hasOnset() || hap.context.processParts) {
              const targetTime =
-                (hap.whole.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
+                (hap.part.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
              const duration = hap.duration / this.cps;
              // the following line is dumb and only here for backwards compatibility
              // see https://codeberg.org/uzu/strudel/pulls/1004
@@ -16,7 +16,7 @@ export class Hap {
      then the whole will be returned as None, in which case the given
      value will have been sampled from the point halfway between the
      start and end of the 'part' timespan.
-      The context is to store a list of source code locations causing the event.
+      The context is to store metadata, including a list of source code locations causing the event.

      The word 'Event' is more or less a reserved word in javascript, hence this
      class is named called 'Hap'.
@@ -161,6 +161,10 @@ export class Hap {
    return new Hap(this.whole, this.part, this.value, context);
  }

+  withContext(f) {
+    return new Hap(this.whole, this.part, this.value, f(this.context));
+  }
+
  ensureObjectValue() {
    /* if (isNote(hap.value)) {
      // supports primitive hap values that look like notes
@@ -37,8 +37,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -62,7 +62,12 @@ export class Pattern {
    this.__steps = steps === undefined ? undefined : Fraction(steps);
  }

+  _processParts() {
+    return this.withHap((hap) => hap.withContext((c) => ({ ...c, processParts: true })));
+  }
+
  setSteps(steps) {
+    // TODO shouldn't this be pure and return a new pattern?
    this._steps = steps;
    return this;
  }
@@ -38,8 +38,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -25,8 +25,5 @@
    "@strudel/core": "workspace:*",
    "@tauri-apps/api": "^2.2.0"
  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme",
-  "engines": {
-    "node": ">=18.0.0"
-  }
+  "homepage": "https://codeberg.org/uzu/strudel#readme"
 }
@@ -33,8 +33,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -20,8 +20,5 @@
  "bugs": {
    "url": "https://codeberg.org/uzu/strudel/issues"
  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme",
-  "engines": {
-    "node": ">=18.0.0"
-  }
+  "homepage": "https://codeberg.org/uzu/strudel#readme"
 }
@@ -40,12 +40,6 @@ const pattern = sequence([
 - D-Pad
  - `up`, `down`, `left`, `right` (or `u`, `d`, `l`, `r` or uppercase)
  - Toggle versions: `tglUp`, `tglDown`, `tglLeft`, `tglRight`(or `tglU`, `tglD`, `tglL`, `tglR`)
- Stick Buttons
-  - `l3`, `r3` (or `ls`, `rs`)
-  - Toggle versions: `tglL3`, `tglR3` (or `tglLS`, `tglRS`)
- System Buttons
-  - `start`, `back` (or uppercase `START`, `BACK`)
-  - Toggle versions: `tglStart`, `tglBack` (or `tglSTART`, `tglBACK`)

 ### Analog Sticks
 - Left Stick
@@ -29,10 +29,6 @@ The gamepad module provides access to buttons and analog sticks as normalized si
 |                  | Toggle versions: `tglLB`, `tglRB`, `tglLT`, `tglRT`                                            |
 | D-Pad            | `up`, `down`, `left`, `right` (or `u`, `d`, `l`, `r` or uppercase)                             |
 |                  | Toggle versions: `tglUp`, `tglDown`, `tglLeft`, `tglRight` (or `tglU`, `tglD`, `tglL`, `tglR`) |
-| Stick Buttons    | `l3`, 'r3' (or `ls`, `rs`)                                                                     |
-|                  | Toggle versions: `tglL3`, 'tglR3' (or `tglLs`, `tglRs`)                                        |
-| System Buttons   | `start`, `back` (or uppercase `START`, `BACK`)                                                 |
-|                  | Toggle versions: `tglStart`, `tglBack` (or `tglSTART`, `tglBACK`)                              |

 ### Analog Sticks

@@ -14,10 +14,6 @@ export const buttonMap = {
  rt: 7,
  back: 8,
  start: 9,
-  l3: 10,
-  ls: 10,
-  r3: 11,
-  rs: 11,
  u: 12,
  up: 12,
  d: 13,
@@ -33,8 +33,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -34,8 +34,5 @@
  "devDependencies": {
    "tree-sitter-haskell": "^0.23.1",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -40,8 +40,5 @@
  "devDependencies": {
    "pkg": "^5.8.1",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -5,10 +5,9 @@ This program is free software: you can redistribute it and/or modify it under th
 */

 import * as _WebMidi from 'webmidi';
-import { Pattern, isPattern, logger, ref } from '@strudel/core';
+import { Pattern, getEventOffsetMs, isPattern, logger, ref } from '@strudel/core';
 import { noteToMidi, getControlName } from '@strudel/core';
 import { Note } from 'webmidi';
-import { scheduleAtTime } from '../superdough/helpers.mjs';

 // if you use WebMidi from outside of this package, make sure to import that instance:
 export const { WebMidi } = _WebMidi;
@@ -191,7 +190,7 @@ function mapCC(mapping, value) {
 }

 // sends a cc message to the given device on the given channel
-function sendCC(ccn, ccv, device, midichan, targetTime) {
+function sendCC(ccn, ccv, device, midichan, timeOffsetString) {
  if (typeof ccv !== 'number' || ccv < 0 || ccv > 1) {
    throw new Error('expected ccv to be a number between 0 and 1');
  }
@@ -199,23 +198,19 @@ function sendCC(ccn, ccv, device, midichan, targetTime) {
    throw new Error('expected ccn to be a number or a string');
  }
  const scaled = Math.round(ccv * 127);
-  scheduleAtTime(() => {
-    device.sendControlChange(ccn, scaled, midichan);
-  }, targetTime);
+  device.sendControlChange(ccn, scaled, midichan, { time: timeOffsetString });
 }

 // sends a program change message to the given device on the given channel
-function sendProgramChange(progNum, device, midichan, targetTime) {
+function sendProgramChange(progNum, device, midichan, timeOffsetString) {
  if (typeof progNum !== 'number' || progNum < 0 || progNum > 127) {
    throw new Error('expected progNum (program change) to be a number between 0 and 127');
  }
-  scheduleAtTime(() => {
-    device.sendProgramChange(progNum, midichan);
-  }, targetTime);
+  device.sendProgramChange(progNum, midichan, { time: timeOffsetString });
 }

 // sends a sysex message to the given device on the given channel
-function sendSysex(sysexid, sysexdata, device, targetTime) {
+function sendSysex(sysexid, sysexdata, device, timeOffsetString) {
  if (Array.isArray(sysexid)) {
    if (!sysexid.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
      throw new Error('all sysexid bytes must be integers between 0 and 255');
@@ -230,13 +225,11 @@ function sendSysex(sysexid, sysexdata, device, targetTime) {
  if (!sysexdata.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
    throw new Error('all sysex bytes must be integers between 0 and 255');
  }
-  scheduleAtTime(() => {
-    device.sendSysex(sysexid, sysexdata);
-  }, targetTime);
+  device.sendSysex(sysexid, sysexdata, { time: timeOffsetString });
 }

 // sends a NRPN message to the given device on the given channel
-function sendNRPN(nrpnn, nrpv, device, midichan, targetTime) {
+function sendNRPN(nrpnn, nrpv, device, midichan, timeOffsetString) {
  if (Array.isArray(nrpnn)) {
    if (!nrpnn.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
      throw new Error('all nrpnn bytes must be integers between 0 and 255');
@@ -244,34 +237,28 @@ function sendNRPN(nrpnn, nrpv, device, midichan, targetTime) {
  } else if (!Number.isInteger(nrpv) || nrpv < 0 || nrpv > 255) {
    throw new Error('A:sysexid must be an number between 0 and 255 or an array of such integers');
  }
-  scheduleAtTime(() => {
-    device.sendNRPN(nrpnn, nrpv, midichan);
-  }, targetTime);
+
+  device.sendNRPN(nrpnn, nrpv, midichan, { time: timeOffsetString });
 }

 // sends a pitch bend message to the given device on the given channel
-function sendPitchBend(midibend, device, midichan, targetTime) {
+function sendPitchBend(midibend, device, midichan, timeOffsetString) {
  if (typeof midibend !== 'number' || midibend < -1 || midibend > 1) {
    throw new Error('expected midibend to be a number between -1 and 1');
  }
-  scheduleAtTime(() => {
-    device.sendPitchBend(midibend, midichan);
-  }, targetTime);
+  device.sendPitchBend(midibend, midichan, { time: timeOffsetString });
 }

 // sends a channel aftertouch message to the given device on the given channel
-function sendAftertouch(miditouch, device, midichan, targetTime) {
+function sendAftertouch(miditouch, device, midichan, timeOffsetString) {
  if (typeof miditouch !== 'number' || miditouch < 0 || miditouch > 1) {
    throw new Error('expected miditouch to be a number between 0 and 1');
  }
-
-  scheduleAtTime(() => {
-    device.sendChannelAftertouch(miditouch, midichan);
-  }, targetTime);
+  device.sendChannelAftertouch(miditouch, midichan, { time: timeOffsetString });
 }

 // sends a note message to the given device on the given channel
-function sendNote(note, velocity, duration, device, midichan, targetTime) {
+function sendNote(note, velocity, duration, device, midichan, timeOffsetString) {
  if (note == null || note === '') {
    throw new Error('note cannot be null or empty');
  }
@@ -281,12 +268,12 @@ function sendNote(note, velocity, duration, device, midichan, targetTime) {
  if (duration != null && (typeof duration !== 'number' || duration < 0)) {
    throw new Error('duration must be a positive number');
  }
+
  const midiNumber = typeof note === 'number' ? note : noteToMidi(note);
  const midiNote = new Note(midiNumber, { attack: velocity, duration });
-
-  scheduleAtTime(() => {
-    device.playNote(midiNote, midichan);
-  }, targetTime);
+  device.playNote(midiNote, midichan, {
+    time: timeOffsetString,
+  });
 }

 /**
@@ -322,6 +309,7 @@ Pattern.prototype.midi = function (midiport, options = {}) {
  let midiConfig = {
    // Default configuration values
    isController: false, // Disable sending notes for midi controllers
+    latencyMs: 34, // Default latency to get audio engine to line up in ms
    noteOffsetMs: 10, // Default note-off offset to prevent glitching in ms
    midichannel: 1, // Default MIDI channel
    velocity: 0.9, // Default velocity
@@ -345,13 +333,18 @@ Pattern.prototype.midi = function (midiport, options = {}) {
      logger(`Midi device disconnected! Available: ${getMidiDeviceNamesString(outputs)}`),
  });

-  return this.onTrigger((hap, _currentTime, cps, targetTime) => {
+  return this.onTrigger((hap, currentTime, cps, targetTime) => {
    if (!WebMidi.enabled) {
      logger('Midi not enabled');
      return;
    }
    hap.ensureObjectValue();

+    //magic number to get audio engine to line up, can probably be calculated somehow
+    const latencyMs = midiConfig.latencyMs;
+    // passing a string with a +num into the webmidi api adds an offset to the current time https://webmidijs.org/api/classes/Output
+    const timeOffsetString = `+${getEventOffsetMs(targetTime, currentTime) + latencyMs}`;
+
    // midi event values from hap with configurable defaults
    let {
      note,
@@ -387,7 +380,7 @@ Pattern.prototype.midi = function (midiport, options = {}) {
    // if midimap is set, send a cc messages from defined controls
    if (midicontrolMap.has(midimap)) {
      const ccs = mapCC(midicontrolMap.get(midimap), hap.value);
-      ccs.forEach(({ ccn, ccv }) => sendCC(ccn, ccv, device, midichan, targetTime));
+      ccs.forEach(({ ccn, ccv }) => sendCC(ccn, ccv, device, midichan, timeOffsetString));
    } else if (midimap !== 'default') {
      // Add warning when a non-existent midimap is specified
      logger(`[midi] midimap "${midimap}" not found! Available maps: ${[...midicontrolMap.keys()].join(', ')}`);
@@ -399,12 +392,12 @@ Pattern.prototype.midi = function (midiport, options = {}) {
      // try to prevent glitching by subtracting noteOffsetMs from the duration length
      const duration = (hap.duration.valueOf() / cps) * 1000 - midiConfig.noteOffsetMs;

-      sendNote(note, velocity, duration, device, midichan, targetTime);
+      sendNote(note, velocity, duration, device, midichan, timeOffsetString);
    }

    // Handle program change
    if (progNum !== undefined) {
-      sendProgramChange(progNum, device, midichan, targetTime);
+      sendProgramChange(progNum, device, midichan, timeOffsetString);
    }

    // Handle sysex
@@ -414,63 +407,53 @@ Pattern.prototype.midi = function (midiport, options = {}) {
    // if sysexid is an array the first byte is 0x00

    if (sysexid !== undefined && sysexdata !== undefined) {
-      sendSysex(sysexid, sysexdata, device, targetTime);
+      sendSysex(sysexid, sysexdata, device, timeOffsetString);
    }

    // Handle control change
    if (ccv !== undefined && ccn !== undefined) {
-      sendCC(ccn, ccv, device, midichan, targetTime);
+      sendCC(ccn, ccv, device, midichan, timeOffsetString);
    }

    // Handle NRPN non-registered parameter number
    if (nrpnn !== undefined && nrpv !== undefined) {
-      sendNRPN(nrpnn, nrpv, device, midichan, targetTime);
+      sendNRPN(nrpnn, nrpv, device, midichan, timeOffsetString);
    }

    // Handle midibend
    if (midibend !== undefined) {
-      sendPitchBend(midibend, device, midichan, targetTime);
+      sendPitchBend(midibend, device, midichan, timeOffsetString);
    }

    // Handle miditouch
    if (miditouch !== undefined) {
-      sendAftertouch(miditouch, device, midichan, targetTime);
+      sendAftertouch(miditouch, device, midichan, timeOffsetString);
    }

    // Handle midicmd
    if (hap.whole.begin + 0 === 0) {
      // we need to start here because we have the timing info
-      scheduleAtTime(() => {
-        device.sendStart();
-      }, targetTime);
+      device.sendStart({ time: timeOffsetString });
    }
    if (['clock', 'midiClock'].includes(midicmd)) {
-      scheduleAtTime(() => {
-        device.sendClock();
-      }, targetTime);
+      device.sendClock({ time: timeOffsetString });
    } else if (['start'].includes(midicmd)) {
-      scheduleAtTime(() => {
-        device.sendStart();
-      }, targetTime);
+      device.sendStart({ time: timeOffsetString });
    } else if (['stop'].includes(midicmd)) {
-      scheduleAtTime(() => {
-        device.sendStop();
-      }, targetTime);
+      device.sendStop({ time: timeOffsetString });
    } else if (['continue'].includes(midicmd)) {
-      scheduleAtTime(() => {
-        device.sendContinue();
-      }, targetTime);
+      device.sendContinue({ time: timeOffsetString });
    } else if (Array.isArray(midicmd)) {
      if (midicmd[0] === 'progNum') {
-        sendProgramChange(midicmd[1], device, midichan, targetTime);
+        sendProgramChange(midicmd[1], device, midichan, timeOffsetString);
      } else if (midicmd[0] === 'cc') {
        if (midicmd.length === 2) {
-          sendCC(midicmd[0], midicmd[1] / 127, device, midichan, targetTime);
+          sendCC(midicmd[0], midicmd[1] / 127, device, midichan, timeOffsetString);
        }
      } else if (midicmd[0] === 'sysex') {
        if (midicmd.length === 3) {
          const [_, id, data] = midicmd;
-          sendSysex(id, data, device, targetTime);
+          sendSysex(id, data, device, timeOffsetString);
        }
      }
    }
@@ -35,8 +35,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -38,8 +38,5 @@
    "peggy": "^4.2.0",
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -33,8 +33,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -40,8 +40,5 @@
    "mondo": "*",
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -33,8 +33,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -34,8 +34,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -52,6 +52,7 @@ export function parseControlsFromHap(hap, cps) {
  controls.unit === 'c' && controls.speed != null && (controls.speed = controls.speed / cps);
  const channels = controls.channels;
  channels != undefined && (controls.channels = JSON.stringify(channels));
+
  return controls;
 }

@@ -63,16 +64,42 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
  const keyvals = Object.entries(controls).flat();
  const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
  const msg = { address: '/dirt/play', args: keyvals, timestamp: ts };
-
-  if ('oschost' in hap.value) {
-    msg['host'] = hap.value['oschost'];
-  }
-  if ('oscport' in hap.value) {
-    msg['port'] = hap.value['oscport'];
-  }
  ws.send(JSON.stringify(msg));
 }

+export async function superdirtTrigger(hap, currentTime, cps = 1, targetTime) {
+  const ws = await connect();
+  const controls = parseControlsFromHap(hap, cps);
+  const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
+
+  let oschost = '127.0.0.1';
+  let oscport = 57120;
+  let bushost = oschost;
+  let busport = 57110;
+
+  for (const [k, v] of Object.entries(controls)) {
+    if (k.startsWith('^')) {
+      const bus_idval = v;
+      const msg = JSON.stringify({
+        oschost: bushost,
+        oscport: busport,
+        address: '/c_set',
+        args: bus_idval,
+        timestamp: ts,
+      });
+      // console.log('bus message', msg);
+      ws.send(msg);
+      // So they aren't sent with trigger messages
+      delete controls[k];
+    }
+  }
+
+  if (hap.hasOnset()) {
+    const keyvals = Object.entries(controls).flat();
+    ws.send(JSON.stringify({ oschost, oscport, address: '/dirt/play', args: keyvals, timestamp: ts }));
+  }
+}
+
 /**
 *
 * Sends each hap as an OSC message, which can be picked up by SuperCollider or any other OSC-enabled software.
@@ -83,3 +110,4 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
 * @returns Pattern
 */
 export const osc = register('osc', (pat) => pat.onTrigger(oscTrigger));
+export const superdirt = register('superdirt', (pat) => pat._processParts().onTrigger(superdirtTrigger));
@@ -44,8 +44,5 @@
  "devDependencies": {
    "pkg": "^5.8.1",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -12,18 +12,13 @@ import { WebSocketServer } from 'ws';
 import osc from 'osc';

 const WS_PORT = 8080; // WebSocket server port
-const OSC_REMOTE_IP = '127.0.0.1';
-const OSC_REMOTE_PORT = 57120;

 const udpPort = new osc.UDPPort({
  localAddress: '0.0.0.0',
  localPort: 0,
-  remoteAddress: OSC_REMOTE_IP,
-  remotePort: OSC_REMOTE_PORT,
 });

 udpPort.open();
-console.log(`[Sending OSC] ${OSC_REMOTE_IP}:${OSC_REMOTE_PORT}`);

 udpPort.on('error', (e) => {
  console.log('Error: ', e);
@@ -36,23 +31,24 @@ wss.on('connection', (ws) => {
  console.log('New WebSocket connection');

  ws.on('message', (message) => {
-    let osc_host = '127.0.0.1';
-    let osc_port = 57120;
+    let oschost = '127.0.0.1';
+    let oscport = 57120;

    try {
      const data = JSON.parse(message);
-      if ('host' in data) {
-        osc_host = data['host'];
+      if ('oschost' in data) {
+        oschost = data['oschost'];
+        delete data['oschost'];
      }
-      if ('port' in data) {
-        osc_port = data['port'];
+      if ('oscport' in data) {
+        oscport = data['oscport'];
+        delete data['oscport'];
      }
      let msg = { address: data['address'], args: data['args'] };
      if ('timestamp' in data) {
        msg = { timeTag: osc.timeTag(0, data['timestamp']), packets: [msg] };
      }
-
-      udpPort.send(msg, osc_host, osc_port);
+      udpPort.send(msg, oschost, oscport);
    } catch (err) {
      console.error('Error parsing message:', err);
    }
@@ -33,8 +33,5 @@
  "homepage": "https://codeberg.org/uzu/strudel#readme",
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -48,8 +48,5 @@
    "@rollup/plugin-replace": "^6.0.2",
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -15,8 +15,5 @@
  "type": "module",
  "dependencies": {
    "cowsay": "^1.6.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -33,8 +33,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -37,8 +37,5 @@
  "devDependencies": {
    "node-fetch": "^3.3.2",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -154,24 +154,6 @@ export const getADSRValues = (params, curve = 'linear', defaultValues) => {
  return [Math.max(a ?? 0, envmin), Math.max(d ?? 0, envmin), Math.min(sustain, envmax), Math.max(r ?? 0, releaseMin)];
 };

-export function getParamLfo(audioContext, param, start, end, lfoValues) {
-  let { defaultDepth = 1, depth, dcoffset, ...getLfoInputs } = lfoValues;
-  if (depth == null) {
-    const hasLFOParams = Object.values(getLfoInputs).some((v) => v != null);
-    depth = hasLFOParams ? defaultDepth : 0;
-  }
-  let lfo;
-  if (depth) {
-    lfo = getLfo(audioContext, start, end, {
-      depth,
-      dcoffset,
-      ...getLfoInputs,
-    });
-    lfo.connect(param);
-  }
-  return lfo;
-}
-
 // helper utility for applying standard modulators to a parameter
 export function applyParameterModulators(audioContext, param, start, end, envelopeValues, lfoValues) {
  let { amount, offset, defaultAmount = 1, curve = 'linear', values, holdEnd, defaultValues } = envelopeValues;
@@ -188,58 +170,55 @@ export function applyParameterModulators(audioContext, param, start, end, envelo
    const [attack, decay, sustain, release] = getADSRValues(values, curve, defaultValues);
    getParamADSR(param, attack, decay, sustain, release, min, max, start, holdEnd, curve);
  }
-  const lfo = getParamLfo(audioContext, param, start, end, lfoValues);
+  let lfo;
+  let { defaultDepth = 1, depth, dcoffset, ...getLfoInputs } = lfoValues;
+
+  if (depth == null) {
+    const hasLFOParams = Object.values(getLfoInputs).some((v) => v != null);
+    depth = hasLFOParams ? defaultDepth : 0;
+  }
+  if (depth) {
+    lfo = getLfo(audioContext, start, end, {
+      depth,
+      dcoffset,
+      ...getLfoInputs,
+    });
+    lfo.connect(param);
+  }
+
  return { lfo, disconnect: () => lfo?.disconnect() };
 }

-export function createFilter(context, start, end, params, cps) {
-  let {
-    frequency,
-    anchor,
-    env,
-    type,
-    model,
-    q = 1,
-    drive = 0.69,
-    depth,
-    dcoffset = -0.5,
-    skew,
-    shape,
-    rate,
-    sync,
-  } = params;
-  let frequencyParam, filter;
+export function createFilter(context, type, frequency, Q, att, dec, sus, rel, fenv, start, end, fanchor, model, drive) {
+  const curve = 'exponential';
+  const [attack, decay, sustain, release] = getADSRValues([att, dec, sus, rel], curve, [0.005, 0.14, 0, 0.1]);
+  let filter;
+  let frequencyParam;
  if (model === 'ladder') {
-    filter = getWorklet(context, 'ladder-processor', { frequency, q, drive });
+    filter = getWorklet(context, 'ladder-processor', { frequency, q: Q, drive });
    frequencyParam = filter.parameters.get('frequency');
  } else {
    filter = context.createBiquadFilter();
    filter.type = type;
-    filter.Q.value = q;
+    filter.Q.value = Q;
    filter.frequency.value = frequency;
    frequencyParam = filter.frequency;
  }
-  const envelopeValues = [params.attack, params.decay, params.sustain, params.release];
-  const [attack, decay, sustain, release] = getADSRValues(envelopeValues, 'exponential', [0.005, 0.14, 0, 0.1]);
-  // envelope is active when any of these values is set
-  const hasEnvelope = [...envelopeValues, env].some((v) => v !== undefined);
-  // Apply ADSR to filter frequency
-  if (hasEnvelope) {
-    env = nanFallback(env, 1, true);
-    anchor = nanFallback(anchor, 0, true);
-    const envAbs = Math.abs(env);
-    const offset = envAbs * anchor;
-    let min = clamp(2 ** -offset * frequency, 0, 20000);
-    let max = clamp(2 ** (envAbs - offset) * frequency, 0, 20000);
-    if (env < 0) [min, max] = [max, min];
-    getParamADSR(frequencyParam, attack, decay, sustain, release, min, max, start, end, 'exponential');
-  }

-  if (sync != null) {
-    rate = cps * sync;
+  // envelope is active when any of these values is set
+  const hasEnvelope = att ?? dec ?? sus ?? rel ?? fenv;
+  // Apply ADSR to filter frequency
+  if (hasEnvelope !== undefined) {
+    fenv = nanFallback(fenv, 1, true);
+    fanchor = nanFallback(fanchor, 0, true);
+    const fenvAbs = Math.abs(fenv);
+    const offset = fenvAbs * fanchor;
+    let min = clamp(2 ** -offset * frequency, 0, 20000);
+    let max = clamp(2 ** (fenvAbs - offset) * frequency, 0, 20000);
+    if (fenv < 0) [min, max] = [max, min];
+    getParamADSR(frequencyParam, attack, decay, sustain, release, min, max, start, end, curve);
+    return filter;
  }
-  const lfoValues = { depth, dcoffset, skew, shape, frequency: rate };
-  getParamLfo(context, frequencyParam, start, end, lfoValues);
  return filter;
 }

@@ -301,11 +280,6 @@ export function getVibratoOscillator(param, value, t) {
    return vibratoOscillator;
  }
 }
-
-export function scheduleAtTime(callback, targetTime, audioContext = getAudioContext()) {
-  const currentTime = audioContext.currentTime;
-  webAudioTimeout(audioContext, callback, currentTime, targetTime);
-}
 // ConstantSource inherits AudioScheduledSourceNode, which has scheduling abilities
 // a bit of a hack, but it works very well :)
 export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
@@ -37,8 +37,5 @@
  },
  "dependencies": {
    "nanostores": "^0.11.3"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -104,8 +104,6 @@ var applyGradualLowpass = function (input, lpFreqStart, lpFreqEnd, lpFreqEndAt,
  player.start();
  context.oncomplete = function (event) {
    callback(event.renderedBuffer);
-    filter.disconnect();
-    player.disconnect();
  };
  context.startRendering();

@@ -7,7 +7,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import './feedbackdelay.mjs';
 import './reverb.mjs';
 import './vowel.mjs';
-import { nanFallback, _mod, cycleToSeconds, pickAndRename } from './util.mjs';
+import { nanFallback, _mod, cycleToSeconds } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
 import { createFilter, gainNode, getCompressor, getDistortion, getLfo, getWorklet, effectSend } from './helpers.mjs';
 import { map } from 'nanostores';
@@ -146,6 +146,11 @@ let defaultDefaultValues = {
  gain: 0.8,
  postgain: 1,
  density: '.03',
+  ftype: '12db',
+  fanchor: 0,
+  resonance: 1,
+  hresonance: 1,
+  bandq: 1,
  channels: [1, 2],
  phaserdepth: 0.75,
  shapevol: 1,
@@ -410,7 +415,32 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    djf,
    // filters
    fanchor = getDefaultValue('fanchor'),
+    drive = 0.69,
    release = 0,
+    // low pass
+    cutoff,
+    lpenv,
+    lpattack,
+    lpdecay,
+    lpsustain,
+    lprelease,
+    resonance = getDefaultValue('resonance'),
+    // high pass
+    hpenv,
+    hcutoff,
+    hpattack,
+    hpdecay,
+    hpsustain,
+    hprelease,
+    hresonance = getDefaultValue('hresonance'),
+    // band pass
+    bpenv,
+    bandf,
+    bpattack,
+    bpdecay,
+    bpsustain,
+    bprelease,
+    bandq = getDefaultValue('bandq'),

    //phaser
    phaserrate: phaser,
@@ -481,7 +511,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  // oldest audio nodes will be destroyed if maximum polyphony is exceeded
  for (let i = 0; i <= activeSoundSources.size - maxPolyphony; i++) {
    const ch = activeSoundSources.entries().next();
-    const source = ch.value[1].deref();
+    const source = ch.value[1];
    const chainID = ch.value[0];
    const endTime = t + 0.25;
    source?.node?.gain?.linearRampToValueAtTime(0, endTime);
@@ -513,7 +543,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)

    if (soundHandle) {
      sourceNode = soundHandle.node;
-      activeSoundSources.set(chainID, new WeakRef(soundHandle)); // allow GC
+      activeSoundSources.set(chainID, soundHandle);
    }
  } else {
    throw new Error(`sound ${s} not found! Is it loaded?`);
@@ -535,87 +565,57 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  // gain stage
  chain.push(gainNode(gain));

-  // filter
+  //filter
  const ftype = getFilterType(value.ftype);
-
-  if (value.cutoff !== undefined) {
-    const lpMap = {
-      frequency: 'cutoff',
-      q: 'resonance',
-      attack: 'lpattack',
-      decay: 'lpdecay',
-      sustain: 'lpsustain',
-      release: 'lprelease',
-      env: 'lpenv',
-      anchor: 'fanchor',
-      model: 'ftype',
-      drive: 'drive',
-      rate: 'lprate',
-      sync: 'lpsync',
-      depth: 'lpdepth',
-      shape: 'lpshape',
-      dcoffset: 'lpdc',
-      skew: 'lpskew',
-    };
-    const lpParams = pickAndRename(value, lpMap);
-    lpParams.type = 'lowpass';
-    let lp = () => createFilter(ac, t, end, lpParams, cps);
+  if (cutoff !== undefined) {
+    let lp = () =>
+      createFilter(
+        ac,
+        'lowpass',
+        cutoff,
+        resonance,
+        lpattack,
+        lpdecay,
+        lpsustain,
+        lprelease,
+        lpenv,
+        t,
+        end,
+        fanchor,
+        ftype,
+        drive,
+      );
    chain.push(lp());
    if (ftype === '24db') {
      chain.push(lp());
    }
  }

-  if (value.hcutoff !== undefined) {
-    const hpMap = {
-      frequency: 'hcutoff',
-      q: 'hresonance',
-      attack: 'hpattack',
-      decay: 'hpdecay',
-      sustain: 'hpsustain',
-      release: 'hprelease',
-      env: 'hpenv',
-      anchor: 'fanchor',
-      model: 'ftype',
-      drive: 'drive',
-      rate: 'hprate',
-      sync: 'hpsync',
-      depth: 'hpdepth',
-      shape: 'hpshape',
-      dcoffset: 'hpdc',
-      skew: 'hpskew',
-    };
-    const hpParams = pickAndRename(value, hpMap);
-    hpParams.type = 'highpass';
-    let hp = () => createFilter(ac, t, end, hpParams, cps);
+  if (hcutoff !== undefined) {
+    let hp = () =>
+      createFilter(
+        ac,
+        'highpass',
+        hcutoff,
+        hresonance,
+        hpattack,
+        hpdecay,
+        hpsustain,
+        hprelease,
+        hpenv,
+        t,
+        end,
+        fanchor,
+      );
    chain.push(hp());
    if (ftype === '24db') {
      chain.push(hp());
    }
  }

-  if (value.bandf !== undefined) {
-    const bpMap = {
-      frequency: 'bandf',
-      q: 'bandq',
-      attack: 'bpattack',
-      decay: 'bpdecay',
-      sustain: 'bpsustain',
-      release: 'bprelease',
-      env: 'bpenv',
-      anchor: 'fanchor',
-      model: 'ftype',
-      drive: 'drive',
-      rate: 'bprate',
-      sync: 'bpsync',
-      depth: 'bpdepth',
-      shape: 'bpshape',
-      dcoffset: 'bpdc',
-      skew: 'bpskew',
-    };
-    const bpParams = pickAndRename(value, bpMap);
-    bpParams.type = 'bandpass';
-    let bp = () => createFilter(ac, t, end, bpParams, cps);
+  if (bandf !== undefined) {
+    let bp = () =>
+      createFilter(ac, 'bandpass', bandf, bandq, bpattack, bpdecay, bpsustain, bprelease, bpenv, t, end, fanchor);
    chain.push(bp());
    if (ftype === '24db') {
      chain.push(bp());
@@ -708,8 +708,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      roomIR = await loadBuffer(url, ac, ir, 0);
    }
    orbitBus.getReverb(roomsize, roomfade, roomlp, roomdim, roomIR, irspeed, irbegin);
-    const send = orbitBus.sendReverb(post, room);
-    audioNodes.push(send);
+    orbitBus.sendReverb(post, room);
  }

  if (djf != null) {
@@ -78,7 +78,7 @@ export class Orbit {
    return this.reverbNode;
  }
  sendReverb(node, amount) {
-    return effectSend(node, this.reverbNode, amount);
+    effectSend(node, this.reverbNode, amount);
  }

  sendDelay(node, amount) {
@@ -109,8 +109,3 @@ export function getCommonSampleInfo(hapValue, bank) {
  const label = `${s}:${index}`;
  return { transpose, url, index, midi, label };
 }
-
-/** Selects entries from `source` and renames them via `map` */
-export const pickAndRename = (source, map) => {
-  return Object.fromEntries(Object.entries(map).map(([newKey, oldKey]) => [newKey, source[oldKey]]));
-};
@@ -6,57 +6,51 @@ import OLAProcessor from './ola-processor';
 import FFT from './fft.js';
 import { getDistortionAlgorithm } from './helpers.mjs';

-const blockSize = 128;
-const PI = Math.PI;
-const TWO_PI = 2 * PI;
-const INVSR = 1 / sampleRate;
-
 const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 const mod = (n, m) => ((n % m) + m) % m;
 const lerp = (a, b, n) => n * (b - a) + a;
 const pv = (arr, n) => arr[n] ?? arr[0];
 const frac = (x) => x - Math.floor(x);
+const ffloor = (x) => x | 0; // fast floor for non-negative

-// Fast integer ops for non-negative values
-const ffloor = (x) => x | 0;
-const fround = (x) => ffloor(x + 0.5);
-const fceil = (x) => ffloor(x + 1);
-const ffrac = (x) => x - ffloor(x);
-
-const fast_tanh = (x) => {
-  const x2 = x ** 2;
-  return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
-};
-
-// Optimized per-voice detuner which precomputes constants
-const getDetuner = (unison, detune) => {
+const getUnisonDetune = (unison, detune, voiceIndex) => {
  if (unison < 2) {
-    return (_voiceIdx) => 0;
+    return 0;
  }
-  const scale = detune / (unison - 1);
-  const center = detune * 0.5;
-  return (voiceIdx) => voiceIdx * scale - center;
+  return lerp(-detune * 0.5, detune * 0.5, voiceIndex / (unison - 1));
 };
-
 const applySemitoneDetuneToFrequency = (frequency, detune) => {
  return frequency * Math.pow(2, detune / 12);
 };

+// Restrict phase to the range [0, maxPhase) via wrapping
+function wrapPhase(phase, maxPhase = 1) {
+  if (phase >= maxPhase) {
+    phase -= maxPhase;
+  } else if (phase < 0) {
+    phase += maxPhase;
+  }
+  return phase;
+}
+const blockSize = 128;
 // Smooth waveshape near discontinuities to remove frequencies above Nyquist and prevent aliasing
 // referenced from https://www.kvraudio.com/forum/viewtopic.php?t=375517
 function polyBlep(phase, dt) {
  dt = Math.min(dt, 1 - dt);
-  const invdt = 1 / dt;
  // Start of cycle
  if (phase < dt) {
-    phase *= invdt;
-    return 2 * phase - phase ** 2 - 1;
+    phase /= dt;
+    // 2 * (phase - phase^2/2 - 0.5)
+    return phase + phase - phase * phase - 1;
  }
+
  // End of cycle
  else if (phase > 1 - dt) {
-    phase = (phase - 1) * invdt;
-    return phase ** 2 + 2 * phase + 1;
+    phase = (phase - 1) / dt;
+    // 2 * (phase^2/2 + phase + 0.5)
+    return phase * phase + phase + phase + 1;
  }
+
  // 0 otherwise
  else {
    return 0;
@@ -72,7 +66,7 @@ const waveshapes = {
    return phase / skew;
  },
  sine(phase) {
-    return Math.sin(TWO_PI * phase) * 0.5 + 0.5;
+    return Math.sin(Math.PI * 2 * phase) * 0.5 + 0.5;
  },
  ramp(phase) {
    return phase;
@@ -106,6 +100,12 @@ const waveshapes = {
    return v - polyBlep(phase, dt);
  },
 };
+function getParamValue(block, param) {
+  if (param.length > 1) {
+    return param[block];
+  }
+  return param[0];
+}

 const waveShapeNames = Object.keys(waveshapes);
 class LFOProcessor extends AudioWorkletProcessor {
@@ -165,9 +165,9 @@ class LFOProcessor extends AudioWorkletProcessor {
    const blockSize = output[0].length ?? 0;

    if (this.phase == null) {
-      this.phase = ffrac(time * frequency + phaseoffset);
+      this.phase = mod(time * frequency + phaseoffset, 1);
    }
-    const dt = frequency * INVSR;
+    const dt = frequency / sampleRate;
    for (let n = 0; n < blockSize; n++) {
      for (let i = 0; i < output.length; i++) {
        let modval = (waveshapes[shape](this.phase, skew) + dcoffset) * depth;
@@ -293,8 +293,8 @@ class TwoPoleFilter {
    // Out of bound values can produce NaNs
    resonance = clamp(resonance, 0, 1);
    cutoff = clamp(cutoff, 0, sampleRate / 2 - 1);
-    const c = clamp(2 * Math.sin(cutoff * PI * INVSR), 0, 1.14);
-    const r = Math.pow(0.5, 8 * resonance + 1);
+    const c = clamp(2 * Math.sin(cutoff * (_PI / sampleRate)), 0, 1.14);
+    const r = Math.pow(0.5, (resonance + 0.125) / 0.125);
    const mrc = 1 - r * c;
    this.s0 = mrc * this.s0 - c * this.s1 + c * s; // bpf
    this.s1 = mrc * this.s1 + c * this.s0; // lpf
@@ -353,6 +353,11 @@ class DJFProcessor extends AudioWorkletProcessor {
 }
 registerProcessor('djf-processor', DJFProcessor);

+function fast_tanh(x) {
+  const x2 = x * x;
+  return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
+}
+const _PI = 3.14159265359;
 //adapted from https://github.com/TheBouteillacBear/webaudioworklet-wasm?tab=MIT-1-ov-file
 class LadderProcessor extends AudioWorkletProcessor {
  static get parameterDescriptors() {
@@ -390,7 +395,7 @@ class LadderProcessor extends AudioWorkletProcessor {
    const drive = clamp(Math.exp(parameters.drive[0]), 0.1, 2000);

    let cutoff = parameters.frequency[0];
-    cutoff = cutoff * TWO_PI * INVSR;
+    cutoff = (cutoff * 2 * _PI) / sampleRate;
    cutoff = cutoff > 1 ? 1 : cutoff;

    const k = Math.min(8, resonance * 0.13);
@@ -503,7 +508,6 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        name: 'voices',
        defaultValue: 5,
        min: 1,
-        automationRate: 'k-rate',
      },
    ];
  }
@@ -515,36 +519,40 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
      // this.port.postMessage({ type: 'onended' });
      return false;
    }
+
    const output = outputs[0];
-    const voices = params.voices[0]; // k-rate
+
    for (let i = 0; i < output[0].length; i++) {
      const detune = pv(params.detune, i);
+      const voices = pv(params.voices, i);
      const freqspread = pv(params.freqspread, i);
      const panspread = pv(params.panspread, i) * 0.5 + 0.5;
-      let gainL = Math.sqrt(1 - panspread);
-      let gainR = Math.sqrt(panspread);
+      const gain1 = Math.sqrt(1 - panspread);
+      const gain2 = Math.sqrt(panspread);
      let freq = pv(params.frequency, i);
      // Main detuning
      freq = applySemitoneDetuneToFrequency(freq, detune / 100);
-      const detuner = getDetuner(voices, freqspread);
      for (let n = 0; n < voices; n++) {
+        const isOdd = (n & 1) == 1;
+        let gainL = gain1;
+        let gainR = gain2;
+        // invert right and left gain
+        if (isOdd) {
+          gainL = gain2;
+          gainR = gain1;
+        }
        // Individual voice detuning
-        const freqVoice = applySemitoneDetuneToFrequency(freq, detuner(n));
+        const freqVoice = applySemitoneDetuneToFrequency(freq, getUnisonDetune(voices, freqspread, n));
        // We must wrap this here because it is passed into sawblep below which
        // has domain [0, 1]
-        const dt = ffrac(freqVoice * INVSR);
+        const dt = mod(freqVoice / sampleRate, 1);
        this.phase[n] = this.phase[n] ?? Math.random();
        const v = waveshapes.sawblep(this.phase[n], dt);

-        output[0][i] += v * gainL;
-        output[1][i] += v * gainR;
+        output[0][i] = output[0][i] + v * gainL;
+        output[1][i] = output[1][i] + v * gainR;

-        let pn = this.phase[n] + dt;
-        if (pn >= 1.0) pn -= 1.0;
-        this.phase[n] = pn;
-        // invert right and left gain
-        gainL = gainR;
-        gainR = gainL;
+        this.phase[n] = wrapPhase(this.phase[n] + dt);
      }
    }
    return true;
@@ -556,16 +564,12 @@ registerProcessor('supersaw-oscillator', SuperSawOscillatorProcessor);
 // Phase Vocoder sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
 const BUFFERED_BLOCK_SIZE = 2048;

-const hannCache = new Map();
 function genHannWindow(length) {
-  if (!hannCache.has(length)) {
-    const win = new Float32Array(length);
-    for (let i = 0; i < length; i++) {
-      win[i] = 0.5 * (1 - Math.cos((TWO_PI * i) / length));
-    }
-    hannCache.set(length, win);
+  let win = new Float32Array(length);
+  for (var i = 0; i < length; i++) {
+    win[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / length));
  }
-  return hannCache.get(length);
+  return win;
 }

 class PhaseVocoderProcessor extends OLAProcessor {
@@ -583,10 +587,11 @@ class PhaseVocoderProcessor extends OLAProcessor {
      blockSize: BUFFERED_BLOCK_SIZE,
    };
    super(options);
-    this.timeCursor = 0;
+
    this.fftSize = this.blockSize;
-    this.invfftSize = 1 / this.fftSize;
-    this.hannWindow = genHannWindow(this.fftSize);
+    this.timeCursor = 0;
+
+    this.hannWindow = genHannWindow(this.blockSize);
    // prepare FFT and pre-allocate buffers
    this.fft = new FFT(this.fftSize);
    this.freqComplexBuffer = this.fft.createComplexArray();
@@ -599,43 +604,52 @@ class PhaseVocoderProcessor extends OLAProcessor {

  processOLA(inputs, outputs, parameters) {
    // no automation, take last value
+
    let pitchFactor = parameters.pitchFactor[parameters.pitchFactor.length - 1];
+
    if (pitchFactor < 0) {
      pitchFactor = pitchFactor * 0.25;
    }
    pitchFactor = Math.max(0, pitchFactor + 1);
-    for (let i = 0; i < this.nbInputs; i++) {
-      for (let j = 0; j < inputs[i].length; j++) {
-        const input = inputs[i][j];
-        const output = outputs[i][j];
+
+    for (var i = 0; i < this.nbInputs; i++) {
+      for (var j = 0; j < inputs[i].length; j++) {
+        // big assumption here: output is symetric to input
+        var input = inputs[i][j];
+        var output = outputs[i][j];
+
        this.applyHannWindow(input);
+
        this.fft.realTransform(this.freqComplexBuffer, input);
+
        this.computeMagnitudes();
        this.findPeaks();
        this.shiftPeaks(pitchFactor);
+
        this.fft.completeSpectrum(this.freqComplexBufferShifted);
        this.fft.inverseTransform(this.timeComplexBuffer, this.freqComplexBufferShifted);
        this.fft.fromComplexArray(this.timeComplexBuffer, output);
        this.applyHannWindow(output);
      }
    }
+
    this.timeCursor += this.hopSize;
  }

  /** Apply Hann window in-place */
  applyHannWindow(input) {
-    for (let i = 0; i < this.blockSize; i++) {
-      input[i] *= this.hannWindow[i] * 1.62;
+    for (var i = 0; i < this.blockSize; i++) {
+      input[i] = input[i] * this.hannWindow[i] * 1.62;
    }
  }

  /** Compute squared magnitudes for peak finding **/
  computeMagnitudes() {
-    let i = 0,
+    var i = 0,
      j = 0;
    while (i < this.magnitudes.length) {
-      const real = this.freqComplexBuffer[j];
-      const imag = this.freqComplexBuffer[j + 1];
+      let real = this.freqComplexBuffer[j];
+      let imag = this.freqComplexBuffer[j + 1];
      // no need to sqrt for peak finding
      this.magnitudes[i] = real ** 2 + imag ** 2;
      i += 1;
@@ -646,10 +660,12 @@ class PhaseVocoderProcessor extends OLAProcessor {
  /** Find peaks in spectrum magnitudes **/
  findPeaks() {
    this.nbPeaks = 0;
-    let i = 2;
-    const end = this.magnitudes.length - 2;
+    var i = 2;
+    let end = this.magnitudes.length - 2;
+
    while (i < end) {
-      const mag = this.magnitudes[i];
+      let mag = this.magnitudes[i];
+
      if (this.magnitudes[i - 1] >= mag || this.magnitudes[i - 2] >= mag) {
        i++;
        continue;
@@ -658,6 +674,7 @@ class PhaseVocoderProcessor extends OLAProcessor {
        i++;
        continue;
      }
+
      this.peakIndexes[this.nbPeaks] = i;
      this.nbPeaks++;
      i += 2;
@@ -668,44 +685,53 @@ class PhaseVocoderProcessor extends OLAProcessor {
  shiftPeaks(pitchFactor) {
    // zero-fill new spectrum
    this.freqComplexBufferShifted.fill(0);
-    for (let i = 0; i < this.nbPeaks; i++) {
-      const peakIndex = this.peakIndexes[i];
-      const peakIndexShifted = fround(peakIndex * pitchFactor);
+
+    for (var i = 0; i < this.nbPeaks; i++) {
+      let peakIndex = this.peakIndexes[i];
+      let peakIndexShifted = Math.round(peakIndex * pitchFactor);
+
      if (peakIndexShifted > this.magnitudes.length) {
        break;
      }
+
      // find region of influence
-      let startIndex = 0;
-      let endIndex = this.fftSize;
+      var startIndex = 0;
+      var endIndex = this.fftSize;
      if (i > 0) {
-        startIndex = peakIndex - fround((peakIndex - this.peakIndexes[i - 1]) / 2);
+        let peakIndexBefore = this.peakIndexes[i - 1];
+        startIndex = peakIndex - Math.floor((peakIndex - peakIndexBefore) / 2);
      }
      if (i < this.nbPeaks - 1) {
-        endIndex = peakIndex + fceil((this.peakIndexes[i + 1] - peakIndex) / 2);
+        let peakIndexAfter = this.peakIndexes[i + 1];
+        endIndex = peakIndex + Math.ceil((peakIndexAfter - peakIndex) / 2);
      }
+
      // shift whole region of influence around peak to shifted peak
-      const startOffset = startIndex - peakIndex;
-      const endOffset = endIndex - peakIndex;
-      const omegaDelta = TWO_PI * this.invfftSize * (peakIndexShifted - peakIndex);
-      const phaseShiftReal = Math.cos(omegaDelta * this.timeCursor);
-      const phaseShiftImag = Math.sin(omegaDelta * this.timeCursor);
-      for (let j = startOffset; j < endOffset; j++) {
-        const binIndex = peakIndex + j;
-        const binIndexShifted = peakIndexShifted + j;
+      let startOffset = startIndex - peakIndex;
+      let endOffset = endIndex - peakIndex;
+      for (var j = startOffset; j < endOffset; j++) {
+        let binIndex = peakIndex + j;
+        let binIndexShifted = peakIndexShifted + j;
+
        if (binIndexShifted >= this.magnitudes.length) {
          break;
        }
+
        // apply phase correction
-        const indexReal = 2 * binIndex;
-        const indexImag = indexReal + 1;
-        const valueReal = this.freqComplexBuffer[indexReal];
-        const valueImag = this.freqComplexBuffer[indexImag];
+        let omegaDelta = (2 * Math.PI * (binIndexShifted - binIndex)) / this.fftSize;
+        let phaseShiftReal = Math.cos(omegaDelta * this.timeCursor);
+        let phaseShiftImag = Math.sin(omegaDelta * this.timeCursor);

-        const valueShiftedReal = valueReal * phaseShiftReal - valueImag * phaseShiftImag;
-        const valueShiftedImag = valueReal * phaseShiftImag + valueImag * phaseShiftReal;
+        let indexReal = binIndex * 2;
+        let indexImag = indexReal + 1;
+        let valueReal = this.freqComplexBuffer[indexReal];
+        let valueImag = this.freqComplexBuffer[indexImag];

-        const indexShiftedReal = 2 * binIndexShifted;
-        const indexShiftedImag = indexShiftedReal + 1;
+        let valueShiftedReal = valueReal * phaseShiftReal - valueImag * phaseShiftImag;
+        let valueShiftedImag = valueReal * phaseShiftImag + valueImag * phaseShiftReal;
+
+        let indexShiftedReal = binIndexShifted * 2;
+        let indexShiftedImag = indexShiftedReal + 1;
        this.freqComplexBufferShifted[indexShiftedReal] += valueShiftedReal;
        this.freqComplexBufferShifted[indexShiftedImag] += valueShiftedImag;
      }
@@ -719,10 +745,11 @@ registerProcessor('phase-vocoder-processor', PhaseVocoderProcessor);
 class PulseOscillatorProcessor extends AudioWorkletProcessor {
  constructor() {
    super();
-    this.phi = -PI; // phase
+    this.pi = _PI;
+    this.phi = -this.pi; // phase
    this.Y0 = 0; // feedback memories
    this.Y1 = 0;
-    this.PW = PI; // pulse width
+    this.PW = this.pi; // pulse width
    this.B = 2.3; // feedback coefficient
    this.dphif = 0; // filtered phase increment
    this.envf = 0; // filtered envelope
@@ -779,11 +806,11 @@ class PulseOscillatorProcessor extends AudioWorkletProcessor {
      dphi;

    for (let i = 0; i < (output[0].length ?? 0); i++) {
-      const pw = (1 - clamp(pv(params.pulsewidth, i), -0.99, 0.99)) * PI;
-      const detune = pv(params.detune, i);
-      const freq = applySemitoneDetuneToFrequency(pv(params.frequency, i), detune / 100);
+      const pw = (1 - clamp(getParamValue(i, params.pulsewidth), -0.99, 0.99)) * this.pi;
+      const detune = getParamValue(i, params.detune);
+      const freq = applySemitoneDetuneToFrequency(getParamValue(i, params.frequency), detune / 100);

-      dphi = freq * TWO_PI * INVSR; // phase increment
+      dphi = freq * (this.pi / (sampleRate * 0.5)); // phase increment
      this.dphif += 0.1 * (dphi - this.dphif);

      env *= 0.9998; // exponential decay envelope
@@ -795,7 +822,7 @@ class PulseOscillatorProcessor extends AudioWorkletProcessor {

      // Waveform generation (half-Tomisawa oscillators)
      this.phi += this.dphif; // phase increment
-      if (this.phi >= PI) this.phi -= TWO_PI; // phase wrapping
+      if (this.phi >= this.pi) this.phi -= 2 * this.pi; // phase wrapping

      // First half-Tomisawa generator
      let out0 = Math.cos(this.phi + this.B * this.Y0); // self-phase modulation
@@ -825,23 +852,24 @@ const chyx = {
  /*bit reverse*/ br: function (x, size = 8) {
    if (size > 32) {
      throw new Error('br() Size cannot be greater than 32');
+    } else {
+      let result = 0;
+      for (let idx = 0; idx < size - 0; idx++) {
+        result += chyx.bitC(x, 2 ** idx, 2 ** (size - (idx + 1)));
+      }
+      return result;
    }
-    let result = 0;
-    for (let idx = 0; idx < size; idx++) {
-      result |= chyx.bitC(x, 1 << idx, 1 << (size - (idx + 1)));
-    }
-    return result;
  },
  /*sin that loops every 128 "steps", instead of every pi steps*/ sinf: function (x) {
-    return Math.sin((x * PI) / 128);
+    return Math.sin(x / (128 / Math.PI));
  },
  /*cos that loops every 128 "steps", instead of every pi steps*/ cosf: function (x) {
-    return Math.cos((x * PI) / 128);
+    return Math.cos(x / (128 / Math.PI));
  },
  /*tan that loops every 128 "steps", instead of every pi steps*/ tanf: function (x) {
-    return Math.tan((x * PI) / 128);
+    return Math.tan(x / (128 / Math.PI));
  },
-  /*converts t into a string composed of its bits; regexes that*/ regG: function (t, X) {
+  /*converts t into a string composed of it's bits, regex's that*/ regG: function (t, X) {
    return X.test(t.toString(2));
  },
 };
@@ -849,7 +877,7 @@ const chyx = {
 // Create shortened Math functions
 let mathParams, byteBeatHelperFuncs;
 function getByteBeatFunc(codetext) {
-  if (mathParams == null) {
+  if ((mathParams || byteBeatHelperFuncs) == null) {
    mathParams = Object.getOwnPropertyNames(Math);
    byteBeatHelperFuncs = mathParams.map((k) => Math[k]);
    const chyxNames = Object.getOwnPropertyNames(chyx);
@@ -882,7 +910,7 @@ class ByteBeatProcessor extends AudioWorkletProcessor {

      this.func = getByteBeatFunc(codeText);
    };
-    this.initialOffset = 0;
+    this.initialOffset = null;
    this.t = null;
    this.func = null;
  }
@@ -929,19 +957,18 @@ class ByteBeatProcessor extends AudioWorkletProcessor {
      this.t = params.begin[0] * sampleRate;
    }
    const output = outputs[0];
-    const scale = 256 * INVSR;
    for (let i = 0; i < output[0].length; i++) {
-      const detune = pv(params.detune, i);
-      const freq = applySemitoneDetuneToFrequency(pv(params.frequency, i), detune / 100);
-      const local_t = scale * freq * this.t + this.initialOffset;
+      const detune = getParamValue(i, params.detune);
+      const freq = applySemitoneDetuneToFrequency(getParamValue(i, params.frequency), detune / 100);
+      let local_t = (this.t / (sampleRate / 256)) * freq + this.initialOffset;
      const funcValue = this.func(local_t);
-      const signal = (funcValue & 255) / 127.5 - 1;
-      //prevent speaker blowout via clipping if threshold exceeds
-      const out = clamp(signal * 0.2, -0.4, 0.4);
+      let signal = (funcValue & 255) / 127.5 - 1;
+      const out = signal * 0.2;
      for (let c = 0; c < output.length; c++) {
-        output[c][i] = out;
+        //prevent speaker blowout via clipping if threshold exceeds
+        output[c][i] = clamp(out, -0.4, 0.4);
      }
-      this.t++;
+      this.t = this.t + 1;
    }

    return true; // keep the audio processing going
@@ -1029,7 +1056,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      { name: 'position', defaultValue: 0, min: 0, max: 1 },
      { name: 'warp', defaultValue: 0, min: 0, max: 1 },
      { name: 'warpMode', defaultValue: 0 },
-      { name: 'voices', defaultValue: 1, min: 1, automationRate: 'k-rate' },
+      { name: 'voices', defaultValue: 1, min: 1 },
      { name: 'panspread', defaultValue: 0.7, min: 0, max: 1 },
      { name: 'phaserand', defaultValue: 0, min: 0, max: 1 },
    ];
@@ -1040,6 +1067,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
    this.frameLen = 0;
    this.numFrames = 0;
    this.phase = [];
+    this.invSR = 1 / sampleRate;

    this.port.onmessage = (e) => {
      const { type, payload } = e.data || {};
@@ -1076,7 +1104,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {

  _toBits(amt, min = 2, max = 12) {
    const b = max + (min - max) * amt;
-    return { b, n: fround(Math.pow(2, b)) };
+    return { b, n: Math.round(Math.pow(2, b)) };
  }

  _warpPhase(phase, amt, mode) {
@@ -1102,7 +1130,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        return amt < 0.5 ? this._warpPhase(phase, 1 - 2 * amt, 3) : this._warpPhase(phase, 2 * amt - 1, 2);
      }
      case WarpMode.SYNC: {
-        const syncRatio = Math.pow(16, amt ** 2);
+        const syncRatio = Math.pow(16, amt * amt);
        return (phase * syncRatio) % 1;
      }
      case WarpMode.QUANT: {
@@ -1111,8 +1139,8 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      }
      case WarpMode.FOLD: {
        const K = 7;
-        const k = 1 + Math.max(1, fround(K * amt));
-        return Math.abs(ffrac(k * phase) - 0.5) * 2;
+        const k = 1 + Math.max(1, Math.round(K * amt));
+        return Math.abs(frac(k * phase) - 0.5) * 2;
      }
      case WarpMode.PWM: {
        const w = clamp(0.5 + 0.49 * (2 * amt - 1), 0, 1);
@@ -1122,12 +1150,12 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      case WarpMode.ORBIT: {
        const depth = 0.5 * amt;
        const n = 3;
-        return frac(phase + depth * Math.sin(TWO_PI * n * phase));
+        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
      }
      case WarpMode.SPIN: {
        const depth = 0.5 * amt;
        const { n } = this._toBits(amt, 1, 6);
-        return frac(phase + depth * Math.sin(TWO_PI * n * phase));
+        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
      }
      case WarpMode.CHAOS: {
        const r = 3.7 + 0.3 * amt;
@@ -1138,7 +1166,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        const isPrime = (n) => {
          if (n < 2) return false;
          if (n % 2 === 0) return n === 2;
-          for (let d = 3; d ** 2 <= n; d += 2) if (n % d === 0) return false;
+          for (let d = 3; d * d <= n; d += 2) if (n % d === 0) return false;
          return true;
        };
        let { n } = this._toBits(amt, 3);
@@ -1147,12 +1175,18 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      }
      case WarpMode.BINARY: {
        let { b } = this._toBits(amt, 3);
-        b = fround(b);
+        b = Math.round(b);
        const n = 1 << b;
        const idx = ffloor(phase * n);
        const ridx = bitReverse(idx, b);
        return ridx / n;
      }
+      case WarpMode.MODULAR: {
+        const { n } = this._toBits(amt);
+        const depth = 0.5 * amt;
+        const jump = frac(phase * n) / n;
+        return frac(phase + depth * jump);
+      }
      case WarpMode.BROWNIAN: {
        const disp = 0.25 * amt * brownian(64 * phase, 4);
        return frac(phase + disp);
@@ -1175,7 +1209,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      case WarpMode.LOGISTIC: {
        let x = phase;
        const r = 3.6 + 0.4 * amt;
-        const iters = 1 + fround(2 * amt);
+        const iters = 1 + Math.round(2 * amt);
        for (let i = 0; i < iters; i++) x = r * x * (1 - x);
        return clamp(x, 0, 1);
      }
@@ -1188,7 +1222,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        return (y - y0) / (y1 - y0);
      }
      case WarpMode.FRACTAL: {
-        const d = 0.5 * Math.sin(TWO_PI * phase) * amt;
+        const d = 0.5 * Math.sin(2 * Math.PI * phase) * amt;
        return frac(phase + d);
      }
      case WarpMode.FLIP: {
@@ -1235,7 +1269,6 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      if (outR !== outL) outR.set(outL);
      return true;
    }
-    const voices = parameters.voices[0]; // k-rate
    for (let i = 0; i < outL.length; i++) {
      const detune = pv(parameters.detune, i);
      const freqspread = pv(parameters.freqspread, i);
@@ -1245,6 +1278,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      const frac = idx - fIdx;
      const warpAmount = clamp(pv(parameters.warp, i), 0, 1);
      const warpMode = pv(parameters.warpMode, i);
+      const voices = pv(parameters.voices, i);
      const phaseRand = clamp(pv(parameters.phaserand, i), 0, 1);
      const panspread = voices > 1 ? clamp(pv(parameters.panspread, i), 0, 1) : 0;
      const gain1 = Math.sqrt(0.5 - 0.5 * panspread);
@@ -1252,7 +1286,6 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      let f = pv(parameters.frequency, i);
      f = applySemitoneDetuneToFrequency(f, detune / 100); // overall detune
      const normalizer = 1 / Math.sqrt(voices);
-      const detuner = getDetuner(voices, freqspread);
      for (let n = 0; n < voices; n++) {
        const isOdd = (n & 1) == 1;
        let gainL = gain1;
@@ -1262,8 +1295,8 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
          gainL = gain2;
          gainR = gain1;
        }
-        const fVoice = applySemitoneDetuneToFrequency(f, detuner(n)); // voice detune
-        const dPhase = fVoice * INVSR;
+        const fVoice = applySemitoneDetuneToFrequency(f, getUnisonDetune(voices, freqspread, n)); // voice detune
+        const dPhase = fVoice * this.invSR;
        const level = this._chooseMip(dPhase);
        const table = this.tables[level];

@@ -1278,7 +1311,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        }
        outL[i] += s * gainL * normalizer;
        outR[i] += s * gainR * normalizer;
-        this.phase[n] = ffrac(this.phase[n] + dPhase);
+        this.phase[n] = wrapPhase(this.phase[n] + dPhase);
      }
    }
    return true;
@@ -1,12 +1,11 @@
 // this is dough, the superdough without dependencies
-// @ts-nocheck
+// @ts-check
 // @ts-ignore ignore next line because sampleRate is unknown
 const SAMPLE_RATE = typeof sampleRate !== 'undefined' ? sampleRate : 48000;
 const PI_DIV_SR = Math.PI / SAMPLE_RATE;
 const ISR = 1 / SAMPLE_RATE;

 let gainCurveFunc = (val) => Math.pow(val, 2);
-const clamp = (num, min, max) => Math.min(Math.max(num, min), max);

 function applyGainCurve(val) {
  return gainCurveFunc(val);
@@ -152,8 +151,7 @@ export class TwoPoleFilter {
    resonance = Math.max(resonance, 0);

    cutoff = Math.min(cutoff, 20000);
-    let c = 2 * Math.sin(cutoff * PI_DIV_SR);
-    c = clamp(c, 0, 1.14); // this line prevents instability TODO: test
+    const c = 2 * Math.sin(cutoff * PI_DIV_SR);

    const r = Math.pow(0.5, (resonance + 0.125) / 0.125);
    const mrc = 1 - r * c;
@@ -13,7 +13,7 @@
  },
  "repository": {
    "type": "git",
-    "url": "git+https://codeberg.org/uzu/strudel.git"
+    "url": "git+https://github.com/tidalcycles/strudel.git"
  },
  "keywords": [
    "tidalcycles",
@@ -25,15 +25,12 @@
  "author": "Felix Roos <flix91@gmail.com>",
  "license": "AGPL-3.0-or-later",
  "bugs": {
-    "url": "https://codeberg.org/uzu/strudel/issues"
+    "url": "https://github.com/tidalcycles/strudel/issues"
  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme",
+  "homepage": "https://github.com/tidalcycles/strudel#readme",
  "devDependencies": {
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*",
    "wav-encoder": "^1.3.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -1,16 +0,0 @@
-import { defineConfig } from 'vite';
-import { resolve } from 'path';
-import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';
-
-// https://vitejs.dev/config/
-export default defineConfig({
-  plugins: [bundleAudioWorkletPlugin()],
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'index.mjs'),
-      formats: ['es'],
-      fileName: (ext) => ({ es: 'index.mjs' })[ext],
-    },
-    target: 'esnext',
-  },
-});
@@ -25,8 +25,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -38,8 +38,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -229,9 +229,6 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
 *
 * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by semicolon (':') and then a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
 *
- * The scale name must be written without spaces (because it would be interpreted as a multi-step pattern otherwise).
- * If your scale name includes spaces, replace them with colons.
- *
 * The root note defaults to octave 3, if no octave number is given.
 *
 * @name scale
@@ -253,8 +250,6 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
 * .s("piano")
 * @example
 * note("C1*16").transpose(irand(36)).scale('Cb2 major').scaleTranspose(3)
- * @example
- * n("[0 0] [1 2] [3 4] [5 6]").scale("C:major:blues")
 */
 export const scale = register(
  'scale',
@@ -39,8 +39,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -12,8 +12,5 @@
  "type": "module",
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -62,7 +62,7 @@ initStrudel();
 document.getElementById('play').addEventListener('click', 
  () => evaluate('note("c a f e").jux(rev)')
 );
-document.getElementById('stop').addEventListener('click', 
+document.getElementById('play').addEventListener('stop', 
  () => hush()
 );
 ```
@@ -43,8 +43,5 @@
    "@rollup/plugin-replace": "^6.0.2",
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -40,8 +40,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -35,8 +35,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -41,6 +41,7 @@ Tune.prototype.tonicize = function(newTonic) {
 	this.tonic = newTonic
 }

+
 /* Return data in the mode you are in (freq, ratio, or midi) */

 Tune.prototype.note = function(input,octave){
@@ -840,31 +840,6 @@ exports[`runs examples > example "amp" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "anchor" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | note:E2 ]",
-  "[ 0/1 → 1/1 | note:C3 ]",
-  "[ 0/1 → 1/1 | note:E3 ]",
-  "[ 0/1 → 1/1 | note:G3 ]",
-  "[ 0/1 → 1/1 | note:C4 ]",
-  "[ 1/1 → 2/1 | note:C3 ]",
-  "[ 1/1 → 2/1 | note:G3 ]",
-  "[ 1/1 → 2/1 | note:C4 ]",
-  "[ 1/1 → 2/1 | note:E4 ]",
-  "[ 1/1 → 2/1 | note:G4 ]",
-  "[ 2/1 → 3/1 | note:E3 ]",
-  "[ 2/1 → 3/1 | note:C4 ]",
-  "[ 2/1 → 3/1 | note:E4 ]",
-  "[ 2/1 → 3/1 | note:G4 ]",
-  "[ 2/1 → 3/1 | note:C5 ]",
-  "[ 3/1 → 4/1 | note:C4 ]",
-  "[ 3/1 → 4/1 | note:G4 ]",
-  "[ 3/1 → 4/1 | note:C5 ]",
-  "[ 3/1 → 4/1 | note:E5 ]",
-  "[ 3/1 → 4/1 | note:G5 ]",
-]
-`;
-
 exports[`runs examples > example "apply" example index 0 1`] = `
 [
  "[ 0/1 → 1/1 | note:C3 ]",
@@ -1872,31 +1847,6 @@ exports[`runs examples > example "chop" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "chord" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | note:A3 ]",
-  "[ 0/1 → 1/1 | note:C4 ]",
-  "[ 0/1 → 1/1 | note:E4 ]",
-  "[ 0/1 → 1/1 | note:A4 ]",
-  "[ 0/1 → 1/1 | note:C5 ]",
-  "[ 1/1 → 2/1 | note:E3 ]",
-  "[ 1/1 → 2/1 | note:C4 ]",
-  "[ 1/1 → 2/1 | note:E4 ]",
-  "[ 1/1 → 2/1 | note:G4 ]",
-  "[ 1/1 → 2/1 | note:C5 ]",
-  "[ 2/1 → 3/1 | note:D3 ]",
-  "[ 2/1 → 3/1 | note:A3 ]",
-  "[ 2/1 → 3/1 | note:D4 ]",
-  "[ 2/1 → 3/1 | note:Gb4 ]",
-  "[ 2/1 → 3/1 | note:A4 ]",
-  "[ 3/1 → 4/1 | note:F3 ]",
-  "[ 3/1 → 4/1 | note:C4 ]",
-  "[ 3/1 → 4/1 | note:F4 ]",
-  "[ 3/1 → 4/1 | note:A4 ]",
-  "[ 3/1 → 4/1 | note:C5 ]",
-]
-`;
-
 exports[`runs examples > example "chorus" example index 0 1`] = `
 [
  "[ 0/1 → 1/4 | note:d s:sawtooth chorus:0.5 ]",
@@ -2789,23 +2739,6 @@ exports[`runs examples > example "detune" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "dictionary" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | note:A3 room:0.5 ]",
-  "[ 0/1 → 1/1 | note:C4 room:0.5 ]",
-  "[ 0/1 → 1/1 | note:E4 room:0.5 ]",
-  "[ 1/1 → 2/1 | note:G3 room:0.5 ]",
-  "[ 1/1 → 2/1 | note:C4 room:0.5 ]",
-  "[ 1/1 → 2/1 | note:E4 room:0.5 ]",
-  "[ 2/1 → 3/1 | note:A3 room:0.5 ]",
-  "[ 2/1 → 3/1 | note:D4 room:0.5 ]",
-  "[ 2/1 → 3/1 | note:Gb4 room:0.5 ]",
-  "[ 3/1 → 4/1 | note:A3 room:0.5 ]",
-  "[ 3/1 → 4/1 | note:C4 room:0.5 ]",
-  "[ 3/1 → 4/1 | note:F4 room:0.5 ]",
-]
-`;
-
 exports[`runs examples > example "distort" example index 0 1`] = `
 [
  "[ 0/1 → 1/8 | s:hh distort:0 ]",
@@ -6563,28 +6496,6 @@ exports[`runs examples > example "miditouch" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "mode" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | note:E3 ]",
-  "[ 0/1 → 1/1 | note:C4 ]",
-  "[ 0/1 → 1/1 | note:E4 ]",
-  "[ 0/1 → 1/1 | note:G4 ]",
-  "[ 0/1 → 1/1 | note:C5 ]",
-  "[ 1/1 → 2/1 | note:C5 ]",
-  "[ 1/1 → 2/1 | note:G5 ]",
-  "[ 1/1 → 2/1 | note:C6 ]",
-  "[ 1/1 → 2/1 | note:E6 ]",
-  "[ 2/1 → 3/1 | note:E3 ]",
-  "[ 2/1 → 3/1 | note:C4 ]",
-  "[ 2/1 → 3/1 | note:E4 ]",
-  "[ 2/1 → 3/1 | note:G4 ]",
-  "[ 3/1 → 4/1 | note:C5 ]",
-  "[ 3/1 → 4/1 | note:G5 ]",
-  "[ 3/1 → 4/1 | note:C6 ]",
-  "[ 3/1 → 4/1 | note:E6 ]",
-]
-`;
-
 exports[`runs examples > example "morph" example index 0 1`] = `
 [
  "[ 0/1 → 1/8 | s:hh ]",
@@ -6903,31 +6814,6 @@ exports[`runs examples > example "octave" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "octaves" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | note:A3 ]",
-  "[ 0/1 → 1/1 | note:C4 ]",
-  "[ 0/1 → 1/1 | note:E4 ]",
-  "[ 0/1 → 1/1 | note:A4 ]",
-  "[ 0/1 → 1/1 | note:C5 ]",
-  "[ 1/1 → 2/1 | note:E3 ]",
-  "[ 1/1 → 2/1 | note:C4 ]",
-  "[ 1/1 → 2/1 | note:E4 ]",
-  "[ 1/1 → 2/1 | note:G4 ]",
-  "[ 1/1 → 2/1 | note:C5 ]",
-  "[ 2/1 → 3/1 | note:D3 ]",
-  "[ 2/1 → 3/1 | note:A3 ]",
-  "[ 2/1 → 3/1 | note:D4 ]",
-  "[ 2/1 → 3/1 | note:Gb4 ]",
-  "[ 2/1 → 3/1 | note:A4 ]",
-  "[ 3/1 → 4/1 | note:F3 ]",
-  "[ 3/1 → 4/1 | note:C4 ]",
-  "[ 3/1 → 4/1 | note:F4 ]",
-  "[ 3/1 → 4/1 | note:A4 ]",
-  "[ 3/1 → 4/1 | note:C5 ]",
-]
-`;
-
 exports[`runs examples > example "off" example index 0 1`] = `
 [
  "[ -5/24 ⇜ (0/1 → 1/8) | note:62 ]",
@@ -6961,15 +6847,6 @@ exports[`runs examples > example "off" example index 0 1`] = `
 ]
 `;

-exports[`runs examples > example "offset" example index 0 1`] = `
-[
-  "[ 0/1 → 1/1 | chord:Am offset:0 ]",
-  "[ 1/1 → 2/1 | chord:C offset:1 ]",
-  "[ 2/1 → 3/1 | chord:D offset:2 ]",
-  "[ 3/1 → 4/1 | chord:F offset:3 ]",
-]
-`;
-
 exports[`runs examples > example "often" example index 0 1`] = `
 [
  "[ 0/1 → 1/8 | s:hh speed:0.5 ]",
@@ -9337,43 +9214,6 @@ exports[`runs examples > example "scale" example index 4 1`] = `
 ]
 `;

-exports[`runs examples > example "scale" example index 5 1`] = `
-[
-  "[ 0/1 → 1/8 | note:C3 ]",
-  "[ 1/8 → 1/4 | note:C3 ]",
-  "[ 1/4 → 3/8 | note:D3 ]",
-  "[ 3/8 → 1/2 | note:Eb3 ]",
-  "[ 1/2 → 5/8 | note:E3 ]",
-  "[ 5/8 → 3/4 | note:G3 ]",
-  "[ 3/4 → 7/8 | note:A3 ]",
-  "[ 7/8 → 1/1 | note:C4 ]",
-  "[ 1/1 → 9/8 | note:C3 ]",
-  "[ 9/8 → 5/4 | note:C3 ]",
-  "[ 5/4 → 11/8 | note:D3 ]",
-  "[ 11/8 → 3/2 | note:Eb3 ]",
-  "[ 3/2 → 13/8 | note:E3 ]",
-  "[ 13/8 → 7/4 | note:G3 ]",
-  "[ 7/4 → 15/8 | note:A3 ]",
-  "[ 15/8 → 2/1 | note:C4 ]",
-  "[ 2/1 → 17/8 | note:C3 ]",
-  "[ 17/8 → 9/4 | note:C3 ]",
-  "[ 9/4 → 19/8 | note:D3 ]",
-  "[ 19/8 → 5/2 | note:Eb3 ]",
-  "[ 5/2 → 21/8 | note:E3 ]",
-  "[ 21/8 → 11/4 | note:G3 ]",
-  "[ 11/4 → 23/8 | note:A3 ]",
-  "[ 23/8 → 3/1 | note:C4 ]",
-  "[ 3/1 → 25/8 | note:C3 ]",
-  "[ 25/8 → 13/4 | note:C3 ]",
-  "[ 13/4 → 27/8 | note:D3 ]",
-  "[ 27/8 → 7/2 | note:Eb3 ]",
-  "[ 7/2 → 29/8 | note:E3 ]",
-  "[ 29/8 → 15/4 | note:G3 ]",
-  "[ 15/4 → 31/8 | note:A3 ]",
-  "[ 31/8 → 4/1 | note:C4 ]",
-]
-`;
-
 exports[`runs examples > example "scaleTranspose" example index 0 1`] = `
 [
  "[ 0/1 → 1/2 | note:C3 ]",
@@ -4,25 +4,11 @@ import { describe, it } from 'vitest';

 const tuneKeys = Object.keys(tunes);

-// Node 24 tightened Number→string rounding; clamp decimals so snapshots stay stable across engines.
-const roundFloatStrings = (input, precision = 12) => {
-  // if matches a decimal number ex: 12.34, -0.5, 0.123, 99.0, 1.932093850293
-  const regex = /-?\d+\.\d+/g;
-  return input.replace(regex, (match) => {
-    // converts the literal to a number, performs round to nearest (ties to even)
-    // at the requested precision, and returns the rounded decimal string
-    const rounded = Number(match).toFixed(precision);
-    // trims trailing zeros (and a dangling dot) after rounding, so the displayed string looks tidy
-    return rounded.replace(/\.?0+$/, '').replace(/\.$/, '');
-  });
-};
-
 describe('renders tunes', () => {
  tuneKeys.forEach((key) => {
    it(`tune: ${key}`, async ({ expect }) => {
      const haps = await queryCode(tunes[key], testCycles[key] || 1);
-      const normalized = haps.map((hap) => roundFloatStrings(hap));
-      expect(normalized).toMatchSnapshot();
+      expect(haps).toMatchSnapshot();
    });
  });
 });
@@ -1,8 +1,5 @@
 {
  "dependencies": {
    "csv": "^6.3.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -75,8 +75,5 @@
    "sharp": "^0.33.5",
    "workbox-window": "^7.3.0",
    "vite-plugin-bundle-audioworklet": "workspace:*"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -63,7 +63,7 @@ You can also create custom aliases for existing sounds using the `soundAlias` fu

 <MiniRepl
  client:idle
-  tune={`soundAlias('RolandTR808_bd', 'kick')
+  tune={`soundAlias("RolandTR808_bd", "kick")
 s("kick")`}
 />

@@ -32,7 +32,7 @@ There are 3 quick ways to embed strudel in your website:

 ### Inside an iframe

-Using an iframe is the most easy way to embed a strudel tune.
+Using an iframe is the most easy way to embed a studel tune.
 You can embed any pattern of your choice via an iframe and the URL of the pattern of your choice:

 ```html
@@ -133,7 +133,7 @@ If you'd rather use your own UI, you can use the `@strudel/web` package:
 </script>
 ```

-For more info on this package, see the [@strudel/web README](https://codeberg.org/uzu/strudel/src/branch/main/packages/web#strudel-web).
+For more info on this package, see the [@strudel/web README]https://codeberg.org/uzu/strudel/src/branch/main/packages/web#strudel-web).

 ## Via npm

@@ -79,11 +79,13 @@ const updateCodeWindow = (context, patternData, reset = false) => {
  context.handleUpdate(patternData, reset);
 };

+const autoResetPatternOnChange = !isUdels();
+
 function UserPatterns({ context }) {
  const activePattern = useActivePattern();
  const viewingPatternStore = useViewingPatternData();
  const viewingPatternData = parseJSON(viewingPatternStore);
-  const { userPatterns, patternFilter, patternAutoStart } = useSettings();
+  const { userPatterns, patternFilter } = useSettings();
  const viewingPatternID = viewingPatternData?.id;
  return (
    <div className="flex flex-col gap-2 flex-grow overflow-hidden h-full pb-2 ">
@@ -133,13 +135,13 @@ function UserPatterns({ context }) {
      <div className="overflow-auto h-full bg-background p-2 rounded-md">
        {/* {patternFilter === patternFilterName.user && ( */}
        <PatternButtons
-          onClick={(id) => {
-            updateCodeWindow(context, { ...userPatterns[id], collection: userPattern.collection }, patternAutoStart);
-
-            if (context.started && activePattern === id) {
-              context.handleEvaluate();
-            }
-          }}
+          onClick={(id) =>
+            updateCodeWindow(
+              context,
+              { ...userPatterns[id], collection: userPattern.collection },
+              autoResetPatternOnChange,
+            )
+          }
          patterns={userPatterns}
          started={context.started}
          activePattern={activePattern}
@@ -186,14 +188,17 @@ function FeaturedPatterns({ context }) {
  const examplePatterns = useExamplePatterns();
  const collections = examplePatterns.collections;
  const patterns = collections.get(patternFilterName.featured);
-  const { patternAutoStart } = useSettings();
  return (
    <PatternPageWithPagination
      patterns={patterns}
      context={context}
      initialPage={featuredPageNum}
      patternOnClick={(id) => {
-        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.featured }, patternAutoStart);
+        updateCodeWindow(
+          context,
+          { ...patterns[id], collection: patternFilterName.featured },
+          autoResetPatternOnChange,
+        );
      }}
      paginationOnChange={async (pageNum) => {
        await loadAndSetFeaturedPatterns(pageNum - 1);
@@ -208,14 +213,13 @@ function LatestPatterns({ context }) {
  const examplePatterns = useExamplePatterns();
  const collections = examplePatterns.collections;
  const patterns = collections.get(patternFilterName.public);
-  const { patternAutoStart } = useSettings();
  return (
    <PatternPageWithPagination
      patterns={patterns}
      context={context}
      initialPage={latestPageNum}
      patternOnClick={(id) => {
-        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.public }, patternAutoStart);
+        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.public }, autoResetPatternOnChange);
      }}
      paginationOnChange={async (pageNum) => {
        await loadAndSetPublicPatterns(pageNum - 1);
@@ -112,7 +112,6 @@ export function SettingsTab({ started }) {
    multiChannelOrbits,
    isTabIndentationEnabled,
    isMultiCursorEnabled,
-    patternAutoStart,
  } = useSettings();
  const shouldAlwaysSync = isUdels();
  const canChangeAudioDevice = AudioContext.prototype.setSinkId != null;
@@ -305,11 +304,6 @@ export function SettingsTab({ started }) {
          onChange={(cbEvent) => settingsMap.setKey('isCSSAnimationDisabled', cbEvent.target.checked)}
          value={isCSSAnimationDisabled}
        />
-        <Checkbox
-          label="Auto-start pattern on pattern change"
-          onChange={(cbEvent) => settingsMap.setKey('patternAutoStart', cbEvent.target.checked)}
-          value={patternAutoStart}
-        />
      </FormItem>
      <FormItem label="Zen Mode">Try clicking the logo in the top left!</FormItem>
      <FormItem label="Reset Settings">
@@ -62,9 +62,11 @@ export function SoundsTab() {

  // stop current sound on mouseup
  useEvent('mouseup', () => {
-    const ref = trigRef.current;
+    const t = trigRef.current;
    trigRef.current = undefined;
-    ref?.stop?.(getAudioContext().currentTime + 0.01);
+    t?.then((ref) => {
+      ref?.stop(getAudioContext().currentTime + 0.01);
+    });
  });
  return (
    <div id="sounds-tab" className="px-4 flex gap-2 flex-col w-full h-full text-foreground">
@@ -122,19 +124,12 @@ export function SoundsTab() {
                  duration: 0.5,
                };
                soundPreviewIdx++;
+                const time = ctx.currentTime + 0.05;
                const onended = () => trigRef.current?.node?.disconnect();
-                try {
-                  // Pre-load the sample by calling onTrigger with a future time
-                  // This triggers the loading but schedules playback for later
-                  const time = ctx.currentTime + 0.5; // Give 500ms for loading
-                  const ref = await onTrigger(time, params, onended);
-                  trigRef.current = ref;
-                  if (ref?.node) {
-                    connectToDestination(ref.node);
-                  }
-                } catch (err) {
-                  console.warn('Failed to trigger sound:', err);
-                }
+                trigRef.current = Promise.resolve(onTrigger(time, params, onended));
+                trigRef.current.then((ref) => {
+                  connectToDestination(ref?.node);
+                });
              }}
            >
              {' '}
@@ -92,7 +92,11 @@ export function registerSamplesFromDB(config = userSamplesDBConfig, onComplete =

 async function blobToDataUrl(blob) {
  return new Promise((resolve) => {
-    resolve(URL.createObjectURL(blob));
+    var reader = new FileReader();
+    reader.onload = function (event) {
+      resolve(event.target.result);
+    };
+    reader.readAsDataURL(blob);
  });
 }

@@ -96,11 +96,6 @@ export function useSettings() {
    isPanelOpen: parseBoolean(state.isPanelOpen),
    userPatterns: userPatterns,
    multiChannelOrbits: parseBoolean(state.multiChannelOrbits),
-    patternAutoStart: isUdels()
-      ? false
-      : state.patternAutoStart === undefined
-        ? true
-        : parseBoolean(state.patternAutoStart),
  };
 }
Author	SHA1	Message	Date
alex	9dc19fb9bf	Merge branch 'main' into busparts	2025-10-30 21:37:48 +00:00
alex	4a158db9d2	Revert "state twiddles wip" This reverts commit `55839e7ee8`.	2025-10-30 21:28:58 +00:00
alex	55839e7ee8	state twiddles wip	2025-10-26 21:14:11 +00:00
alex	9aaa9bee6b	fixes + tidying	2025-10-24 20:51:12 +01:00
alex	1834d689ef	fixes + tidying	2025-10-24 20:48:35 +01:00
Alex McLean	77a7a148f0	wip	2025-10-23 21:26:27 +01:00
Alex McLean	52931e879d	nearly there	2025-10-23 16:18:47 +01:00
Alex McLean	d5c9be1c30	add _processParts()	2025-10-23 15:14:22 +01:00
Alex McLean	2b30ab3008	Merge branch 'main' of ssh://codeberg.org/uzu/strudel into busparts	2025-10-23 14:59:07 +01:00
Alex McLean	13cbeb3f67	wip	2025-10-23 14:58:57 +01:00
alex	352d8659ec	wip	2025-10-23 14:02:41 +01:00