Merge branch 'main' into nkymut/gamepad-pr

fix custom button mapping error
2026-07-21 20:55:12 -04:00 · 2025-10-28 23:32:28 +01:00 · 2025-10-20 20:42:00 +02:00 · 2025-05-21 01:18:44 +08:00 · 2025-05-21 01:00:58 +08:00 · 2025-05-17 16:10:11 +08:00
89 changed files with 7219 additions and 9215 deletions
@@ -1 +0,0 @@
-22
@@ -1,88 +0,0 @@
-# changelog
-
-NOTE: you can generate this with `node warm.js`. it might still not be perfectly sorted...
-
-## november 2025
-
- 2025-11-27T22:03:53+01:00 [perf] in `noise`, let noiseMix do the disconnect when it exists by jeromew in: [#1783](https://codeberg.org/uzu/strudel/pulls/1783) 
- 2025-11-27T22:01:01+01:00 Bug Fix: Retries for sounds tab by glossing in: [#1754](https://codeberg.org/uzu/strudel/pulls/1754) 
- 2025-11-27T20:36:46+01:00 [hydra] return the hydra object when await initHydra(..) is called by jeromew in: [#1784](https://codeberg.org/uzu/strudel/pulls/1784) 
- 2025-11-27T20:36:14+01:00 Use errorLogger for query and tonal errors by glossing in: [#1782](https://codeberg.org/uzu/strudel/pulls/1782) 
- 2025-11-27T20:27:10+01:00 [perf] level 5 `connect-leak` on `vowel` by jeromew in: [#1779](https://codeberg.org/uzu/strudel/pulls/1779) 
- 2025-11-26T08:23:38+01:00 feat: add prebake script import button for loading .strudel files by daslyfe in: [#1774](https://codeberg.org/uzu/strudel/pulls/1774) 
- 2025-11-26T07:39:28+01:00 Fix Sampler port trampling by Dayglo in: [#1717](https://codeberg.org/uzu/strudel/pulls/1717) 
- 2025-11-25T20:59:09+01:00 Feat: Hook up octave and fix example by glossing in: [#1773](https://codeberg.org/uzu/strudel/pulls/1773) 
- 2025-11-25T20:48:09+01:00 [perf] fix `connect-leak` in `tremolo` param by jeromew in: [#1780](https://codeberg.org/uzu/strudel/pulls/1780) 
- 2025-11-24T17:51:20+01:00 filter modulation improvements! by daslyfe in: [#1769](https://codeberg.org/uzu/strudel/pulls/1769) 
- 2025-11-24T01:20:53+01:00 Add o as a synonym for orbit by daslyfe in: [#1766](https://codeberg.org/uzu/strudel/pulls/1766) 
- 2025-11-23T22:23:26+01:00 [perf] fix `connect-leak` in `fm` modulation by jeromew in: [#1758](https://codeberg.org/uzu/strudel/pulls/1758) 
- 2025-11-23T09:47:24+01:00 Fix interoperability issue between `all` and `await initHydra()` by jeromew in: [#1663](https://codeberg.org/uzu/strudel/pulls/1663) 
- 2025-11-23T04:23:06+01:00 Bug fix: Swap l/r gains with temp variable by glossing in: [#1768](https://codeberg.org/uzu/strudel/pulls/1768) 
- 2025-11-23T00:52:28+01:00 FIX: prevent LFO filter modulation from popping from negative values by daslyfe in: [#1767](https://codeberg.org/uzu/strudel/pulls/1767) 
- 2025-11-21T01:56:11+01:00 Bug Fix: Use frac due to negative frequencies from FM by glossing in: [#1759](https://codeberg.org/uzu/strudel/pulls/1759) 
- 2025-11-20T19:48:16+01:00 [perf] fix `connect-leak` added by #1742 when noise() is not used by jeromew in: [#1757](https://codeberg.org/uzu/strudel/pulls/1757) 
- 2025-11-20T14:51:00+01:00 [perf] fix `connect-leak` in `delay` effect by jeromew in: [#1755](https://codeberg.org/uzu/strudel/pulls/1755) 
- 2025-11-20T14:49:41+01:00 [perf] fix `connect leak` when .noise() is in the mix by jeromew in: [#1742](https://codeberg.org/uzu/strudel/pulls/1742) 
- 2025-11-18T23:52:45+01:00 wchooseCycles has now notes in an example by scrappy_fiddler in: [#1748](https://codeberg.org/uzu/strudel/pulls/1748) 
- 2025-11-17T05:31:54+01:00 Feature: Partials by glossing in: [#1659](https://codeberg.org/uzu/strudel/pulls/1659) 
- 2025-11-16T22:06:14+01:00 README: update superdough documentation by TristanMlct in: [#1741](https://codeberg.org/uzu/strudel/pulls/1741) 
- 2025-11-16T21:08:54+01:00 Worklet optimizations by glossing in: [#1730](https://codeberg.org/uzu/strudel/pulls/1730) 
- 2025-11-15T14:59:30+01:00 [perf] disconnect Offline AudioNode connections in generateReverb by jeromew in: [#1740](https://codeberg.org/uzu/strudel/pulls/1740) 
- 2025-11-15T14:57:47+01:00 [perf] disconnect `send` effect AudioNode when `room` is used by jeromew in: [#1736](https://codeberg.org/uzu/strudel/pulls/1736) 
- 2025-11-12T21:22:34+01:00 [supradough] fix: unstable filter by froos in: [#1593](https://codeberg.org/uzu/strudel/pulls/1593) 
- 2025-11-12T21:12:07+01:00 Fix link syntax in `project-start` by Kissaki in: [#1724](https://codeberg.org/uzu/strudel/pulls/1724) 
- 2025-11-12T21:06:13+01:00 Fix web README sample code by Kissaki in: [#1725](https://codeberg.org/uzu/strudel/pulls/1725) 
- 2025-11-12T20:59:39+01:00 Fix typo: 'studel' -> 'strudel' by drhayes in: [#1726](https://codeberg.org/uzu/strudel/pulls/1726) 
- 2025-11-12T15:23:41+01:00 fix for node 24 support in tests - #1718 by ausav in: [#1719](https://codeberg.org/uzu/strudel/pulls/1719) 
- 2025-11-11T09:00:49+01:00 soundAlias example fix by PepsiiMan in: [#1720](https://codeberg.org/uzu/strudel/pulls/1720)
- 2025-11-10T08:18:36+01:00 fix: Make Supradough package build by munshkr in: [#1711](https://codeberg.org/uzu/strudel/pulls/1711) 
- 2025-11-10T08:18:00+01:00 added docs for spaces in scale names by ondras in: [#1715](https://codeberg.org/uzu/strudel/pulls/1715) 
- 2025-11-10T02:44:01+01:00 Feature: LFOs for Filters by glossing in: [#1636](https://codeberg.org/uzu/strudel/pulls/1636)
- 2025-11-05T17:07:00+01:00 improvement: sync midi messages to audio context clock by daslyfe in: [#1708](https://codeberg.org/uzu/strudel/pulls/1708) 
- 2025-11-04T19:36:14+01:00 Add stick button mappings to gamepad implementation and improve docs by kaosuryoko in: [#1696](https://codeberg.org/uzu/strudel/pulls/1696) 
- 2025-11-04T19:29:35+01:00 Refactor sound stopping and triggering logic in SoundsTab component by IJOL in: [#1688](https://codeberg.org/uzu/strudel/pulls/1688) 
- 2025-11-04T19:13:21+01:00 Add setting to toggle pattern auto-start on pattern change by moumar in: [#1690](https://codeberg.org/uzu/strudel/pulls/1690) 
- 2025-11-04T18:58:50+01:00 Voicings JSDoc by sharkeys_lunchbox in: [#1686](https://codeberg.org/uzu/strudel/pulls/1686)
- 2025-11-01T07:50:40+01:00 FIX: Loading local samples uses too much memory by daslyfe in: [#1706](https://codeberg.org/uzu/strudel/pulls/1706) 
-
- 
-## october 2025
-
- 2025-10-28T22:58:24+01:00 Bug Fix: Handle scale-for-notes when n also supplied by glossing in: [#1625](https://codeberg.org/uzu/strudel/pulls/1625) 
- 2025-10-28T22:51:16+01:00 Repurpose vim shortcuts for usability by dtricks in: [#1624](https://codeberg.org/uzu/strudel/pulls/1624) 
- 2025-10-28T22:35:21+01:00 Add support for euclidian in mondo with `bd&3:8` by TristanCacqueray in: [#1630](https://codeberg.org/uzu/strudel/pulls/1630)
- 2025-10-27T10:42:07+01:00 Use bunny cdn for all samples and json files by yaxu in: [#1701](https://codeberg.org/uzu/strudel/pulls/1701) 
- 2025-10-26T22:52:54+01:00 degithub - switch some samples to bunnycdn by yaxu in: [#1697](https://codeberg.org/uzu/strudel/pulls/1697) 
- 2025-10-26T17:09:22+01:00 Fix ZZFX example by moumar in: [#1685](https://codeberg.org/uzu/strudel/pulls/1685) 
- 2025-10-23T15:56:04+02:00 Make osc port and host configurable. Changes dependencies. by yaxu in: [#1682](https://codeberg.org/uzu/strudel/pulls/1682) 
- 2025-10-23T03:47:31+02:00 Adds back shape to superdough by glossing in: [#1672](https://codeberg.org/uzu/strudel/pulls/1672) 
- 2025-10-22T22:15:19+02:00 Fix sampler.mjs githubPath by jeromew in: [#1684](https://codeberg.org/uzu/strudel/pulls/1684) 
- 2025-10-22T16:20:50+02:00 Fix onPaint for widgets by yaxu in: [#1658](https://codeberg.org/uzu/strudel/pulls/1658) 
- 2025-10-22T15:19:12+02:00 Fix a bug introduced by #4e17cfbdd6 by milliganf in: [#1679](https://codeberg.org/uzu/strudel/pulls/1679) 
- 2025-10-18T04:29:20+02:00 Bug Fix: Wavetable: phase wrapping at 1 and detune by glossing in: [#1620](https://codeberg.org/uzu/strudel/pulls/1620) 
- 2025-10-16T20:26:28+02:00 github samples: default to "samples" if repository is not specified by prezmop in: [#1644](https://codeberg.org/uzu/strudel/pulls/1644) 
- 2025-10-16T17:33:39+02:00 Docs: add example of custom chained function by dariusk in: [#1642](https://codeberg.org/uzu/strudel/pulls/1642) 
- 2025-10-14T12:39:48+02:00 textbox by yaxu in: [#1650](https://codeberg.org/uzu/strudel/pulls/1650) 
- 2025-10-13T07:05:57+02:00 Feature: Wavetable FM by glossing in: [#1623](https://codeberg.org/uzu/strudel/pulls/1623) 
- 2025-10-12T20:43:42+02:00 fix: repair REPL sample sources and URL concat (#1640) by erikfox in: [#1646](https://codeberg.org/uzu/strudel/pulls/1646)
- 2025-10-10T11:25:02+02:00 Add control-metadata by yaxu in: [#1634](https://codeberg.org/uzu/strudel/pulls/1634) 
- 2025-10-07T22:59:39+02:00 Fix MQTT: change the trigger handler to match new hap by jurrchen in: [#1629](https://codeberg.org/uzu/strudel/pulls/1629) 
- 2025-10-05T21:42:19+02:00 Fix case sensitivity for synonym search by vvolhejn in: [#1618](https://codeberg.org/uzu/strudel/pulls/1618) 
- 2025-10-01T08:56:35+02:00 Optimize wavetable synth by glossing in: [#1613](https://codeberg.org/uzu/strudel/pulls/1613) 
- 2025-10-01T02:02:33+02:00 fix: pattern switching by daslyfe in: [#1616](https://codeberg.org/uzu/strudel/pulls/1616) 
-
-## September 2025
-
- 2025-09-29T02:10:54+02:00 fix wavetable JSON by daslyfe in: [#1611](https://codeberg.org/uzu/strudel/pulls/1611) 
- 2025-09-28T21:28:16+02:00 rename wavetable controls to match existing naming conventions by daslyfe in: [#1610](https://codeberg.org/uzu/strudel/pulls/1610) 
- 2025-09-27T23:28:13+02:00 Feature: Wavetable synth improvements by glossing in: [#1607](https://codeberg.org/uzu/strudel/pulls/1607) 
- 2025-09-27T21:43:10+02:00 wavetable improvements by daslyfe in: [#1608](https://codeberg.org/uzu/strudel/pulls/1608) 
- 2025-09-26T08:48:46+02:00 create orbit based DJ filter by daslyfe in: [#1603](https://codeberg.org/uzu/strudel/pulls/1603) 
- 2025-09-23T13:28:20+02:00 fix: time signal by daslyfe in: [#1583](https://codeberg.org/uzu/strudel/pulls/1583) 
- 2025-09-21T16:16:06+02:00 mondo: fix all + setcpm + setcps by froos in: [#1600](https://codeberg.org/uzu/strudel/pulls/1600) 
- 2025-09-19T21:59:43+02:00 fix: osc error message by froos in: [#1597](https://codeberg.org/uzu/strudel/pulls/1597) 
- 2025-09-18T21:09:56+02:00 osc: --debug flag to see incoming messages by froos in: [#1595](https://codeberg.org/uzu/strudel/pulls/1595) 
- 2025-09-17T14:12:10+02:00 simplify osc usage by froos in: [#1588](https://codeberg.org/uzu/strudel/pulls/1588) 
- 2025-09-16T16:59:58+02:00 dev: logger errors to console in dev mode by daslyfe in: [#1585](https://codeberg.org/uzu/strudel/pulls/1585) 
- 2025-09-15T22:52:14+02:00 add tic80 font by froos in: [#1579](https://codeberg.org/uzu/strudel/pulls/1579) 
- 2025-09-15T00:00:19+02:00 supradough: fix delay + add some jsdoc types by froos in: [#1578](https://codeberg.org/uzu/strudel/pulls/1578) 
@@ -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,27 +72,6 @@ export function registerControl(names, ...aliases) {
  return bag;
 }

-export function registerMultiControl(names, maxControls, ...aliases) {
-  names = Array.isArray(names) ? names : [names];
-  let bag = {};
-  for (let i = 1; i <= maxControls; i++) {
-    let theseAliases = [...aliases];
-    let theseNames = [...names];
-    if (i === 1) {
-      // adds e.g. fm1 as an alias for fm
-      const aliases1 = theseAliases.map((a) => `${a}1`);
-      const names1 = theseNames.map((n) => `${n}1`);
-      theseAliases = theseAliases.concat(aliases1).concat(names1);
-    } else {
-      theseAliases = theseAliases.map((a) => `${a}${i}`);
-      theseNames = theseNames.map((n) => `${n}${i}`);
-    }
-    const subBag = registerControl(theseNames, ...theseAliases);
-    bag = { ...bag, ...subBag };
-  }
-  return bag;
-}
-
 /**
 * Select a sound / sample by name. When using mininotation, you can also optionally supply 'n' and 'gain' parameters
 * separated by ':'.
@@ -456,9 +435,6 @@ export const { attack, att } = registerControl('attack', 'att');
 * Whole numbers and simple ratios sound more natural,
 * while decimal numbers and complex ratios sound metallic.
 *
- * A number may be added afterwards to control the harmonicity of
- * any of the 8 individual FMs (e.g. `fmh2`)
- *
 * @name fmh
 * @param {number | Pattern} harmonicity
 * @example
@@ -468,40 +444,25 @@ export const { attack, att } = registerControl('attack', 'att');
 * ._scope()
 *
 */
-export const { fmh, fmh1, fmh2, fmh3, fmh4, fmh5, fmh6, fmh7, fmh8 } = registerMultiControl(['fmh', 'fmi'], 8, 'fmh');
-
+export const { fmh } = registerControl(['fmh', 'fmi'], 'fmh');
 /**
 * Sets the Frequency Modulation of the synth.
 * Controls the modulation index, which defines the brightness of the sound.
 *
- * A number may be added afterwards to control the modulation index of
- * any of the 8 individual FMs (e.g. `fm3`). Also, FMs may be routed into
- * each other with matrix commands like `fm13`, which would send `fm1` back into
- * `fm3`
- *
- * @name fmi
+ * @name fm
 * @param {number | Pattern} brightness modulation index
- * @synonyms fm
+ * @synonyms fmi
 * @example
 * note("c e g b g e")
 * .fm("<0 1 2 8 32>")
 * ._scope()
- * @example
- * s("sine").note("F1").seg(8)
- *  .fm(4).fm2(rand.mul(4)).fm3(saw.mul(8).slow(8))
- *  .fmh(1.06).fmh2(10).fmh3(0.1)
 *
 */
-export const { fmi, fmi1, fmi2, fmi3, fmi4, fmi5, fmi6, fmi7, fmi8, fm, fm1, fm2, fm3, fm4, fm5, fm6, fm7, fm8 } =
-  registerMultiControl(['fmi', 'fmh'], 8, 'fm');
-
+export const { fmi, fm } = registerControl(['fmi', 'fmh'], 'fm');
 // fm envelope
 /**
 * Ramp type of fm envelope. Exp might be a bit broken..
 *
- * A number may be added afterwards to control the envelope of
- * any of the 8 individual FMs (e.g. `fmenv4`)
- *
 * @name fmenv
 * @param {number | Pattern} type lin | exp
 * @example
@@ -513,19 +474,11 @@ export const { fmi, fmi1, fmi2, fmi3, fmi4, fmi5, fmi6, fmi7, fmi8, fm, fm1, fm2
 * ._scope()
 *
 */
-export const { fmenv, fmenv1, fmenv2, fmenv3, fmenv4, fmenv5, fmenv6, fmenv7, fmenv8 } = registerMultiControl(
-  'fmenv',
-  8,
-);
-
+export const { fmenv } = registerControl('fmenv');
 /**
 * Attack time for the FM envelope: time it takes to reach maximum modulation
 *
- * A number may be added afterwards to control the attack of the envelope of
- * any of the 8 individual FMs (e.g. `fmatt5`)
- *
 * @name fmattack
- * @synonyms fmatt
 * @param {number | Pattern} time attack time
 * @example
 * note("c e g b g e")
@@ -534,33 +487,11 @@ export const { fmenv, fmenv1, fmenv2, fmenv3, fmenv4, fmenv5, fmenv6, fmenv7, fm
 * ._scope()
 *
 */
-export const {
-  fmattack,
-  fmattack1,
-  fmattack2,
-  fmattack3,
-  fmattack4,
-  fmattack5,
-  fmattack6,
-  fmattack7,
-  fmattack8,
-  fmatt,
-  fmatt1,
-  fmatt2,
-  fmatt3,
-  fmatt4,
-  fmatt5,
-  fmatt6,
-  fmatt7,
-  fmatt8,
-} = registerMultiControl('fmattack', 8, 'fmatt');
+export const { fmattack } = registerControl('fmattack');

 /**
 * Waveform of the fm modulator
 *
- * A number may be added afterwards to control the waveform
- * any of the 8 individual FMs (e.g. `fmwave6`)
- *
 * @name fmwave
 * @param {number | Pattern} wave waveform
 * @example
@@ -569,19 +500,12 @@ export const {
 * n("0 1 2 3".fast(4)).chord("<Dm Am F G>").voicing().s("sawtooth").fmwave("brown").fm(.6)
 *
 */
-export const { fmwave, fmwave1, fmwave2, fmwave3, fmwave4, fmwave5, fmwave6, fmwave7, fmwave8 } = registerMultiControl(
-  'fmwave',
-  8,
-);
+export const { fmwave } = registerControl('fmwave');

 /**
 * Decay time for the FM envelope: seconds until the sustain level is reached after the attack phase.
 *
- * A number may be added afterwards to control the decay of the envelope of
- * any of the 8 individual FMs (e.g. `fmdec6`)
- *
 * @name fmdecay
- * @synonyms fmdec
 * @param {number | Pattern} time decay time
 * @example
 * note("c e g b g e")
@@ -591,35 +515,11 @@ export const { fmwave, fmwave1, fmwave2, fmwave3, fmwave4, fmwave5, fmwave6, fmw
 * ._scope()
 *
 */
-export const {
-  fmdecay,
-  fmdecay1,
-  fmdecay2,
-  fmdecay3,
-  fmdecay4,
-  fmdecay5,
-  fmdecay6,
-  fmdecay7,
-  fmdecay8,
-  fmdec,
-  fmdec1,
-  fmdec2,
-  fmdec3,
-  fmdec4,
-  fmdec5,
-  fmdec6,
-  fmdec7,
-  fmdec8,
-} = registerMultiControl('fmdecay', 8, 'fmdec');
-
+export const { fmdecay } = registerControl('fmdecay');
 /**
 * Sustain level for the FM envelope: how much modulation is applied after the decay phase
 *
- * A number may be added afterwards to control the sustain of the envelope of
- * any of the 8 individual FMs (e.g. `fmsus7`)
- *
 * @name fmsustain
- * @synonyms fmsus
 * @param {number | Pattern} level sustain level
 * @example
 * note("c e g b g e")
@@ -629,69 +529,10 @@ export const {
 * ._scope()
 *
 */
-export const {
-  fmsustain,
-  fmsustain1,
-  fmsustain2,
-  fmsustain3,
-  fmsustain4,
-  fmsustain5,
-  fmsustain6,
-  fmsustain7,
-  fmsustain8,
-  fmsus,
-  fmsus1,
-  fmsus2,
-  fmsus3,
-  fmsus4,
-  fmsus5,
-  fmsus6,
-  fmsus7,
-  fmsus8,
-} = registerMultiControl('fmsustain', 8, 'fmsus');
-
-/**
- * Release time for the FM envelope: how much modulation is applied after the note is released
- *
- * A number may be added afterwards to control the release of the envelope of
- * any of the 8 individual FMs (e.g. `fmrel8`)
- *
- * @name fmrelease
- * @synonyms fmrel
- * @param {number | Pattern} time release time
- *
- */
-export const {
-  fmrelease,
-  fmrelease1,
-  fmrelease2,
-  fmrelease3,
-  fmrelease4,
-  fmrelease5,
-  fmrelease6,
-  fmrelease7,
-  fmrelease8,
-  fmrel,
-  fmrel1,
-  fmrel2,
-  fmrel3,
-  fmrel4,
-  fmrel5,
-  fmrel6,
-  fmrel7,
-  fmrel8,
-} = registerMultiControl('fmrelease', 8, 'fmrel');
-
-// FM Matrix
-// Note: we do not declare top-level exports here since it would add
-// ~162 more explicit exports. This is likely fine as the most common use-case would be to at least
-// declare one other FM prior to utilizing the matrix functionality, but if we ever decide we need it,
-// TODO to add it explicitly / go with the globalThis approach
-for (let i = 0; i <= 8; i++) {
-  for (let j = 0; j <= 8; j++) {
-    registerControl(`fmi${i}${j}`, `fm${i}${j}`);
-  }
-}
+export const { fmsustain } = registerControl('fmsustain');
+// these are not really useful... skipping for now
+export const { fmrelease } = registerControl('fmrelease');
+export const { fmvelocity } = registerControl('fmvelocity');

 /**
 * Select the sound bank to use. To be used together with `s`. The bank name (+ "_") will be prepended to the value of `s`.
@@ -1447,196 +1288,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
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lprate("<4 8 2 1>")
- */
-export const { lprate } = registerControl('lprate');
-
-/**
- * Cycle-synced rate of the LFO for the lowpass filter
- *
- * @name lpsync
- * @param {number | Pattern} rate rate in cycles
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpsync("<4 8 2 1>")
- */
-export const { lpsync } = registerControl('lpsync');
-
-/**
- * Depth of the LFO for the lowpass filter
- *
- * @name lpdepth
- * @param {number | Pattern} depth depth of modulation
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpdepth("<1 .5 1.8 0>")
- */
-
-export const { lpdepth } = registerControl('lpdepth');
-/**
- * Depth of the LFO for the lowpass filter, in HZ
- *
- * @name lpdepthfrequency
- * @synonyms
- * lpdethfreq
- * @param {number | Pattern} depth depth of modulation
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpdepthfrequency("<200 500 100 0>")
- */
-
-export const { lpdepthfrequency } = registerControl('lpdepthfrequency', 'lpdepthfreq');
-
-/**
- * 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');
-
-/**
- * Depth of the LFO for the bandpass filter, in HZ
- *
- * @name bpdepthfrequency
- * @synonyms
- * bpdethfreq
- * @param {number | Pattern} depth depth of modulation
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).bpdepthfrequency("<200 500 100 0>")
- */
-
-export const { bpdepthfrequency } = registerControl('bpdepthfrequency', 'bpdepthfreq');
-
-/**
- * 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, hpdepthfreq } = registerControl('hpdepth');
-
-/**
- * Depth of the LFO for the hipass filter, in hz
- *
- * @name hpdepthfrequency
- * @synonyms
- * hpdethfreq
- * @param {number | Pattern} depth depth of modulation
- * @example
- * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).hpdepthfrequency("<200 500 100 0>")
- */
-
-export const { hpdepthfrequency } = registerControl('hpdepthfrequency', 'hpdepthfreq');
-
-/**
- * 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.
 *
@@ -2024,12 +1675,12 @@ export const { nudge } = registerControl('nudge');
 * Sets the default octave of a synth.
 *
 * @name octave
- * @synonyms oct
 * @param {number | Pattern} octave octave number
 * @example
- * n("0,4,7").scale("F:minor").s('supersaw').octave("<0 1 2 3>")
+ * n("0,4,7").s('supersquare').octave("<3 4 5 6>").osc()
+ * @superDirtOnly
 */
-export const { octave, oct } = registerControl('octave', 'oct');
+export const { octave } = registerControl('octave');

 // ['ophatdecay'],
 // TODO: example
@@ -2037,7 +1688,6 @@ export const { octave, oct } = registerControl('octave', 'oct');
 * An `orbit` is a global parameter context for patterns. Patterns with the same orbit will share the same global effects.
 *
 * @name orbit
- * @synonyms o
 * @param {number | Pattern} number
 * @example
 * stack(
@@ -2045,7 +1695,7 @@ export const { octave, oct } = registerControl('octave', 'oct');
 *   s("~ sd ~ sd").delay(.5).delaytime(.125).orbit(2)
 * )
 */
-export const { orbit } = registerControl('orbit', 'o');
+export const { orbit } = registerControl('orbit');
 // TODO: what is this? not found in tidal doc Answer: gain is limited to maximum of 2. This allows you to go over that
 export const { overgain } = registerControl('overgain');
 // TODO: what is this? not found in tidal doc. Similar to above, but limited to 1
@@ -2100,64 +1750,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']);

 /**
@@ -2469,6 +2072,7 @@ export const { tsdelay } = registerControl('tsdelay');
 export const { real } = registerControl('real');
 export const { imag } = registerControl('imag');
 export const { enhance } = registerControl('enhance');
+export const { partials } = registerControl('partials');
 export const { comb } = registerControl('comb');
 export const { smear } = registerControl('smear');
 export const { scram } = registerControl('scram');
@@ -37,8 +37,5 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -25,7 +25,7 @@ import {
  stringifyValues,
 } from './util.mjs';
 import drawLine from './drawLine.mjs';
-import { errorLogger, logger } from './logger.mjs';
+import { logger } from './logger.mjs';

 let stringParser;

@@ -414,7 +414,7 @@ export class Pattern {
    try {
      return this.query(new State(new TimeSpan(begin, end), controls));
    } catch (err) {
-      errorLogger(err, 'query');
+      logger(`[query]: ${err.message}`, 'error');
      return [];
    }
  }
@@ -2234,7 +2234,7 @@ export const brak = register('brak', function (pat) {
 });

 /**
- * Reverse all cycles in a pattern. See also `revv` for reversing a whole pattern.
+ * Reverse all haps in a pattern
 *
 * @name rev
 * @memberof Pattern
@@ -2266,23 +2266,6 @@ export const rev = register(
  true,
 );

-/**
- * Reverse a whole pattern. See also `rev` for reversing each cycle.
- *
- * @name revv
- * @memberof Pattern
- * @returns Pattern
- * @example
- * // This is the same as `<[g e] [d c]>`. If `rev()` is used, you get
- * // the same as `<[d c] [g e]>`, where each cycle reverses, but the order of
- * // cycles stays the same.
- * note("<[c d] [e g]>").revv()
- */
-export const revv = register('revv', function (pat) {
-  const negateSpan = (span) => new TimeSpan(Fraction(0).sub(span.end), Fraction(0).sub(span.begin));
-  return pat.withQuerySpan(negateSpan).withHapSpan(negateSpan);
-});
-
 /** Like press, but allows you to specify the amount by which each
 * event is shifted. pressBy(0.5) is the same as press, while
 * pressBy(1/3) shifts each event by a third of its timespan.
@@ -3641,66 +3624,3 @@ for (const name of distAlgoNames) {
    return this.distort(argsPat);
  };
 }
-
-/**
- * Turns a list of patterns into a single pattern which outputs list-values
- *
- * @name parray
- * @returns Pattern
- */
-export const parray = (pats) => {
-  const pack = (...xs) => xs;
-  let acc = pure(curry(pack, null, pats.length));
-  for (const p of pats) acc = acc.appBoth(reify(p));
-  return acc;
-};
-
-const _ensureListPattern = (list) => {
-  if (Array.isArray(list)) {
-    return parray(list);
-  }
-  return reify(list);
-};
-
-/**
- * Scale the magnitude of the harmonics of one of the core synths ('sine', 'tri', 'saw', ..)
- *
- * Can also be used to create a new synth via `s('user').partials(...)`
- *
- * @name partials
- * @param {number[] | Pattern} magnitudes List of [0, 1] magnitudes for partials. 0th entry is the fundamental harmonic (i.e. DC offset is skipped)
- * @example
- * s("user").seg(16).n(irand(8)).scale("A:major")
- *   .partials([1, 0, 1, 0, 0, 1])
- * @example
- * s("saw").seg(8).n(irand(12)).scale("G#:minor")
- *   .partials(binaryL(irand(256).add("1")))
- */
-Pattern.prototype.partials = function (list) {
-  return this.withValue((v) => (l) => ({ ...v, partials: l })).appLeft(_ensureListPattern(list));
-};
-
-// Also create a top-level function
-export const partials = (list) => {
-  return _ensureListPattern(list).as('partials');
-};
-
-/**
- * Rotates the harmonics of one of the core synths ('sine', 'tri', 'saw', 'user', ..) by a list of phases
- *
- * @name phases
- * @param {number[] | Pattern} phases List of [0, 1) phases for partials. 0th entry is the fundamental phase (i.e. DC offset is skipped)
- * @example
- * // Phase cancellation
- * s("saw").seg(8).n(irand(12)).scale("G#1:minor")
- *   .partials(partials([1, 1, 1]))
- *   .superimpose(x => x.phases([0.5, 0.5, 0.5]))
- */
-Pattern.prototype.phases = function (list) {
-  return this.withValue((v) => (l) => ({ ...v, phases: l })).appLeft(_ensureListPattern(list));
-};
-
-// Also create a top-level function
-export const phases = (list) => {
-  return _ensureListPattern(list).as('phases');
-};
@@ -152,9 +152,9 @@ export function repl({
        // allows muting a pattern x with x_ or _x
        return silence;
      }
-      if (id.includes('$')) {
+      if (id === '$') {
        // allows adding anonymous patterns with $:
-        id = `${id}${anonymousIndex}`;
+        id = `$${anonymousIndex}`;
        anonymousIndex++;
      }
      pPatterns[id] = this;
@@ -215,19 +215,8 @@ export function repl({
      let { pattern, meta } = await _evaluate(code, transpiler, transpilerOptions);
      if (Object.keys(pPatterns).length) {
        let patterns = [];
-        let soloActive = false;
        for (const [key, value] of Object.entries(pPatterns)) {
-          // handle soloed patterns ex: S$: s("bd!4")
-          const isSolod = key.length > 1 && key.startsWith('S');
-          if (isSolod && soloActive === false) {
-            // first time we see a soloed pattern, clear existing patterns
-            patterns = [];
-            soloActive = true;
-          }
-          if (!soloActive || (soloActive && isSolod)) {
-            const valWithState = value.withState((state) => state.setControls({ id: key }));
-            patterns.push(valWithState);
-          }
+          patterns.push(value.withState((state) => state.setControls({ id: key })));
        }
        if (eachTransform) {
          // Explicit lambda so only element (not index and array) are passed
@@ -238,13 +227,14 @@ export function repl({
        pattern = eachTransform(pattern);
      }
      if (allTransforms.length) {
-        for (const transform of allTransforms) {
-          pattern = transform(pattern);
+        for (let i in allTransforms) {
+          pattern = allTransforms[i](pattern);
        }
      }

      if (!isPattern(pattern)) {
-        pattern = silence;
+        const message = `got "${typeof evaluated}" instead of pattern`;
+        throw new Error(message + (typeof evaluated === 'function' ? ', did you forget to call a function?' : '.'));
      }
      logger(`[eval] code updated`);
      pattern = await setPattern(pattern, autostart);
@@ -228,7 +228,7 @@ const timeToRands = (t, n) => timeToRandsPrime(timeToIntSeed(t), n);
 export const run = (n) => saw.range(0, n).round().segment(n);

 /**
- * Creates a binary pattern from a number.
+ * Creates a pattern from a binary number.
 *
 * @name binary
 * @param {number} n - input number to convert to binary
@@ -242,7 +242,7 @@ export const binary = (n) => {
 };

 /**
- * Creates a binary pattern from a number, padded to n bits long.
+ * Creates a pattern from a binary number, padded to n bits long.
 *
 * @name binaryN
 * @param {number} n - input number to convert to binary
@@ -258,51 +258,6 @@ export const binaryN = (n, nBits = 16) => {
  return reify(n).segment(nBits).brshift(bitPos).band(pure(1));
 };

-/**
- * Creates a binary list pattern from a number.
- *
- * @name binaryL
- * @param {number} n - input number to convert to binary
- * s("saw").seg(8)
- *   .partials(binaryL(irand(4096).add(1)))
- */
-export const binaryL = (n) => {
-  const nBits = reify(n).log2(0).floor().add(1);
-  return binaryNL(n, nBits);
-};
-
-/**
- * Creates a binary list pattern from a number, padded to n bits long.
- *
- * @name binaryNL
- * @param {number} n - input number to convert to binary
- * @param {number} nBits - pattern length, defaults to 16
- */
-export const binaryNL = (n, nBits = 16) => {
-  return reify(n)
-    .withValue((v) => (bits) => {
-      const bList = [];
-      for (let i = bits - 1; i >= 0; i--) {
-        bList.push((v >> i) & 1);
-      }
-      return bList;
-    })
-    .appLeft(reify(nBits));
-};
-
-/**
- * Creates a list of random numbers of the given length
- *
- * @name randL
- * @param {number} n Number of random numbers to sample
- * @example
- * s("saw").seg(16).n(irand(12)).scale("F1:minor")
- *   .partials(randL(8))
- */
-export const randL = (n) => {
-  return signal((t) => (nVal) => timeToRands(t, nVal).map(Math.abs)).appLeft(reify(n));
-};
-
 export const randrun = (n) => {
  return signal((t) => {
    // Without adding 0.5, the first cycle is always 0,1,2,3,...
@@ -524,7 +479,7 @@ export const wchoose = (...pairs) => wchooseWith(rand, ...pairs);
 * @example
 * wchooseCycles(["bd",10], ["hh",1], ["sd",1]).s().fast(8)
 * @example
- * wchooseCycles(["c c c",5], ["a a a",3], ["f f f",1]).fast(4).note()
+ * wchooseCycles(["bd bd bd",5], ["hh hh hh",3], ["sd sd sd",1]).fast(4).s()
 * @example
 * // The probability can itself be a pattern
 * wchooseCycles(["bd(3,8)","<5 0>"], ["hh hh hh",3]).fast(4).s()
@@ -586,18 +586,6 @@ describe('Pattern', () => {
          .map((a) => a.value),
      ).toStrictEqual(['c', 'b', 'a']);
    });
-    it('Does not reverse the order of cycles', () => {
-      expect(fastcat('a', 'b', 'c', 'd').slow(2).rev().fast(2).sortHapsByPart().firstCycle()).toStrictEqual(
-        fastcat('b', 'a', 'd', 'c').firstCycle(),
-      );
-    });
-  });
-  describe('revv()', () => {
-    it('Does reverse the order of cycles', () => {
-      expect(fastcat('a', 'b', 'c', 'd').slow(2).revv().fast(2).sortHapsByPart().firstCycle()).toStrictEqual(
-        fastcat('d', 'c', 'b', 'a').firstCycle(),
-      );
-    });
  });
  describe('sequence()', () => {
    it('Can work like fastcat', () => {
@@ -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"
 }
@@ -14,7 +14,12 @@ npm i @strudel/gamepad --save
 import { gamepad } from '@strudel/gamepad';

 // Initialize gamepad (optional index parameter, defaults to 0)
-const pad = gamepad(0);
+const pad = gamepad(0); // Default mapping is XBOX {a: 0, b: 1, x: 2, y: 3}
+
+//const pad = gamepad(0, 'XBOX'); // XBOX button mapping {a: 0, b: 1, x: 2, y: 3}
+//const pad = gamepad(0, 'NES'); // Nintendo button mapping {a: 1, b: 0, x: 3, y: 2}
+//const pad = gamepad(0, {a: 0, b: 1, x: 2, y: 3}); // Custom mapping
+

 // Use gamepad inputs in patterns
 const pattern = sequence([
@@ -40,12 +45,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
@@ -92,6 +91,7 @@ $: sound("hadoken").gain(pad.checkSequence(HADOKEN))
 ## Multiple Gamepads

 You can connect multiple gamepads by specifying the gamepad index:
+Make sure to press buttons on all connected gamepads before hitting play, so the browser can properly detect them.

 ```javascript
 const pad1 = gamepad(0);  // First gamepad
@@ -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

@@ -111,9 +107,32 @@ $: s("free_hadouken -").slow(2)
 samples({free_hadouken: 'https://cdn.freesound.org/previews/67/67674_111920-lq.mp3'})
 `} />

-## Multiple Gamepads
+### Button Sequences
+
+### Button Mappings
+
+The gamepad module supports different button mapping configurations to accommodate various gamepad layouts:
+
+- **XBOX** (Default): Standard Xbox-style mapping where A=0, B=1, X=2, Y=3
+- **NES**: Nintendo-style mapping where B=0, A=1, Y=2, X=3
+- **Custom**: Define your own button mapping by passing an object with button assignments
+
+You can specify the mapping when initializing the gamepad:
+
+<MiniRepl
+  client:idle
+  tune={`
+const pad1 = gamepad(0); // Default mapping is XBOX {a: 0, b: 1, x: 2, y: 3}
+const pad2 = gamepad(1, 'XBOX'); // XBOX button mapping {a: 0, b: 1, x: 2, y: 3}
+const pad3 = gamepad(2, 'NES'); // Nintendo button mapping {a: 1, b: 0, x: 3, y: 2}
+const pad4 = gamepad(3, {a: 0, b: 1, x: 2, y: 3}); // Custom mapping
+`}
+/>
+
+### Multiple Gamepads

 Strudel supports multiple gamepads. You can specify the gamepad index to connect to different devices.
+Make sure to press buttons on all connected gamepads before hitting play, so the browser can properly detect them.

 <MiniRepl
  client:idle
@@ -1,39 +1,62 @@
 // @strudel/gamepad/index.mjs

 import { signal } from '@strudel/core';
+import { logger } from '@strudel/core';

 // Button mapping for Logitech Dual Action (STANDARD GAMEPAD Vendor: 046d Product: c216)
-export const buttonMap = {
-  a: 0,
-  b: 1,
-  x: 2,
-  y: 3,
-  lb: 4,
-  rb: 5,
-  lt: 6,
-  rt: 7,
-  back: 8,
-  start: 9,
-  l3: 10,
-  ls: 10,
-  r3: 11,
-  rs: 11,
-  u: 12,
-  up: 12,
-  d: 13,
-  down: 13,
-  l: 14,
-  left: 14,
-  r: 15,
-  right: 15,
+
+const buttonMapSettings = {
+  XBOX: {
+    // XBOX mapping default
+    a: 0,
+    b: 1,
+    x: 2,
+    y: 3,
+    lb: 4,
+    rb: 5,
+    lt: 6,
+    rt: 7,
+    back: 8,
+    start: 9,
+    u: 12,
+    up: 12,
+    d: 13,
+    down: 13,
+    l: 14,
+    left: 14,
+    r: 15,
+    right: 15,
+  },
+  NES: {
+    // Nintendo mapping
+    a: 1,
+    b: 0,
+    x: 3,
+    y: 2,
+    lb: 4,
+    rb: 5,
+    lt: 6,
+    rt: 7,
+    back: 8,
+    start: 9,
+    u: 12,
+    up: 12,
+    d: 13,
+    down: 13,
+    l: 14,
+    left: 14,
+    r: 15,
+    right: 15,
+  },
 };

 class ButtonSequenceDetector {
-  constructor(timeWindow = 1000) {
+  constructor(timeWindow = 1000, mapping) {
    this.sequence = [];
    this.timeWindow = timeWindow;
    this.lastInputTime = 0;
    this.buttonStates = Array(16).fill(0); // Track previous state of each button
+    this.buttonMap = mapping;
    // Button mapping for character inputs
  }

@@ -48,7 +71,8 @@ class ButtonSequenceDetector {
      }

      // Store the button name instead of index
-      const buttonName = Object.keys(buttonMap).find((key) => buttonMap[key] === buttonIndex) || buttonIndex.toString();
+      const buttonName =
+        Object.keys(this.buttonMap).find((key) => this.buttonMap[key] === buttonIndex) || buttonIndex.toString();

      this.sequence.push({
        input: buttonName,
@@ -91,9 +115,9 @@ class ButtonSequenceDetector {
      // Check if either the input matches directly or they refer to the same button in the map
      return (
        input === target ||
-        buttonMap[input] === buttonMap[target] ||
+        this.buttonMap[input] === this.buttonMap[target] ||
        // Also check if the numerical index matches
-        buttonMap[input] === parseInt(target)
+        this.buttonMap[input] === parseInt(target)
      );
    })
      ? 1
@@ -102,9 +126,10 @@ class ButtonSequenceDetector {
 }

 class GamepadHandler {
-  constructor(index = 0) {
+  constructor(index = 0, mapping) {
    // Add index parameter
    this._gamepads = {};
+    this._mapping = mapping;
    this._activeGamepad = index; // Use provided index
    this._axes = [0, 0, 0, 0];
    this._buttons = Array(16).fill(0);
@@ -147,12 +172,66 @@ class GamepadHandler {
  }
 }

+// Add utility function to list all connected gamepads
+export const listGamepads = () => {
+  const gamepads = navigator.getGamepads();
+  const connectedGamepads = Array.from(gamepads)
+    .filter((gp) => gp !== null)
+    .map((gp) => ({
+      index: gp.index,
+      id: gp.id,
+      mapping: gp.mapping,
+      buttons: gp.buttons.length,
+      axes: gp.axes.length,
+      connected: gp.connected,
+      timestamp: gp.timestamp,
+    }));
+  // Format the gamepads info into a readable string
+  const gamepadsInfo = connectedGamepads.map((gp) => `${gp.index}: ${gp.id}`).join('\n');
+
+  logger(`[gamepad] available gamepads:\n${gamepadsInfo}`);
+  return connectedGamepads;
+};
+
 // Module-level state store for toggle states
 const gamepadStates = new Map();

-export const gamepad = (index = 0) => {
-  const handler = new GamepadHandler(index);
-  const sequenceDetector = new ButtonSequenceDetector(2000);
+export const gamepad = (index = 0, mapping = 'XBOX') => {
+  // list connected gamepads
+  const connectedGamepads = listGamepads();
+
+  // Check if the requested gamepad index exists
+  const requestedGamepad = connectedGamepads.find((gp) => gp.index === index);
+  if (!requestedGamepad) {
+    throw new Error(
+      `[gamepad] gamepad at index ${index} not found. available gamepads: ${connectedGamepads.map((gp) => gp.index).join(', ')}`,
+    );
+  }
+
+  // Handle button mapping
+  let buttonMap = buttonMapSettings.XBOX;
+
+  if (typeof mapping === 'string') {
+    buttonMap = buttonMapSettings[mapping.toUpperCase()];
+  } else if (typeof mapping === 'object') {
+    buttonMap = { ...buttonMapSettings.XBOX, ...mapping };
+    // Check that all mapping values are valid button indices
+    const maxButtons = requestedGamepad.buttons; // Standard gamepad has 16 buttons
+    for (const [key, value] of Object.entries(mapping)) {
+      if (typeof value !== 'number' || value < 0 || value >= maxButtons) {
+        throw new Error(
+          `[gamepad] invalid button mapping for '${key}': ${value}. Must be a number between 0 and ${maxButtons - 1}`,
+        );
+      }
+    }
+  }
+
+  if (!buttonMap) {
+    throw new Error(`[gamepad] button mapping '${mapping}' not found`);
+  }
+
+  const handler = new GamepadHandler(index, buttonMap);
+  const sequenceDetector = new ButtonSequenceDetector(2000, buttonMap);

  // Base signal that polls gamepad state and handles sequence detection
  const baseSignal = signal((t) => {
@@ -222,8 +301,14 @@ export const gamepad = (index = 0) => {
    return baseSignal.fmap(() => sequenceDetector.checkSequence(sequence));
  };
  const checkSequence = btnSequence;
+  const sequence = btnSequence;
  const btnSeq = btnSequence;
-  const btnseq = btnSeq;
+  const btnseq = btnSequence;
+  const seq = btnSequence;
+
+  logger(
+    `[gamepad] connected to gamepad ${index} (${requestedGamepad.id}) with ${typeof mapping === 'object' ? 'custom' : mapping} mapping`,
+  );

  // Return an object with all controls
  return {
@@ -238,9 +323,11 @@ export const gamepad = (index = 0) => {
      ]),
    ),
    checkSequence,
+    sequence,
    btnSequence,
    btnSeq,
    btnseq,
+    seq,
    raw: baseSignal,
  };
 };
@@ -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"
  }
 }
@@ -35,7 +35,6 @@ export async function initHydra(options = {}) {
      hydra.synth.s0.init({ src: canvas });
    }
  }
-  return hydra;
 }

 export function clearHydra() {
@@ -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"
  }
 }
@@ -44,8 +44,5 @@
  "devDependencies": {
    "pkg": "^5.8.1",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -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"
  }
 }
@@ -9,7 +9,6 @@ import readline from 'readline';
 import os from 'os';

 const LOG = !!process.env.LOG || false;
-const PORT = process.env.PORT || 5432;
 const VALID_AUDIO_EXTENSIONS = ['wav', 'mp3', 'ogg'];

 const isAudioFile = (f) => {
@@ -55,6 +54,7 @@ async function getBanks(directory, flat = false) {
    banks[bank].push(subDir);
    return subDir;
  });
+  banks._base = `http://localhost:5432`;
  return { banks, files };
 }

@@ -134,6 +134,8 @@ const server = http.createServer(async (req, res) => {
  readStream.pipe(res);
 });

+// eslint-disable-next-line
+const PORT = process.env.PORT || 5432;
 const IP_ADDRESS = '0.0.0.0';
 let IP;
 const networkInterfaces = os.networkInterfaces();
@@ -33,8 +33,5 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -6,7 +6,6 @@ import {
  getADSRValues,
  getPitchEnvelope,
  getVibratoOscillator,
-  onceEnded,
 } from '@strudel/webaudio';
 import gm from './gm.mjs';

@@ -171,12 +170,12 @@ export function registerSoundfonts() {

        bufferSource.stop(envEnd);
        const stop = (releaseTime) => {};
-        onceEnded(bufferSource, () => {
+        bufferSource.onended = () => {
          bufferSource.disconnect();
          vibratoOscillator?.stop();
          node.disconnect();
          onended();
-        });
+        };
        return { node, stop };
      },
      { type: 'soundfont', prebake: true, fonts },
@@ -37,8 +37,5 @@
  "devDependencies": {
    "node-fetch": "^3.3.2",
    "vite": "^6.0.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -89,7 +89,7 @@ superdough({ s: 'bd', delay: 0.5 }, 0, 1);
  - `decay`: seconds of decay phase
  - `sustain`: gain of sustain phase
  - `release`: seconds of release phase
- `deadline`: seconds from audio context initialization before playing the sound (getAudioContextCurrentTime() = immediate)
+- `deadline`: seconds until the sound should play (0 = immediate)
 - `duration`: seconds the sound should last. optional for one shot samples, required for synth sounds

 ### registerSynthSounds()
@@ -1,7 +1,7 @@
 import { getAudioContext } from './audioContext.mjs';
-import { logger } from './logger.mjs';
-import { getNoiseBuffer } from './noise.mjs';
 import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';
+import { getNoiseBuffer } from './noise.mjs';
+import { logger } from './logger.mjs';

 export const noises = ['pink', 'white', 'brown', 'crackle'];

@@ -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,78 +170,56 @@ 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, cycle) {
-  let {
-    frequency,
-    anchor,
-    env,
-    type,
-    model,
-    q = 1,
-    drive = 0.69,
-    depth,
-    depthfrequency,
-    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);
+  const hasEnvelope = att ?? dec ?? sus ?? rel ?? fenv;
  // 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;
+  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 ** (envAbs - offset) * frequency, 0, 20000);
-    if (env < 0) [min, max] = [max, min];
-    getParamADSR(frequencyParam, attack, decay, sustain, release, min, max, start, end, 'exponential');
+    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;
  }
-
-  if (sync != null) {
-    rate = cps * sync;
-  }
-  const hasLFO = [depth, depthfrequency, skew, shape, rate].some((v) => v !== undefined);
-  let lfo;
-  if (hasLFO) {
-    depth = depth ?? 1;
-    const time = cycle / cps;
-    const modDepth = depthfrequency ?? (depth ?? 1) * frequency;
-    const lfoValues = {
-      depth: modDepth,
-      dcoffset,
-      skew,
-      shape,
-      frequency: rate ?? cps,
-      min: -frequency + 30,
-      max: 20000 - frequency,
-      time,
-      curve: 1,
-    };
-    lfo = getParamLfo(context, frequencyParam, start, end, lfoValues);
-  }
-
-  return { filter, lfo };
+  return filter;
 }

 // stays 1 until .5, then fades out
@@ -281,15 +241,7 @@ export function drywet(dry, wet, wetAmount = 0) {
  let mix = ac.createGain();
  dry_gain.connect(mix);
  wet_gain.connect(mix);
-  return {
-    node: mix,
-    onended: () => {
-      dry_gain.disconnect(mix);
-      wet_gain.disconnect(mix);
-      dry.disconnect(dry_gain);
-      wet.disconnect(wet_gain);
-    },
-  };
+  return mix;
 }

 let curves = ['linear', 'exponential'];
@@ -324,19 +276,10 @@ export function getVibratoOscillator(param, value, t) {
    gain.gain.value = vibmod * 100;
    vibratoOscillator.connect(gain);
    gain.connect(param);
-    vibratoOscillator.onended = () => {
-      gain.disconnect(param);
-      vibratoOscillator.disconnect(gain);
-    };
    vibratoOscillator.start(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) {
@@ -349,17 +292,25 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
  constantNode.connect(zeroGain);

  // Schedule the `onComplete` callback to occur at `stopTime`
-  onceEnded(constantNode, () => {
-    releaseAudioNode(zeroGain);
-    releaseAudioNode(constantNode);
+  constantNode.onended = () => {
+    // Ensure garbage collection
+    try {
+      zeroGain.disconnect();
+    } catch {
+      // pass
+    }
+    try {
+      constantNode.disconnect();
+    } catch {
+      // pass
+    }
    onComplete();
-  });
+  };
  constantNode.start(startTime);
  constantNode.stop(stopTime);
  return constantNode;
 }
-
-const mod = (freq, type = 'sine') => {
+const mod = (freq, range = 1, type = 'sine') => {
  const ctx = getAudioContext();
  let osc;
  if (noises.includes(type)) {
@@ -371,89 +322,64 @@ const mod = (freq, type = 'sine') => {
    osc.type = type;
    osc.frequency.value = freq;
  }
-  osc.start();
-  return osc;
-};

-const fm = (frequencyparam, harmonicityRatio, wave = 'sine') => {
+  osc.start();
+  const g = new GainNode(ctx, { gain: range });
+  osc.connect(g); // -range, range
+  return { node: g, stop: (t) => osc.stop(t) };
+};
+const fm = (frequencyparam, harmonicityRatio, modulationIndex, wave = 'sine') => {
  const carrfreq = frequencyparam.value;
  const modfreq = carrfreq * harmonicityRatio;
-  return { osc: mod(modfreq, wave), freq: modfreq };
+  const modgain = modfreq * modulationIndex;
+  return mod(modfreq, modgain, wave);
 };
-
 export function applyFM(param, value, begin) {
-  const ac = getAudioContext();
-  const toStop = []; // fm oscillators we will expose `stop` for
-  const fms = {};
-  // Matrix
-  for (let i = 1; i <= 8; i++) {
-    for (let j = 0; j <= 8; j++) {
-      let control;
-      if (i === j + 1) {
-        // Standard fm3 -> fm2 -> fm1 -> param usage
-        const iS = i === 1 ? '' : i;
-        control = `fmi${iS}`;
-      } else {
-        control = `fmi${i}${j}`;
-      }
-      const amt = value[control];
-      if (!amt) continue;
-      let io = [];
-      for (let [isMod, idx] of [
-        [true, i], // source
-        [false, j], // target
-      ]) {
-        if (idx === 0) {
-          io.push(param);
-          continue;
-        }
-        if (!fms[idx]) {
-          const idxS = idx === 1 ? '' : idx;
-          const { osc, freq } = fm(param, value[`fmh${idxS}`] ?? 1, value[`fmwave${idxS}`] ?? 'sine');
-          toStop.push(osc);
-          const toCleanup = [osc]; // nodes we want to cleanup after oscillator `stop`
-          const adsr = ['attack', 'decay', 'sustain', 'release'].map((s) => value[`fm${s}${idxS}`]);
-          let output = osc;
-          if (adsr.some((v) => v !== undefined)) {
-            const envGain = ac.createGain();
-            const [attack, decay, sustain, release] = getADSRValues(adsr);
-            const holdEnd = begin + value.duration;
-            const fmEnvelopeType = value[`fmenv${idxS}`] ?? 'exp';
-            getParamADSR(
-              envGain.gain,
-              attack,
-              decay,
-              sustain,
-              release,
-              0,
-              1,
-              begin,
-              holdEnd,
-              fmEnvelopeType === 'exp' ? 'exponential' : 'linear',
-            );
-            toCleanup.push(envGain);
-            output = osc.connect(envGain);
-          }
-          fms[idx] = { input: osc.frequency, output, freq, osc, toCleanup };
-        }
-        const { input, output, freq, osc, toCleanup } = fms[idx];
-        const g = gainNode(amt * freq);
-        io.push(isMod ? output.connect(g) : input);
-        cleanupOnEnd(osc, [...toCleanup, g]);
-      }
-      if (!io[1]) {
-        logger(
-          `[superdough] control ${control} failed to connect FM ${i} to target ${j} due to missing frequency parameter (likely because fm${j} is noise)`,
-          'warning',
-        );
-        continue;
-      }
-      io[0].connect(io[1]);
+  const {
+    fmh: fmHarmonicity = 1,
+    fmi: fmModulationIndex,
+    fmenv: fmEnvelopeType = 'exp',
+    fmattack: fmAttack,
+    fmdecay: fmDecay,
+    fmsustain: fmSustain,
+    fmrelease: fmRelease,
+    fmvelocity: fmVelocity,
+    fmwave: fmWaveform = 'sine',
+    duration,
+  } = value;
+  let modulator;
+  let stop = () => {};
+
+  if (fmModulationIndex) {
+    const ac = getAudioContext();
+    const envGain = ac.createGain();
+    const fmmod = fm(param, fmHarmonicity, fmModulationIndex, fmWaveform);
+
+    modulator = fmmod.node;
+    stop = fmmod.stop;
+    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].some((v) => v !== undefined)) {
+      // no envelope by default
+      modulator.connect(param);
+    } else {
+      const [attack, decay, sustain, release] = getADSRValues([fmAttack, fmDecay, fmSustain, fmRelease]);
+      const holdEnd = begin + duration;
+      getParamADSR(
+        envGain.gain,
+        attack,
+        decay,
+        sustain,
+        release,
+        0,
+        1,
+        begin,
+        holdEnd,
+        fmEnvelopeType === 'exp' ? 'exponential' : 'linear',
+      );
+      modulator.connect(envGain);
+      envGain.connect(param);
    }
  }
-  return {
-    stop: (t) => toStop.forEach((m) => m?.stop(t)),
-  };
+  return { stop };
 }

 // Saturation curves
@@ -553,7 +479,7 @@ export const getDistortion = (distort, postgain, algorithm) => {
 };

 export const getFrequencyFromValue = (value, defaultNote = 36) => {
-  let { note, freq, octave = 0 } = value;
+  let { note, freq } = value;
  note = note || defaultNote;
  if (typeof note === 'string') {
    note = noteToMidi(note); // e.g. c3 => 48
@@ -562,62 +488,14 @@ export const getFrequencyFromValue = (value, defaultNote = 36) => {
  if (!freq && typeof note === 'number') {
    freq = midiToFreq(note); // + 48);
  }
-  freq *= Math.pow(2, octave);
+
  return Number(freq);
 };

-// This helper should be used instead of the `node.onended = callback` pattern
-// It adds a mechanism to help minimize gc retention
-export const onceEnded = (node, callback) => {
-  const onended = callback;
-  node.onended = function cleanup() {
-    onended && onended();
-    this.onended = null;
-  };
-};
-
-export const releaseAudioNode = (node) => {
-  if (node == null) return;
-
-  // check we received an AudioNode
-  if (!(node instanceof AudioNode)) {
-    throw new Error('releaseAudioNode can only release an AudioNode');
+export const destroyAudioWorkletNode = (node) => {
+  if (node == null) {
+    return;
  }
-
-  // https://developer.mozilla.org/en-US/docs/Web/API/AudioNode/disconnect
  node.disconnect();
-
-  // make sure all AudioScheduledSourceNodes are in a stopped state
-  // https://developer.mozilla.org/en-US/docs/Web/API/AudioScheduledSourceNode
-  if (node instanceof AudioScheduledSourceNode) {
-    if (node.onended && node.onended.name !== 'cleanup') {
-      logger(
-        `[superdough] Deprecation warning: it seems your code path is setting 'node.onended = callback' instead of using the onceEnded helper`,
-      );
-    }
-    try {
-      node.stop();
-    } catch (e) {
-      // At the stage, `start` was not called on the node
-      // but an `onended` callback releasing resources may exist
-      // and we want it to fire :
-      // - we force a start/stop cycle so that `onended` gets called
-      // - we `lock` the node so that no-one can start it
-      node.start(node.context.currentTime + 5); // will never happen
-      node.stop();
-    }
-  }
-
-  // https://www.w3.org/TR/webaudio-1.1/#AudioNode-actively-processing
-  // An AudioWorkletNode is actively processing when its AudioWorkletProcessor's [[callable process]]
-  // returns true and either its active source flag is true or
-  // any AudioNode connected to one of its inputs is actively processing.
-  if (node instanceof AudioWorkletNode) {
-    node.parameters.get('end')?.setValueAtTime(0, 0);
-  }
-};
-
-// Once the `anchor` node has ended, release all nodes in `toCleanup`
-export const cleanupOnEnd = (anchor, toCleanup) => {
-  onceEnded(anchor, () => toCleanup.forEach((n) => releaseAudioNode(n)));
+  node.parameters.get('end')?.setValueAtTime(0, 0);
 };
@@ -65,9 +65,8 @@ export function getNoiseOscillator(type = 'white', t, density = 0.02) {
 export function getNoiseMix(inputNode, wet, t) {
  const noiseOscillator = getNoiseOscillator('pink', t);
  const noiseMix = drywet(inputNode, noiseOscillator.node, wet);
-  noiseOscillator.node.onended = () => noiseMix.onended();
  return {
-    node: noiseMix.node,
+    node: noiseMix,
    stop: (time) => noiseOscillator?.stop(time),
  };
 }
@@ -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();

@@ -1,14 +1,7 @@
-import { getBaseURL, getCommonSampleInfo } from './util.mjs';
+import { getCommonSampleInfo } from './util.mjs';
 import { registerSound, registerWaveTable } from './index.mjs';
 import { getAudioContext } from './audioContext.mjs';
-import {
-  getADSRValues,
-  getParamADSR,
-  getPitchEnvelope,
-  getVibratoOscillator,
-  onceEnded,
-  releaseAudioNode,
-} from './helpers.mjs';
+import { getADSRValues, getParamADSR, getPitchEnvelope, getVibratoOscillator } from './helpers.mjs';
 import { logger } from './logger.mjs';

 const bufferCache = {}; // string: Promise<ArrayBuffer>
@@ -218,7 +211,7 @@ export async function fetchSampleMap(url) {
    // not a browser
    return;
  }
-  const base = getBaseURL(url);
+  const base = url.split('/').slice(0, -1).join('/');
  if (typeof fetch === 'undefined') {
    // skip fetch when in node / testing
    return;
@@ -243,6 +236,12 @@ export async function fetchSampleMap(url) {
 *  sd: '808sd/SD0010.WAV'
 *  }, 'https://raw.githubusercontent.com/tidalcycles/Dirt-Samples/master/');
 * s("[bd ~]*2, [~ hh]*2, ~ sd")
+ * @example
+ * samples('shabda:noise,chimp:2')
+ * s("noise <chimp:0*2 chimp:1>")
+ * @example
+ * samples('shabda/speech/fr-FR/f:chocolat')
+ * s("chocolat*4")
 */

 export const samples = async (sampleMap, baseUrl = sampleMap._base || '', options = {}) => {
@@ -287,16 +286,14 @@ export async function onTriggerSample(t, value, onended, bank, resolveUrl) {

  const { bufferSource, sliceDuration, offset } = await getSampleBufferSource(value, bank, resolveUrl);

-  if (!bufferSource) {
-    logger(`[sampler] could not load "${s}:${n}"`, 'error');
+  // asny stuff above took too long?
+  if (ac.currentTime > t) {
+    logger(`[sampler] still loading sound "${s}:${n}"`, 'highlight');
+    // console.warn('sample still loading:', s, n);
    return;
  }
-
-  // async stuff above took too long?
-  if (ac.currentTime > t) {
-    logger(`[sampler] loading sound "${s}:${n}" took too long`, 'highlight');
-    // AudioBufferSourceNode will never be used. discard it
-    releaseAudioNode(bufferSource);
+  if (!bufferSource) {
+    logger(`[sampler] could not load "${s}:${n}"`, 'error');
    return;
  }

@@ -322,13 +319,13 @@ export async function onTriggerSample(t, value, onended, bank, resolveUrl) {

  const out = ac.createGain(); // we need a separate gain for the cutgroups because firefox...
  node.connect(out);
-  onceEnded(bufferSource, function () {
+  bufferSource.onended = function () {
    bufferSource.disconnect();
    vibratoOscillator?.stop();
    node.disconnect();
    out.disconnect();
    onended();
-  });
+  };
  let envEnd = holdEnd + release + 0.01;
  bufferSource.stop(envEnd);
  const stop = (endTime) => {
@@ -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,
@@ -263,8 +268,8 @@ let audioReady;
 export async function initAudioOnFirstClick(options) {
  if (!audioReady) {
    audioReady = new Promise((resolve) => {
-      document.addEventListener('mousedown', async function listener() {
-        document.removeEventListener('mousedown', listener);
+      document.addEventListener('click', async function listener() {
+        document.removeEventListener('click', listener);
        await initAudio(options);
        resolve();
      });
@@ -274,7 +279,7 @@ export async function initAudioOnFirstClick(options) {
 }

 let controller;
-export function getSuperdoughAudioController() {
+function getSuperdoughAudioController() {
  if (controller == null) {
    controller = new SuperdoughAudioController(getAudioContext());
  }
@@ -287,7 +292,7 @@ export function connectToDestination(input, channels) {

 function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000, sweep = 2000) {
  const ac = getAudioContext();
-  const lfo = getLfo(ac, time, end, { frequency, depth: sweep * 2 });
+  const lfoGain = getLfo(ac, time, end, { frequency, depth: sweep * 2 });

  //filters
  const numStages = 2; //num of filters in series
@@ -300,14 +305,14 @@ function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000
    filter.frequency.value = centerFrequency + fOffset;
    filter.Q.value = 2 - Math.min(Math.max(depth * 2, 0), 1.9);

-    lfo.connect(filter.detune);
+    lfoGain.connect(filter.detune);
    fOffset += 282;
    if (i > 0) {
      filterChain[i - 1].connect(filter);
    }
    filterChain.push(filter);
  }
-  return { phaser: filterChain[filterChain.length - 1], lfo };
+  return filterChain[filterChain.length - 1];
 }

 function getFilterType(ftype) {
@@ -410,10 +415,35 @@ 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,
+    phaserrate: phaser,
    phaserdepth = getDefaultValue('phaserdepth'),
    phasersweep,
    phasercenter,
@@ -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,105 +565,60 @@ 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',
-      depthfrequency: 'lpdepthfrequency',
-      shape: 'lpshape',
-      dcoffset: 'lpdc',
-      skew: 'lpskew',
-    };
-    const lpParams = pickAndRename(value, lpMap);
-    lpParams.type = 'lowpass';
-    const lp = () => createFilter(ac, t, end, lpParams, cps, cycle);
-    const { filter: lpf1, lfo: lfo1 } = lp();
-    chain.push(lpf1);
-    lfo1 && audioNodes.push(lfo1);
+  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') {
-      const { filter: lpf2, lfo: lfo2 } = lp();
-      chain.push(lpf2);
-      lfo2 && audioNodes.push(lfo2);
+      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',
-      depthfrequency: 'hpdepthfrequency',
-      shape: 'hpshape',
-      dcoffset: 'hpdc',
-      skew: 'hpskew',
-    };
-    const hpParams = pickAndRename(value, hpMap);
-    hpParams.type = 'highpass';
-    const hp = () => createFilter(ac, t, end, hpParams, cps, cycle);
-    const { filter: hpf1, lfo: lfo1 } = hp();
-    chain.push(hpf1);
-    lfo1 && audioNodes.push(lfo1);
+  if (hcutoff !== undefined) {
+    let hp = () =>
+      createFilter(
+        ac,
+        'highpass',
+        hcutoff,
+        hresonance,
+        hpattack,
+        hpdecay,
+        hpsustain,
+        hprelease,
+        hpenv,
+        t,
+        end,
+        fanchor,
+      );
+    chain.push(hp());
    if (ftype === '24db') {
-      const { filter: hpf2, lfo: lfo2 } = hp();
-      chain.push(hpf2);
-      lfo2 && audioNodes.push(lfo2);
+      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',
-      depthfrequency: 'bpdepthfrequency',
-      shape: 'bpshape',
-      dcoffset: 'bpdc',
-      skew: 'bpskew',
-    };
-    const bpParams = pickAndRename(value, bpMap);
-    bpParams.type = 'bandpass';
-    const bp = () => createFilter(ac, t, end, bpParams, cps, cycle);
-    const { filter: bpf1, lfo: lfo1 } = bp();
-    chain.push(bpf1);
-    lfo1 && audioNodes.push(lfo1);
+  if (bandf !== undefined) {
+    let bp = () =>
+      createFilter(ac, 'bandpass', bandf, bandq, bpattack, bpdecay, bpsustain, bprelease, bpenv, t, end, fanchor);
+    chain.push(bp());
    if (ftype === '24db') {
-      const { filter: bpf2, lfo: lfo2 } = bp();
-      chain.push(bpf2);
-      lfo2 && audioNodes.push(lfo2);
+      chain.push(bp());
    }
  }

@@ -680,7 +665,6 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      curve: 1.5,
    });
    lfo.connect(amGain.gain);
-    audioNodes.push(lfo);
    chain.push(amGain);
  }

@@ -696,10 +680,9 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    chain.push(panner);
  }
  // phaser
-  if (phaserrate !== undefined && phaserdepth > 0) {
-    const { phaser, lfo } = getPhaser(t, endWithRelease, phaserrate, phaserdepth, phasercenter, phasersweep);
-    audioNodes.push(lfo);
-    chain.push(phaser);
+  if (phaser !== undefined && phaserdepth > 0) {
+    const phaserFX = getPhaser(t, endWithRelease, phaser, phaserdepth, phasercenter, phasersweep);
+    chain.push(phaserFX);
  }

  // last gain
@@ -709,8 +692,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  // delay
  if (delay > 0 && delaytime > 0 && delayfeedback > 0) {
    orbitBus.getDelay(delaytime, delayfeedback, t);
-    const send = orbitBus.sendDelay(post, delay);
-    audioNodes.push(send);
+    orbitBus.sendDelay(post, delay);
  }
  // reverb
  if (room > 0) {
@@ -726,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,11 +78,11 @@ export class Orbit {
    return this.reverbNode;
  }
  sendReverb(node, amount) {
-    return effectSend(node, this.reverbNode, amount);
+    effectSend(node, this.reverbNode, amount);
  }

  sendDelay(node, amount) {
-    return effectSend(node, this.delayNode, amount);
+    effectSend(node, this.delayNode, amount);
  }

  duck(t, onsettime = 0, attacktime = 0.1, depth = 1) {
@@ -3,6 +3,7 @@ import { registerSound, soundMap } from './superdough.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import {
  applyFM,
+  destroyAudioWorkletNode,
  gainNode,
  getADSRValues,
  getFrequencyFromValue,
@@ -12,13 +13,11 @@ import {
  getVibratoOscillator,
  getWorklet,
  noises,
-  releaseAudioNode,
  webAudioTimeout,
 } from './helpers.mjs';
-import { logger } from './logger.mjs';
 import { getNoiseMix, getNoiseOscillator } from './noise.mjs';

-const waveforms = ['triangle', 'square', 'sawtooth', 'sine', 'user'];
+const waveforms = ['triangle', 'square', 'sawtooth', 'sine'];
 const waveformAliases = [
  ['tri', 'triangle'],
  ['sqr', 'square'],
@@ -48,17 +47,19 @@ export function registerSynthSounds() {
          [0.001, 0.05, 0.6, 0.01],
        );

+        let sound = getOscillator(s, t, value);
+        let { node: o, stop, triggerRelease } = sound;
+
        // turn down
        const g = gainNode(0.3);

-        let sound = getOscillator(s, t, value, () => {
+        const { duration } = value;
+
+        o.onended = () => {
+          o.disconnect();
          g.disconnect();
          onended();
-        });
-
-        let { node: o, stop, triggerRelease } = sound;
-
-        const { duration } = value;
+        };

        const envGain = gainNode(1);
        let node = o.connect(g).connect(envGain);
@@ -192,7 +193,8 @@ export function registerSynthSounds() {
      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          releaseAudioNode(o);
+          destroyAudioWorkletNode(o);
+          envGain.disconnect();
          onended();
          fm?.stop();
          vibratoOscillator?.stop();
@@ -269,7 +271,8 @@ export function registerSynthSounds() {
      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          releaseAudioNode(o);
+          destroyAudioWorkletNode(o);
+          envGain.disconnect();
          onended();
        },
        begin,
@@ -342,8 +345,9 @@ export function registerSynthSounds() {
      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          releaseAudioNode(o);
-          releaseAudioNode(lfo);
+          destroyAudioWorkletNode(o);
+          destroyAudioWorkletNode(lfo);
+          envGain.disconnect();
          onended();
          fm?.stop();
          vibratoOscillator?.stop();
@@ -410,13 +414,9 @@ export function registerSynthSounds() {
  waveformAliases.forEach(([alias, actual]) => soundMap.set({ ...soundMap.get(), [alias]: soundMap.get()[actual] }));
 }

-const PI2 = 2 * Math.PI;
-export function waveformN(partials, phases, type) {
-  const isList = typeof partials === 'object';
-  partials = isList ? partials : new Float32Array(partials).fill(1);
-  const len = partials.length;
-  const real = new Float32Array(len + 1);
-  const imag = new Float32Array(len + 1);
+export function waveformN(partials, type) {
+  const real = new Float32Array(partials + 1);
+  const imag = new Float32Array(partials + 1);
  const ac = getAudioContext();
  const osc = ac.createOscillator();

@@ -424,29 +424,20 @@ export function waveformN(partials, phases, type) {
    sawtooth: (n) => [0, -1 / n],
    square: (n) => [0, n % 2 === 0 ? 0 : 1 / n],
    triangle: (n) => [n % 2 === 0 ? 0 : 1 / (n * n), 0],
-    user: (_n) => [0, 1],
  };

  if (!terms[type]) {
    throw new Error(`unknown wave type ${type}`);
  }

-  for (let n = 0; n < len; n++) {
-    const mag = partials[n];
-    const [r, i] = terms[type](n + 1); // we skip n === 0 as this is dc offset
-    const phase = phases?.[n] ?? 0;
-    // Scale by `partials`
-    let R = r * mag;
-    let I = i * mag;
-    // Apply rotation by the phase
-    if (phase !== 0) {
-      const c = Math.cos(PI2 * phase);
-      const s = Math.sin(PI2 * phase);
-      R = c * R - s * I;
-      I = s * R + c * I;
-    }
-    real[n + 1] = R;
-    imag[n + 1] = I;
+  real[0] = 0; // dc offset
+  imag[0] = 0;
+  let n = 1;
+  while (n <= partials) {
+    const [r, i] = terms[type](n);
+    real[n] = r;
+    imag[n] = i;
+    n++;
  }

  const wave = ac.createPeriodicWave(real, imag);
@@ -455,28 +446,21 @@ export function waveformN(partials, phases, type) {
 }

 // expects one of waveforms as s
-export function getOscillator(s, t, value, onended) {
-  const { duration, noise = 0 } = value;
-  const partials = value.partials ?? value.n;
+export function getOscillator(s, t, value) {
+  let { n: partials, duration, noise = 0 } = value;
  let o;
-  if (s === 'user' && !partials) {
-    logger(
-      `[superdough] Synth 'user' was selected, but partials not specified. Defaulting to triangle. Use pat.partials to setup custom waveform`,
-    );
-    s = 'triangle';
-  }
-  s = s === 'user' && !partials ? 'triangle' : s;
  // If no partials are given, use stock waveforms
-  if (!partials || partials?.length === 0 || s === 'sine') {
+  if (!partials || s === 'sine') {
    o = getAudioContext().createOscillator();
    o.type = s || 'triangle';
  }
  // generate custom waveform if partials are given
  else {
-    o = waveformN(partials, value.phases, s);
+    o = waveformN(partials, s);
  }
  // set frequency
  o.frequency.value = getFrequencyFromValue(value);
+  o.start(t);

  let vibratoOscillator = getVibratoOscillator(o.detune, value, t);

@@ -489,13 +473,6 @@ export function getOscillator(s, t, value, onended) {
    noiseMix = getNoiseMix(o, noise, t);
  }

-  o.onended = () => {
-    noiseMix || o.disconnect();
-    noiseMix?.node.disconnect();
-    onended();
-  };
-  o.start(t);
-
  return {
    node: noiseMix?.node || o,
    stop: (time) => {
@@ -109,18 +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]]));
-};
-
-export const getBaseURL = (url) => {
-  try {
-    // For real URLs
-    return new URL('.', new URL(url)).href.replace(/\/$/, ''); // removes trailing slash
-  } catch {
-    // For pseudo URLS
-    return url.split('/').slice(0, -1).join('/');
-  }
-};
@@ -45,8 +45,7 @@ if (typeof GainNode !== 'undefined') {
        throw new Error('vowel: unknown vowel ' + letter);
      }
      const { gains, qs, freqs } = vowelFormant[letter];
-      this.makeupGain = ac.createGain();
-      this.audioNodes = [];
+      const makeupGain = ac.createGain();
      for (let i = 0; i < 5; i++) {
        const gain = ac.createGain();
        gain.gain.value = gains[i];
@@ -54,25 +53,14 @@ if (typeof GainNode !== 'undefined') {
        filter.type = 'bandpass';
        filter.Q.value = qs[i];
        filter.frequency.value = freqs[i];
-        super.connect(filter);
+        this.connect(filter);
        filter.connect(gain);
-        this.audioNodes.push(filter);
-        gain.connect(this.makeupGain);
-        this.audioNodes.push(gain);
+        gain.connect(makeupGain);
      }
-      this.makeupGain.gain.value = 8; // how much makeup gain to add?
+      makeupGain.gain.value = 8; // how much makeup gain to add?
+      this.connect = (target) => makeupGain.connect(target);
      return this;
    }
-    connect(target) {
-      this.makeupGain.connect(target);
-    }
-    disconnect() {
-      this.makeupGain.disconnect();
-      this.audioNodes.forEach((n) => n.disconnect());
-      super.disconnect();
-      this.makeupGain = null;
-      this.audioNodes = null;
-    }
  }

  AudioContext.prototype.createVowelFilter = function (letter) {
@@ -1,15 +1,15 @@
 import { getAudioContext, registerSound } from './index.mjs';
-import { getBaseURL, getCommonSampleInfo } from './util.mjs';
+import { getCommonSampleInfo } from './util.mjs';
 import {
  applyFM,
  applyParameterModulators,
+  destroyAudioWorkletNode,
  getADSRValues,
  getFrequencyFromValue,
  getParamADSR,
  getPitchEnvelope,
  getVibratoOscillator,
  getWorklet,
-  releaseAudioNode,
  webAudioTimeout,
 } from './helpers.mjs';
 import { logger } from './logger.mjs';
@@ -190,7 +190,6 @@ export const tables = async (url, frameLen, json, options = {}) => {
  if (url.startsWith('local:')) {
    url = `http://localhost:5432`;
  }
-  const base = getBaseURL(url);
  if (typeof fetch !== 'function') {
    // not a browser
    return;
@@ -201,7 +200,7 @@ export const tables = async (url, frameLen, json, options = {}) => {
  }
  return fetch(url)
    .then((res) => res.json())
-    .then((json) => _processTables(json, base, frameLen, options))
+    .then((json) => _processTables(json, url, frameLen, options))
    .catch((error) => {
      console.error(error);
      throw new Error(`error loading "${url}"`);
@@ -319,9 +318,10 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
  const timeoutNode = webAudioTimeout(
    ac,
    () => {
-      releaseAudioNode(source);
+      destroyAudioWorkletNode(source);
      vibratoOscillator?.stop();
      fm?.stop();
+      node.disconnect();
      wtPosModulators?.disconnect();
      wtWarpModulators?.disconnect();
      onended();
@@ -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,50 +508,51 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        name: 'voices',
        defaultValue: 5,
        min: 1,
-        automationRate: 'k-rate',
      },
    ];
  }
  process(_input, outputs, params) {
-    if (currentTime >= params.end[0]) {
-      // should terminate
-      return false;
-    }
    if (currentTime <= params.begin[0]) {
-      // keep alive
      return true;
    }
+    if (currentTime >= params.end[0]) {
+      // 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 = frac(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
-        const tmp = gainL;
-        gainL = gainR;
-        gainR = tmp;
+        this.phase[n] = wrapPhase(this.phase[n] + dt);
      }
    }
    return true;
@@ -558,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 {
@@ -585,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();
@@ -601,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;
@@ -648,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;
@@ -660,6 +674,7 @@ class PhaseVocoderProcessor extends OLAProcessor {
        i++;
        continue;
      }
+
      this.peakIndexes[this.nbPeaks] = i;
      this.nbPeaks++;
      i += 2;
@@ -670,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;
      }
@@ -721,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
@@ -781,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
@@ -797,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
@@ -827,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));
  },
 };
@@ -851,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);
@@ -884,7 +910,7 @@ class ByteBeatProcessor extends AudioWorkletProcessor {

      this.func = getByteBeatFunc(codeText);
    };
-    this.initialOffset = 0;
+    this.initialOffset = null;
    this.t = null;
    this.func = null;
  }
@@ -931,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
@@ -952,102 +977,6 @@ class ByteBeatProcessor extends AudioWorkletProcessor {

 registerProcessor('byte-beat-processor', ByteBeatProcessor);

-class EnvelopeProcessor extends AudioWorkletProcessor {
-  static get parameterDescriptors() {
-    return [
-      { name: 'begin', defaultValue: 0 },
-      { name: 'end', defaultValue: 0 },
-      { name: 'attack', defaultValue: 0.005, minValue: 0 },
-      { name: 'decay', defaultValue: 0.14, minValue: 0 },
-      { name: 'sustain', defaultValue: 0, minValue: 0, maxValue: 1 },
-      { name: 'release', defaultValue: 0.1, minValue: 0 },
-      { name: 'attackCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
-      { name: 'decayCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
-      { name: 'releaseCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
-      { name: 'peak', defaultValue: 1 },
-      { name: 'retrigger', defaultValue: 1, minValue: 0, maxValue: 1 },
-    ];
-  }
-
-  constructor() {
-    super();
-    this.val = 0;
-    this.segIdx = 0;
-    this.state = 0;
-    this.beginTime = 0;
-    this.endTime = 0;
-    this.attackStart = 0;
-  }
-
-  _warp(phase, curvature, strength = 8) {
-    if (phase === 0 || phase === 1) return phase; // fast exit
-    if (curvature > 0) {
-      // snappier
-      const exp = 1 + strength * curvature;
-      return 1 - Math.pow(1 - phase, exp);
-    } else {
-      // more calm
-      const exp = 1 - strength * curvature;
-      return Math.pow(phase, exp);
-    }
-  }
-
-  _advance(start, target, time, curvature) {
-    if (time === 0 || start === target) {
-      this.val = target;
-    } else {
-      // We compute our progress through this section of the envelope in time
-      // as a `phase` value, which is warped by the curvature, and then used
-      // to compute the value of the envelope at that time
-      const phase = Math.min(1, (currentTime - this.beginTime) / time);
-      const phaseWarped = this._warp(phase, curvature);
-      this.val = start + (target - start) * phaseWarped;
-    }
-  }
-
-  process(_inputs, outputs, params) {
-    const out = outputs[0][0];
-    if (!out) return true;
-    const begin = pv(params.begin, 0);
-    const retrigger = pv(params.retrigger, 0) >= 0.5; // convert to bool
-    if (begin !== this.beginTime && (this.state === 0 || retrigger)) {
-      // triggered
-      this.beginTime = begin;
-      this.state = 1;
-      this.endTime = pv(params.end, 0);
-      this.attackStart = this.val;
-    }
-    const susTime = this.endTime - this.beginTime;
-    for (let i = 0; i < out.length; i++) {
-      const attack = pv(params.attack, i);
-      const decay = pv(params.decay, i);
-      const sustain = pv(params.sustain, i);
-      const release = pv(params.release, i);
-      const aCurve = pv(params.attackCurve, i);
-      const dCurve = pv(params.decayCurve, i);
-      const rCurve = pv(params.releaseCurve, i);
-      const peak = pv(params.peak, i);
-      const states = [
-        { time: Number.POSITIVE_INFINITY, start: 0, target: 0 }, // idle
-        { time: attack, start: this.attackStart, target: 1, curve: aCurve },
-        { time: attack + decay, start: 1, target: sustain, curve: dCurve },
-        { time: susTime, start: sustain, target: sustain },
-        { time: susTime + release, start: sustain, target: 0, curve: rCurve },
-      ];
-      let { time, start, target, curve } = states[this.state];
-      this._advance(start, target, time, curve);
-      while (currentTime - this.beginTime >= time) {
-        this.state = (this.state + 1) % states.length;
-        time = states[this.state].time;
-      }
-      out[i] = this.val * peak;
-    }
-    return true;
-  }
-}
-
-registerProcessor('envelope-processor', EnvelopeProcessor);
-
 export const WarpMode = Object.freeze({
  NONE: 0,
  ASYM: 1,
@@ -1127,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 },
    ];
@@ -1138,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 || {};
@@ -1174,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) {
@@ -1200,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: {
@@ -1209,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);
@@ -1220,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;
@@ -1236,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);
@@ -1245,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);
@@ -1273,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);
      }
@@ -1286,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: {
@@ -1333,16 +1269,16 @@ 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);
      const tablePos = clamp(pv(parameters.position, i), 0, 1);
      const idx = tablePos * (this.numFrames - 1);
      const fIdx = idx | 0;
-      const interpT = idx - fIdx;
+      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);
@@ -1350,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;
@@ -1360,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];

@@ -1370,13 +1305,13 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        const ph = this._warpPhase(this.phase[n], warpAmount, warpMode);
        const s0 = this._sampleFrame(table[fIdx], ph);
        const s1 = this._sampleFrame(table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
-        let s = lerp(s0, s1, interpT);
+        let s = s0 + (s1 - s0) * frac;
        if (warpMode === WarpMode.FLIP && this.phase[n] < warpAmount) {
          s = -s;
        }
        outL[i] += s * gainL * normalizer;
        outR[i] += s * gainR * normalizer;
-        this.phase[n] = frac(this.phase[n] + dPhase);
+        this.phase[n] = wrapPhase(this.phase[n] + dPhase);
      }
    }
    return true;
@@ -3,7 +3,6 @@ import { midiToFreq, noteToMidi } from './util.mjs';
 import { registerSound } from './superdough.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import { buildSamples } from './zzfx_fork.mjs';
-import { onceEnded, releaseAudioNode } from './helpers.mjs';

 export const getZZFX = (value, t) => {
  let {
@@ -84,10 +83,10 @@ export function registerZZFXSounds() {
      wave,
      (t, value, onended) => {
        const { node: o } = getZZFX({ s: wave, ...value }, t);
-        onceEnded(o, () => {
-          releaseAudioNode(o);
+        o.onended = () => {
+          o.disconnect();
          onended();
-        });
+        };
        return {
          node: o,
          stop: () => {},
@@ -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"
  }
 }
@@ -5,16 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
 */

 import { Note, Interval, Scale } from '@tonaljs/tonal';
-import {
-  _mod,
-  errorLogger,
-  getAccidentalsOffset,
-  isNote,
-  logger,
-  noteToMidi,
-  register,
-  removeUndefineds,
-} from '@strudel/core';
+import { register, _mod, logger, isNote, noteToMidi, removeUndefineds, getAccidentalsOffset } from '@strudel/core';
 import { stepInNamedScale, nearestNumberIndex } from './tonleiter.mjs';

 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
@@ -238,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
@@ -262,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',
@@ -303,7 +289,7 @@ export const scale = register(
            }
            if (offset != 0) scaleNote = Note.transpose(scaleNote, Interval.fromSemitones(offset));
          } catch (err) {
-            errorLogger(err, 'tonal');
+            logger(`[tonal] ${err.message}`, 'error');
            return; // will be removed
          }
        }
@@ -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){
@@ -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,9 +1,5 @@
 {
-  "name": "dbpatch",
  "dependencies": {
    "csv": "^6.3.11"
-  },
-  "engines": {
-    "node": ">=18.0.0"
  }
 }
@@ -1,14 +0,0 @@
-fetch('https://codeberg.org/api/v1/repos/uzu/strudel/pulls?state=closed&page=1')
-  .then((res) => res.json())
-  .then((pulls) => {
-    const r = pulls
-      .filter((pull) => pull.merged)
-      .sort((a, b) => new Date(b.closed_at) - new Date(a.closed_at))
-      .map((pull) => `${pull.closed_at} ${pull.title} by ${pull.user.login || '?'} in: [#${pull.number}](${pull.url}) `)
-      .join('\n');
-    console.log(r);
-  });
-
-/*
-
-  */
@@ -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")`}
 />

@@ -48,94 +48,28 @@ You can also use the `crackle` type to play some subtle noise crackles. You can

 ### Additive Synthesis

-Periodic waveforms are composed of several [harmonics](https://en.wikipedia.org/wiki/Harmonic) above a fundamental frequency, lying at integer multiples. These overtones combine to give a sound its unique timbral quality.
-
-For the basic waveforms, we offer you control over these harmonics with the `partials` and `phases` functions.
-
-#### Partials
-
-`partials` refers to the magnitude of each harmonic relative to the fundamental frequency. They can thus be used to spectrally filter these waveforms and tame some of their harshness:
+To tame the harsh sound of the basic waveforms, we can set the `n` control to limit the overtones of the waveform:

 <MiniRepl
  client:idle
  tune={`note("c2 <eb2 <g2 g1>>".fast(2))
 .sound("sawtooth")
-.partials([1, 1, "<1 0>", "<1 0>", "<1 0>", "<1 0>", "<1 0>"])
+.n("<32 16 8 4>")
 ._scope()`}
 />

-`partials` can also be used to construct _new_ waveforms not present in our basic set with the 'user' sound source:
+When the `n` control is used on a basic waveform, it defines the number of harmonic partials the sound is getting.
+You can also set `n` directly in mini notation with `sound`:

 <MiniRepl
  client:idle
  tune={`note("c2 <eb2 <g2 g1>>".fast(2))
-.sound("user")
-.partials([1, 0, 0.3, 0, 0.1, 0, 0, 0.3])
+.sound("sawtooth:<32 16 8 4>")
 ._scope()`}
 />

-We may algorithmically construct lists of magnitudes with Javascript code like:
-
-<MiniRepl
-  client:idle
-  tune={`const numHarmonics = 22;
-note("c2 <eb2 <g2 g1>>".fast(2))
-.sound("saw")
-.partials(new Array(numHarmonics).fill(1))
-._scope()`}
-/>
-
-which acts as a spectral filter. Or:
-
-<MiniRepl
-  client:idle
-  tune={`note("c2 <eb2 <g2 g1>>").fast(2)
-.sound("user")
-.partials(new Array(50).fill(0)
-  .map((_, idx) => ((-1) ** (idx + 1)) / (idx + 1))
-)
-._scope()`}
-/>
-
-which recovers a familiar waveform.
-
-`partials` is also compatible with pattern functions designed to produce lists, like `randL` or `binaryL`:
-
-<MiniRepl
-  client:idle
-  tune={`note("c2 <eb2 <g2 g1>>").fast(2)
-.sound("user")
-.partials(randL(10))
-._scope()`}
-/>
-
-and with lists _of_ patterns:
-
-<MiniRepl
-  client:idle
-  tune={`note("c2 <eb2 <g2 g1>>".fast(4))
-.sound("user")
-.partials([1, 0, "0 1", "0 1 0.3", rand])
-._scope()`}
-/>
-
-Note that the first value in the `partials` array controls the magnitude of the fundamental harmonic rather than the DC offset, which is fixed at 0.
-
-#### Phases
-
-Earlier, we mentioned that periodic waveforms can be broken into a set of harmonics above a fundamental frequency. Each harmonic has two defining properties: its magnitude (how loud it is) and its phase, which determines where in its cycle that sine wave starts when the waveform is built.
-
-These phases too can be declared in Strudel and can give your sounds interesting depth.
-
-<MiniRepl
-  client:idle
-  tune={`s("saw").seg(16).n(irand(12)).scale("F1:minor")
-  .penv(48).panchor(0).pdec(0.05)
-  .delay(0.25).room(0.25)
-  .compressor(-20).vib(0.3)
-  .partials(randL(200))
-  .phases(randL(200))`}
-/>
+Note for tidal users: `n` in tidal is synonymous to `note` for synths only.
+In strudel, this is not the case, where `n` will always change timbre, be it though different samples or different waveforms.

 ## Vibrato

@@ -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

@@ -8,34 +8,3 @@ export function ActionButton({ children, label, labelIsHidden, className, ...but
    </button>
  );
 }
-
-export function SpecialActionButton(props) {
-  const { className, ...buttonProps } = props;
-
-  return (
-    <ActionButton
-      {...buttonProps}
-      className={cx('bg-background p-2 max-w-[300px] rounded-md hover:opacity-50', className)}
-    />
-  );
-}
-
-export function ActionInput({ label, className, ...props }) {
-  return (
-    <label className={cx('inline-flex items-center cursor-pointer', className)}>
-      <input {...props} className="sr-only peer" />
-
-      <span className="inline-flex items-center peer-hover:opacity-50">{label}</span>
-    </label>
-  );
-}
-
-export function SpecialActionInput({ className, ...props }) {
-  return (
-    <ActionInput
-      {...props}
-      className={className}
-      label={<span className="bg-background p-2 max-w-[300px] rounded-md">{props.label}</span>}
-    />
-  );
-}
@@ -1,29 +0,0 @@
-import { errorLogger } from '@strudel/core';
-import { useSettings, storePrebakeScript } from '../../../settings.mjs';
-import { SpecialActionInput } from '../button/action-button';
-
-async function importScript(script) {
-  const reader = new FileReader();
-  reader.readAsText(script);
-
-  reader.onload = () => {
-    const text = reader.result;
-    storePrebakeScript(text);
-  };
-
-  reader.onerror = () => {
-    errorLogger(new Error('failed to import prebake script'), 'importScript');
-  };
-}
-export function ImportPrebakeScriptButton() {
-  const settings = useSettings();
-
-  return (
-    <SpecialActionInput
-      type="file"
-      label="import prebake script"
-      accept=".strudel"
-      onChange={(e) => importScript(e.target.files[0])}
-    />
-  );
-}
@@ -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);
@@ -7,8 +7,6 @@ import { AudioDeviceSelector } from './AudioDeviceSelector.jsx';
 import { AudioEngineTargetSelector } from './AudioEngineTargetSelector.jsx';
 import { confirmDialog } from '../../util.mjs';
 import { DEFAULT_MAX_POLYPHONY, setMaxPolyphony, setMultiChannelOrbits } from '@strudel/webaudio';
-import { ActionButton, SpecialActionButton } from '../button/action-button.jsx';
-import { ImportPrebakeScriptButton } from './ImportPrebakeScriptButton.jsx';

 function Checkbox({ label, value, onChange, disabled = false }) {
  return (
@@ -114,8 +112,6 @@ export function SettingsTab({ started }) {
    multiChannelOrbits,
    isTabIndentationEnabled,
    isMultiCursorEnabled,
-    patternAutoStart,
-    includePrebakeScriptInShare,
  } = useSettings();
  const shouldAlwaysSync = isUdels();
  const canChangeAudioDevice = AudioContext.prototype.setSinkId != null;
@@ -207,15 +203,6 @@ export function SettingsTab({ started }) {
          />
        </FormItem>
      </div>
-      <FormItem label="Prebake">
-        <ImportPrebakeScriptButton />
-        <Checkbox
-          label="Include prebake script in share"
-          onChange={(cbEvent) => settingsMap.setKey('includePrebakeScriptInShare', cbEvent.target.checked)}
-          value={includePrebakeScriptInShare}
-        />
-      </FormItem>
-
      <FormItem label="Keybindings">
        <ButtonGroup
          value={keybindings}
@@ -317,15 +304,11 @@ 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">
-        <SpecialActionButton
+        <button
+          className="bg-background p-2 max-w-[300px] rounded-md hover:opacity-50"
          onClick={() => {
            confirmDialog('Sure?').then((r) => {
              if (r) {
@@ -336,7 +319,7 @@ export function SettingsTab({ started }) {
          }}
        >
          restore default settings
-        </SpecialActionButton>
+        </button>
      </FormItem>
    </div>
  );
@@ -14,10 +14,6 @@ import { prebake } from '@src/repl/prebake.mjs';
 const getSamples = (samples) =>
  Array.isArray(samples) ? samples.length : typeof samples === 'object' ? Object.values(samples).length : 1;

-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 export function SoundsTab() {
  const sounds = useStore(soundMap);

@@ -60,21 +56,17 @@ export function SoundsTab() {

  // holds mutable ref to current triggered sound
  const trigRef = useRef();
-  const numRef = useRef(0);
+
+  // Used to cycle through sound previews on banks with multiple sounds
+  let soundPreviewIdx = 0;

  // stop current sound on mouseup
  useEvent('mouseup', () => {
-    const ref = trigRef.current;
+    const t = trigRef.current;
    trigRef.current = undefined;
-    ref?.stop?.(getAudioContext().currentTime + 0.01);
-  });
-  useEvent('keydown', (e) => {
-    if (!isNaN(Number(e.key))) {
-      numRef.current = Number(e.key);
-    }
-  });
-  useEvent('keyup', (e) => {
-    numRef.current = 0;
+    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">
@@ -125,35 +117,19 @@ export function SoundsTab() {
                const params = {
                  note: ['synth', 'soundfont'].includes(data.type) ? 'a3' : undefined,
                  s: name,
-                  n: numRef.current,
+                  n: soundPreviewIdx,
                  clip: 1,
                  release: 0.5,
                  sustain: 1,
                  duration: 0.5,
                };
+                soundPreviewIdx++;
+                const time = ctx.currentTime + 0.05;
                const onended = () => trigRef.current?.node?.disconnect();
-                // Attempt to play the sample and retry every 200ms until 10 attempts have been reached
-                let errMsg;
-                for (let attempt = 0; attempt < 10; attempt++) {
-                  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.05; // Give 50ms for loading
-                    const ref = await onTrigger(time, params, onended);
-                    trigRef.current = ref;
-                    if (ref?.node) {
-                      connectToDestination(ref.node);
-                      break;
-                    }
-                  } catch (err) {
-                    errMsg = err;
-                  }
-                  if (attempt == 9) {
-                    console.warn('Failed to trigger sound after 10 attempts' + (errMsg ? `: ${errMsg}` : ''));
-                  } else {
-                    await wait(200);
-                  }
-                }
+                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);
  });
 }

@@ -3,8 +3,6 @@ import { aliasBank, registerSynthSounds, registerZZFXSounds, samples } from '@st
 import { registerSamplesFromDB } from './idbutils.mjs';
 import './piano.mjs';
 import './files.mjs';
-import { settingsMap } from '@src/settings.mjs';
-import { evaluate } from '@strudel/transpiler';

 const { BASE_URL } = import.meta.env;
 const baseNoTrailing = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL;
@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th

 import { code2hash, getPerformanceTimeSeconds, logger, silence } from '@strudel/core';
 import { getDrawContext } from '@strudel/draw';
-import { evaluate, transpiler } from '@strudel/transpiler';
+import { transpiler } from '@strudel/transpiler';
 import {
  getAudioContextCurrentTime,
  webaudioOutput,
@@ -63,10 +63,11 @@ async function getModule(name) {
 const initialCode = `// LOADING`;

 export function useReplContext() {
-  const { isSyncEnabled, audioEngineTarget, prebakeScript, includePrebakeScriptInShare } = useSettings();
+  const { isSyncEnabled, audioEngineTarget } = useSettings();
  const shouldUseWebaudio = audioEngineTarget !== audioEngineTargets.osc;
  const defaultOutput = shouldUseWebaudio ? webaudioOutput : superdirtOutput;
  const getTime = shouldUseWebaudio ? getAudioContextCurrentTime : getPerformanceTimeSeconds;
+
  const init = useCallback(() => {
    const drawTime = [-2, 2];
    const drawContext = getDrawContext();
@@ -83,12 +84,7 @@ export function useReplContext() {
      pattern: silence,
      drawTime,
      drawContext,
-      prebake: async () =>
-        Promise.all([modulesLoading, presets]).then(() => {
-          if (prebakeScript?.length) {
-            return evaluate(prebakeScript ?? '');
-          }
-        }),
+      prebake: async () => Promise.all([modulesLoading, presets]),
      onUpdateState: (state) => {
        setReplState({ ...state });
      },
@@ -218,13 +214,7 @@ export function useReplContext() {
    editorRef.current.repl.evaluate(code);
  };

-  const handleShare = async () => {
-    let code = replState.code;
-    if (includePrebakeScriptInShare) {
-      code = prebakeScript + '\n' + code;
-    }
-    shareCode(code);
-  };
+  const handleShare = async () => shareCode(replState.code);
  const context = {
    started,
    pending,
@@ -1,10 +1,11 @@
-import { code2hash, evalScope, hash2code, logger } from '@strudel/core';
+import { evalScope, hash2code, logger } from '@strudel/core';
 import { settingPatterns } from '../settings.mjs';
 import { setVersionDefaults } from '@strudel/webaudio';
 import { getMetadata } from '../metadata_parser';
 import { isTauri } from '../tauri.mjs';
 import './Repl.css';
 import { createClient } from '@supabase/supabase-js';
+import { nanoid } from 'nanoid';
 import { writeText } from '@tauri-apps/plugin-clipboard-manager';
 import { $featuredPatterns /* , loadDBPatterns */ } from '@src/user_pattern_utils.mjs';

@@ -108,8 +109,9 @@ export function confirmDialog(msg) {
  });
 }

+let lastShared;
+
 //RIP due to SPAM
-// let lastShared;
 // export async function shareCode(codeToShare) {
 //   // const codeToShare = activeCode || code;
 //   if (lastShared === codeToShare) {
@@ -144,10 +146,9 @@ export function confirmDialog(msg) {
 //   });
 // }

-export async function shareCode(codeToShare) {
+export async function shareCode() {
  try {
-    const hash = '#' + code2hash(codeToShare);
-    const shareUrl = window.location.origin + window.location.pathname + hash;
+    const shareUrl = window.location.href;
    if (isTauri()) {
      await writeText(shareUrl);
    } else {
@@ -45,13 +45,11 @@ export const defaultSettings = {
  isPanelOpen: true,
  togglePanelTrigger: 'click', //click | hover
  userPatterns: '{}',
-  prebakeScript: '',
  audioEngineTarget: audioEngineTargets.webaudio,
  isButtonRowHidden: false,
  isCSSAnimationDisabled: false,
  maxPolyphony: 128,
  multiChannelOrbits: false,
-  includePrebakeScriptInShare: true,
 };

 let search = null;
@@ -98,12 +96,6 @@ export function useSettings() {
    isPanelOpen: parseBoolean(state.isPanelOpen),
    userPatterns: userPatterns,
    multiChannelOrbits: parseBoolean(state.multiChannelOrbits),
-    includePrebakeScriptInShare: parseBoolean(state.includePrebakeScriptInShare),
-    patternAutoStart: isUdels()
-      ? false
-      : state.patternAutoStart === undefined
-        ? true
-        : parseBoolean(state.patternAutoStart),
  };
 }

@@ -111,8 +103,6 @@ export const setActiveFooter = (tab) => settingsMap.setKey('activeFooter', tab);
 export const setPanelPinned = (bool) => settingsMap.setKey('isPanelPinned', bool);
 export const setIsPanelOpened = (bool) => settingsMap.setKey('isPanelOpen', bool);

-export const storePrebakeScript = (script) => settingsMap.setKey('prebakeScript', script);
-
 export const setIsZen = (active) => settingsMap.setKey('isZen', !!active);

 const patternSetting = (key) =>
Author	SHA1	Message	Date
froos	b48321a84c	Merge branch 'main' into nkymut/gamepad-pr	2025-10-28 23:32:28 +01:00
froos	827b659592	Merge branch 'main' into nkymut/gamepad-pr	2025-10-20 20:42:00 +02:00
nkymut	4553408b28	fix custom button mapping error	2025-05-21 01:18:44 +08:00
nkymut	42eb33440c	Improve logger messages and connection error handling	2025-05-21 01:00:58 +08:00
nkymut	87768198a0	fix import logger	2025-05-17 16:10:11 +08:00
nkymut	c24a87df48	codeformat	2025-05-17 16:06:06 +08:00
nkymut	2d63f36201	update gamepad documentation for button mapping	2025-05-17 16:03:57 +08:00
nkymut	43ac2d3d72	Add gamepad button mapping support	2025-05-17 15:41:48 +08:00