Merge branch 'main' into glossing/midin-channels

Merge pull request 'Feat: Transient shaper' (#1777 ) from glossing/transient-processor into main
Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1777
2026-07-22 13:13:10 -04:00 · 2025-12-07 21:23:57 +01:00 · 2025-12-07 21:23:42 +01:00 · 2025-12-07 20:29:50 +01:00 · 2025-12-07 20:29:39 +01:00 · 2025-12-07 13:28:57 -06:00
33 changed files with 1908 additions and 564 deletions
@@ -0,0 +1,88 @@
+# 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) 
@@ -72,6 +72,27 @@ 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 ':'.
@@ -380,12 +401,13 @@ export const { accelerate } = registerControl('accelerate');
 * Sets the velocity from 0 to 1. Is multiplied together with gain.
 *
 * @name velocity
+ * @synonyms vel
 * @example
 * s("hh*8")
 * .gain(".4!2 1 .4!2 1 .4 1")
 * .velocity(".4 1")
 */
-export const { velocity } = registerControl('velocity');
+export const { velocity, vel } = registerControl('velocity', 'vel');
 /**
 * Controls the gain by an exponential amount.
 *
@@ -435,6 +457,9 @@ 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
@@ -444,25 +469,40 @@ export const { attack, att } = registerControl('attack', 'att');
 * ._scope()
 *
 */
-export const { fmh } = registerControl(['fmh', 'fmi'], 'fmh');
+export const { fmh, fmh1, fmh2, fmh3, fmh4, fmh5, fmh6, fmh7, fmh8 } = registerMultiControl(['fmh', 'fmi'], 8, 'fmh');
+
 /**
 * Sets the Frequency Modulation of the synth.
 * Controls the modulation index, which defines the brightness of the sound.
 *
- * @name fm
+ * 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
 * @param {number | Pattern} brightness modulation index
- * @synonyms fmi
+ * @synonyms fm
 * @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, fm } = registerControl(['fmi', 'fmh'], 'fm');
+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');
+
 // 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
@@ -474,11 +514,19 @@ export const { fmi, fm } = registerControl(['fmi', 'fmh'], 'fm');
 * ._scope()
 *
 */
-export const { fmenv } = registerControl('fmenv');
+export const { fmenv, fmenv1, fmenv2, fmenv3, fmenv4, fmenv5, fmenv6, fmenv7, fmenv8 } = registerMultiControl(
+  'fmenv',
+  8,
+);
+
 /**
 * 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")
@@ -487,11 +535,33 @@ export const { fmenv } = registerControl('fmenv');
 * ._scope()
 *
 */
-export const { fmattack } = registerControl('fmattack');
+export const {
+  fmattack,
+  fmattack1,
+  fmattack2,
+  fmattack3,
+  fmattack4,
+  fmattack5,
+  fmattack6,
+  fmattack7,
+  fmattack8,
+  fmatt,
+  fmatt1,
+  fmatt2,
+  fmatt3,
+  fmatt4,
+  fmatt5,
+  fmatt6,
+  fmatt7,
+  fmatt8,
+} = registerMultiControl('fmattack', 8, 'fmatt');

 /**
 * 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
@@ -500,12 +570,19 @@ export const { fmattack } = registerControl('fmattack');
 * n("0 1 2 3".fast(4)).chord("<Dm Am F G>").voicing().s("sawtooth").fmwave("brown").fm(.6)
 *
 */
-export const { fmwave } = registerControl('fmwave');
+export const { fmwave, fmwave1, fmwave2, fmwave3, fmwave4, fmwave5, fmwave6, fmwave7, fmwave8 } = registerMultiControl(
+  'fmwave',
+  8,
+);

 /**
 * 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")
@@ -515,11 +592,35 @@ export const { fmwave } = registerControl('fmwave');
 * ._scope()
 *
 */
-export const { fmdecay } = registerControl('fmdecay');
+export const {
+  fmdecay,
+  fmdecay1,
+  fmdecay2,
+  fmdecay3,
+  fmdecay4,
+  fmdecay5,
+  fmdecay6,
+  fmdecay7,
+  fmdecay8,
+  fmdec,
+  fmdec1,
+  fmdec2,
+  fmdec3,
+  fmdec4,
+  fmdec5,
+  fmdec6,
+  fmdec7,
+  fmdec8,
+} = registerMultiControl('fmdecay', 8, 'fmdec');
+
 /**
 * 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")
@@ -529,10 +630,69 @@ export const { fmdecay } = registerControl('fmdecay');
 * ._scope()
 *
 */
-export const { fmsustain } = registerControl('fmsustain');
-// these are not really useful... skipping for now
-export const { fmrelease } = registerControl('fmrelease');
-export const { fmvelocity } = registerControl('fmvelocity');
+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}`);
+  }
+}

 /**
 * Select the sound bank to use. To be used together with `s`. The bank name (+ "_") will be prepended to the value of `s`.
@@ -1294,6 +1454,8 @@ export const { fanchor } = registerControl('fanchor');
 *
 * @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');

@@ -1302,6 +1464,8 @@ export const { lprate } = registerControl('lprate');
 *
 * @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');

@@ -1310,8 +1474,22 @@ export const { lpsync } = registerControl('lpsync');
 *
 * @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 lpdepthfreq
+ * @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, lpdepthfreq } = registerControl('lpdepthfrequency', 'lpdepthfreq');

 /**
 * Shape of the LFO for the lowpass filter
@@ -1361,6 +1539,18 @@ export const { bpsync } = registerControl('bpsync');
 */
 export const { bpdepth } = registerControl('bpdepth');

+/**
+ * Depth of the LFO for the bandpass filter, in HZ
+ *
+ * @name bpdepthfrequency
+ * @synonyms bpdepthfreq
+ * @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, bpdepthfreq } = registerControl('bpdepthfrequency', 'bpdepthfreq');
+
 /**
 * Shape of the LFO for the bandpass filter
 *
@@ -1409,6 +1599,18 @@ export const { hpsync } = registerControl('hpsync');
 */
 export const { hpdepth } = registerControl('hpdepth');

+/**
+ * Depth of the LFO for the hipass filter, in hz
+ *
+ * @name hpdepthfrequency
+ * @synonyms hpdepthfreq
+ * @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, hpdepthfreq } = registerControl('hpdepthfrequency', 'hpdepthfreq');
+
 /**
 * Shape of the LFO for the highpass filter
 *
@@ -1622,40 +1824,6 @@ export const { unison } = registerControl('unison');
 *
 */
 export const { spread } = registerControl('spread');
-
-/**
- * Controls how much the detune is concentrated outwards or inwards. A value of 0 will be
- * linear spacing of voices; -1 will be concentrated outwards (inverse power law); 1 will be concentrated inwards
- *
- * @name dpow
- * @synonyms detunepower
- * @param {number | Pattern} power between -1 and 1
- *
- */
-export const { dpow, detunepower } = registerControl('dpow', 'detunepower');
-
-/**
- * Controls how much the central voices are emphasized in a detuned oscillator. -1 will emphasize detuned voices;
- * 1 will emphasize central voices (i.e. either the raw frequency if `unison` is odd or the central two detuned frequencies
- * if it is even); 0 will be the default blending
- *
- * @name dblend
- * @synonyms detuneblend
- * @param {number | Pattern} blend between -1 and 1
- *
- */
-export const { dblend, detuneblend } = registerControl('dblend', 'detuneblend');
-
-/**
- * Sets the stacking mode of detuned oscillators
- *
- * @name dstack
- * @synonyms detunestack
- * @param {number | Pattern} mode mode index starting at 0
- *
- */
-export const { dstack, detunestack } = registerControl('dstack', 'detunestack');
-
 /**
 * Set dryness of reverb. See `room` and `size` for more information about reverb.
 *
@@ -1854,12 +2022,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").s('supersquare').octave("<3 4 5 6>").osc()
- * @superDirtOnly
+ * n("0,4,7").scale("F:minor").s('supersaw').octave("<0 1 2 3>")
 */
-export const { octave } = registerControl('octave');
+export const { octave, oct } = registerControl('octave', 'oct');

 // ['ophatdecay'],
 // TODO: example
@@ -1867,6 +2035,7 @@ export const { octave } = registerControl('octave');
 * 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(
@@ -1874,7 +2043,7 @@ export const { octave } = registerControl('octave');
 *   s("~ sd ~ sd").delay(.5).delaytime(.125).orbit(2)
 * )
 */
-export const { orbit } = registerControl('orbit');
+export const { orbit } = registerControl('orbit', 'o');
 // 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
@@ -2617,3 +2786,17 @@ export const scrub = register(
  },
  false,
 );
+
+/**
+ * Transient shaper. Gives independent control over the emphasis on transients
+ * and sustains
+ *
+ * @name transient
+ * @param {number | Pattern} attack Emphasis on transients; between -1 (deaccentuate) and 1 (accentuate)
+ * @param {number | Pattern} sustain Emphasis on the sustains; between -1 (deaccentuate) and 1 (accentuate)
+ * @example
+ * s("bd").transient("<-1 -0.5 0 0.5 1>")
+ * @example
+ * s("hh*16").bank("tr909").transient("<-1:1 1:-1>")
+ */
+export const { transient } = registerControl(['transient', 'transsustain']);
@@ -25,7 +25,7 @@ import {
  stringifyValues,
 } from './util.mjs';
 import drawLine from './drawLine.mjs';
-import { logger } from './logger.mjs';
+import { errorLogger, 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) {
-      logger(`[query]: ${err.message}`, 'error');
+      errorLogger(err, 'query');
      return [];
    }
  }
@@ -574,7 +574,8 @@ export class Pattern {
   * Returns a new Pattern, which only returns haps that meet the given test.
   * @param {Function} hap_test - a function which returns false for haps to be removed from the pattern
   * @returns Pattern
-   * @noAutocomplete
+   * @example
+   * s("bd*8").velocity(rand).filterHaps((h) => (h.whole.begin % 1) < h.value.velocity)
   */
  filterHaps(hap_test) {
    return new Pattern((state) => this.query(state).filter(hap_test));
@@ -585,7 +586,11 @@ export class Pattern {
   * inside haps.
   * @param {Function} value_test
   * @returns Pattern
-   * @noAutocomplete
+   * @example
+   * const drums = s("bd sd bd sd")
+   * kick: drums.filterValues((v) => v.s === 'bd').duck(2)
+   * snare: drums.filterValues((v) => v.s === 'sd')
+   * bass: s("saw!4").note("G#1").lpf(80).lpenv(4).orbit(2)
   */
  filterValues(value_test) {
    return new Pattern((state) => this.query(state).filter((hap) => value_test(hap.value))).setSteps(this._steps);
@@ -1587,7 +1592,13 @@ export const func = curry((a, b) => reify(b).func(a));
 *
 * @param {string | string[]} name name of the function, or an array of names to be used as synonyms
 * @param {function} func function with 1 or more params, where last is the current pattern
- * @noAutocomplete
+ * @param {bool} patternify defaults to true; if set to false, you will have more control over the arguments to `func` as they will be
+ *   in their raw form and it will be up to you to patternify them and/or query them for values
+ * @example
+ * const vlpf = register('vlpf', (freq, pat) => {
+ *   return pat.fmap((v) => ({...v, cutoff: freq * (v.velocity ?? 1) }));
+ * })
+ * s("saw").seg(8).velocity(rand).vlpf(800)
 *
 */
 export function register(name, func, patternify = true, preserveSteps = false, join = (x) => x.innerJoin()) {
@@ -2234,7 +2245,7 @@ export const brak = register('brak', function (pat) {
 });

 /**
- * Reverse all haps in a pattern
+ * Reverse all cycles in a pattern. See also `revv` for reversing a whole pattern.
 *
 * @name rev
 * @memberof Pattern
@@ -2266,6 +2277,23 @@ 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.
@@ -2659,8 +2687,13 @@ export const hsl = register('hsl', (h, s, l, pat) => {
 /**
 * Tags each Hap with an identifier. Good for filtering. The function populates Hap.context.tags (Array).
 * @name tag
- * @noAutocomplete
 * @param {string} tag anything unique
+ * @example
+ * s("saw!16").note("F1")
+ *   .lpf(tri.range(40, 80).slow(4)).lpenv(5).lpq(4).lpd(0.15)
+ *   .when(rand.late(0.1).gte(0.5), x => x.transpose("12").tag('altered'))
+ *   .when(rand.late(0.2).gte(0.5), x => x.s("square").tag('altered'))
+ *   .when("<0 1>", x => x.filter((hap) => hap.hasTag('altered')))
 */
 Pattern.prototype.tag = function (tag) {
  return this.withContext((ctx) => ({ ...ctx, tags: (ctx.tags || []).concat([tag]) }));
@@ -2671,15 +2704,16 @@ Pattern.prototype.tag = function (tag) {
 * @name filter
 * @param {Function} test function to test Hap
 * @example
- * s("hh!7 oh").filter(hap => hap.value.s==='hh')
+ * s("hh!7 oh").filter(hap => hap.value.s === 'hh')
 */
 export const filter = register('filter', (test, pat) => pat.withHaps((haps) => haps.filter(test)));

 /**
 * Filters haps by their begin time
 * @name filterWhen
- * @noAutocomplete
 * @param {Function} test function to test Hap.whole.begin
+ * @example
+ * oneCycle: s("bd*4").filterWhen((t) => t < 1)
 */
 export const filterWhen = register('filterWhen', (test, pat) => pat.filter((h) => test(h.whole.begin)));

@@ -152,9 +152,9 @@ export function repl({
        // allows muting a pattern x with x_ or _x
        return silence;
      }
-      if (id === '$') {
+      if (id.includes('$')) {
        // allows adding anonymous patterns with $:
-        id = `$${anonymousIndex}`;
+        id = `${id}${anonymousIndex}`;
        anonymousIndex++;
      }
      pPatterns[id] = this;
@@ -215,8 +215,19 @@ 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)) {
-          patterns.push(value.withState((state) => state.setControls({ id: key })));
+          // 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);
+          }
        }
        if (eachTransform) {
          // Explicit lambda so only element (not index and array) are passed
@@ -227,14 +238,13 @@ export function repl({
        pattern = eachTransform(pattern);
      }
      if (allTransforms.length) {
-        for (let i in allTransforms) {
-          pattern = allTransforms[i](pattern);
+        for (const transform of allTransforms) {
+          pattern = transform(pattern);
        }
      }

      if (!isPattern(pattern)) {
-        const message = `got "${typeof evaluated}" instead of pattern`;
-        throw new Error(message + (typeof evaluated === 'function' ? ', did you forget to call a function?' : '.'));
+        pattern = silence;
      }
      logger(`[eval] code updated`);
      pattern = await setPattern(pattern, autostart);
@@ -524,7 +524,7 @@ export const wchoose = (...pairs) => wchooseWith(rand, ...pairs);
 * @example
 * wchooseCycles(["bd",10], ["hh",1], ["sd",1]).s().fast(8)
 * @example
- * wchooseCycles(["bd bd bd",5], ["hh hh hh",3], ["sd sd sd",1]).fast(4).s()
+ * wchooseCycles(["c c c",5], ["a a a",3], ["f f f",1]).fast(4).note()
 * @example
 * // The probability can itself be a pattern
 * wchooseCycles(["bd(3,8)","<5 0>"], ["hh hh hh",3]).fast(4).s()
@@ -586,6 +586,18 @@ 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', () => {
@@ -35,6 +35,7 @@ export async function initHydra(options = {}) {
      hydra.synth.s0.init({ src: canvas });
    }
  }
+  return hydra;
 }

 export function clearHydra() {
@@ -479,14 +479,24 @@ Pattern.prototype.midi = function (midiport, options = {}) {

 let listeners = {};
 const refs = {};
+const refsByChan = {};

 /**
 * MIDI input: Opens a MIDI input port to receive MIDI control change messages.
+ *
+ * The output is a function that accepts a midi cc value to query as well as (optionally) a midi channel
 * @param {string | number} input MIDI device name or index defaulting to 0
- * @returns {Function}
+ * @returns {function(number, number=): Pattern} A function from (cc, channel?) to a pattern.
+ *   When queried, the pattern will produces the most recently received midi value (normalized to 0 to 1)
+ *   that came through that cc number (and channel, if provided)
 * @example
- * let cc = await midin('IAC Driver Bus 1')
+ * const cc = await midin('IAC Driver Bus 1')
 * note("c a f e").lpf(cc(0).range(0, 1000)).lpq(cc(1).range(0, 10)).sound("sawtooth")
+ * @example
+ * const allCC = await midin('IAC Driver Bus 1')
+ * const cc = (ccNum) => allCC(ccNum, 2) // just channel 2
+ * note("c a f e").s("saw")
+ *   .when(cc(0).gt(0), x => x.postgain(0))
 */
 export async function midin(input) {
  if (isPattern(input)) {
@@ -511,17 +521,24 @@ export async function midin(input) {
      }`,
    );
  }
-  // ensure refs for this input are initialized
-  if (!refs[input]) {
-    refs[input] = {};
-  }
-  const cc = (cc) => ref(() => refs[input][cc] || 0);
+  refs[input] ??= {};
+  refsByChan[input] ??= {};
+  const cc = (cc, chan) => {
+    if (chan !== undefined) {
+      return ref(() => refsByChan[input][cc]?.[chan] || 0);
+    }
+    return ref(() => refs[input][cc] || 0);
+  };

  listeners[input] && device.removeListener('midimessage', listeners[input]);
  listeners[input] = (e) => {
-    const cc = e.dataBytes[0];
+    const ccNum = e.dataBytes[0];
    const v = e.dataBytes[1];
-    refs[input] && (refs[input][cc] = v / 127);
+    const chan = e.message.channel;
+    const scaled = v / 127;
+    refsByChan[input][ccNum] ??= {};
+    refsByChan[input][ccNum][chan] = scaled;
+    refs[input][ccNum] = scaled;
  };
  device.addListener('midimessage', listeners[input]);
  return cc;
@@ -9,6 +9,7 @@ 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) => {
@@ -54,7 +55,6 @@ async function getBanks(directory, flat = false) {
    banks[bank].push(subDir);
    return subDir;
  });
-  banks._base = `http://localhost:5432`;
  return { banks, files };
 }

@@ -134,8 +134,6 @@ 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();
@@ -6,6 +6,7 @@ import {
  getADSRValues,
  getPitchEnvelope,
  getVibratoOscillator,
+  onceEnded,
 } from '@strudel/webaudio';
 import gm from './gm.mjs';

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

        bufferSource.stop(envEnd);
        const stop = (releaseTime) => {};
-        bufferSource.onended = () => {
+        onceEnded(bufferSource, () => {
          bufferSource.disconnect();
          vibratoOscillator?.stop();
          node.disconnect();
          onended();
-        };
+        });
        return { node, stop };
      },
      { type: 'soundfont', prebake: true, fonts },
@@ -1,7 +1,7 @@
 import { getAudioContext } from './audioContext.mjs';
-import { clamp, midiToFreq, nanFallback, noteToMidi } from './util.mjs';
-import { getNoiseBuffer } from './noise.mjs';
 import { logger } from './logger.mjs';
+import { getNoiseBuffer } from './noise.mjs';
+import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';

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

@@ -191,8 +191,7 @@ export function applyParameterModulators(audioContext, param, start, end, envelo
  const lfo = getParamLfo(audioContext, param, start, end, lfoValues);
  return { lfo, disconnect: () => lfo?.disconnect() };
 }
-
-export function createFilter(context, start, end, params, cps) {
+export function createFilter(context, start, end, params, cps, cycle) {
  let {
    frequency,
    anchor,
@@ -202,12 +201,14 @@ export function createFilter(context, start, end, params, cps) {
    q = 1,
    drive = 0.69,
    depth,
+    depthfrequency,
    dcoffset = -0.5,
    skew,
    shape,
    rate,
    sync,
  } = params;
+
  let frequencyParam, filter;
  if (model === 'ladder') {
    filter = getWorklet(context, 'ladder-processor', { frequency, q, drive });
@@ -238,9 +239,27 @@ export function createFilter(context, start, end, params, cps) {
  if (sync != null) {
    rate = cps * sync;
  }
-  const lfoValues = { depth, dcoffset, skew, shape, frequency: rate };
-  getParamLfo(context, frequencyParam, start, end, lfoValues);
-  return filter;
+  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 };
 }

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

 let curves = ['linear', 'exponential'];
@@ -297,6 +324,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;
  }
@@ -318,25 +349,17 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
  constantNode.connect(zeroGain);

  // Schedule the `onComplete` callback to occur at `stopTime`
-  constantNode.onended = () => {
-    // Ensure garbage collection
-    try {
-      zeroGain.disconnect();
-    } catch {
-      // pass
-    }
-    try {
-      constantNode.disconnect();
-    } catch {
-      // pass
-    }
+  onceEnded(constantNode, () => {
+    releaseAudioNode(zeroGain);
+    releaseAudioNode(constantNode);
    onComplete();
-  };
+  });
  constantNode.start(startTime);
  constantNode.stop(stopTime);
  return constantNode;
 }
-const mod = (freq, range = 1, type = 'sine') => {
+
+const mod = (freq, type = 'sine') => {
  const ctx = getAudioContext();
  let osc;
  if (noises.includes(type)) {
@@ -348,64 +371,89 @@ const mod = (freq, range = 1, type = 'sine') => {
    osc.type = type;
    osc.frequency.value = freq;
  }
-
  osc.start();
-  const g = new GainNode(ctx, { gain: range });
-  osc.connect(g); // -range, range
-  return { node: g, stop: (t) => osc.stop(t) };
+  return osc;
 };
-const fm = (frequencyparam, harmonicityRatio, modulationIndex, wave = 'sine') => {
+
+const fm = (frequencyparam, harmonicityRatio, wave = 'sine') => {
  const carrfreq = frequencyparam.value;
  const modfreq = carrfreq * harmonicityRatio;
-  const modgain = modfreq * modulationIndex;
-  return mod(modfreq, modgain, wave);
+  return { osc: mod(modfreq, wave), freq: modfreq };
 };
+
 export function applyFM(param, value, begin) {
-  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);
+  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]);
    }
  }
-  return { stop };
+  return {
+    stop: (t) => toStop.forEach((m) => m?.stop(t)),
+  };
 }

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

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

-export const destroyAudioWorkletNode = (node) => {
-  if (node == null) {
-    return;
-  }
-  node.disconnect();
-  node.parameters.get('end')?.setValueAtTime(0, 0);
+// 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 getDetuner = (detune = 0, power = 0) => {
-  if (detune <= 0) {
-    return () => 0;
+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');
  }
-  const curve = (x) => {
-    if (power === 0) {
-      return x;
+
+  // 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`,
+      );
    }
-    const a = Math.abs(x),
-      s = Math.sign(x);
-    if (power > 0) {
-      return s * Math.pow(a, 1 + 4 * power);
+    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();
    }
-    return s * (1 - Math.pow(1 - a, 1 - 4 * power));
-  };
-  return (t) => {
-    return curve(2 * t - 1) * detune;
-  };
+  }
+
+  // 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)));
 };
@@ -65,8 +65,9 @@ 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: noiseMix.node,
    stop: (time) => noiseOscillator?.stop(time),
  };
 }
@@ -1,7 +1,14 @@
-import { getCommonSampleInfo } from './util.mjs';
+import { getBaseURL, getCommonSampleInfo } from './util.mjs';
 import { registerSound, registerWaveTable } from './index.mjs';
 import { getAudioContext } from './audioContext.mjs';
-import { getADSRValues, getParamADSR, getPitchEnvelope, getVibratoOscillator } from './helpers.mjs';
+import {
+  getADSRValues,
+  getParamADSR,
+  getPitchEnvelope,
+  getVibratoOscillator,
+  onceEnded,
+  releaseAudioNode,
+} from './helpers.mjs';
 import { logger } from './logger.mjs';

 const bufferCache = {}; // string: Promise<ArrayBuffer>
@@ -211,7 +218,7 @@ export async function fetchSampleMap(url) {
    // not a browser
    return;
  }
-  const base = url.split('/').slice(0, -1).join('/');
+  const base = getBaseURL(url);
  if (typeof fetch === 'undefined') {
    // skip fetch when in node / testing
    return;
@@ -236,12 +243,6 @@ 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 = {}) => {
@@ -286,17 +287,19 @@ export async function onTriggerSample(t, value, onended, bank, resolveUrl) {

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

-  // 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;
-  }
  if (!bufferSource) {
    logger(`[sampler] could not load "${s}:${n}"`, 'error');
    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);
+    return;
+  }
+
  // vibrato
  let vibratoOscillator = getVibratoOscillator(bufferSource.detune, value, t);

@@ -319,13 +322,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);
-  bufferSource.onended = function () {
+  onceEnded(bufferSource, function () {
    bufferSource.disconnect();
    vibratoOscillator?.stop();
    node.disconnect();
    out.disconnect();
    onended();
-  };
+  });
  let envEnd = holdEnd + release + 0.01;
  bufferSource.stop(envEnd);
  const stop = (endTime) => {
@@ -263,8 +263,8 @@ let audioReady;
 export async function initAudioOnFirstClick(options) {
  if (!audioReady) {
    audioReady = new Promise((resolve) => {
-      document.addEventListener('click', async function listener() {
-        document.removeEventListener('click', listener);
+      document.addEventListener('mousedown', async function listener() {
+        document.removeEventListener('mousedown', listener);
        await initAudio(options);
        resolve();
      });
@@ -274,7 +274,7 @@ export async function initAudioOnFirstClick(options) {
 }

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

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

  //filters
-  const numStages = 2; //num of filters in series
-  let fOffset = 0;
+  const numStages = 1; //num of filters in series
+  let fOffset = 282; //for backward compat in #1800
  const filterChain = [];
  for (let i = 0; i < numStages; i++) {
    const filter = ac.createBiquadFilter();
@@ -300,14 +300,11 @@ 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);

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

 function getFilterType(ftype) {
@@ -413,7 +410,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    release = 0,

    //phaser
-    phaserrate: phaser,
+    phaserrate,
    phaserdepth = getDefaultValue('phaserdepth'),
    phasersweep,
    phasercenter,
@@ -451,6 +448,8 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    compressorKnee,
    compressorAttack,
    compressorRelease,
+    transient,
+    transsustain,
  } = value;

  delaytime = delaytime ?? cycleToSeconds(delaysync, cps);
@@ -532,6 +531,23 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  chain.push(sourceNode);
  stretch !== undefined && chain.push(getWorklet(ac, 'phase-vocoder-processor', { pitchFactor: stretch }));

+  transient !== undefined &&
+    chain.push(
+      getWorklet(
+        ac,
+        'transient-processor',
+        {},
+        {
+          processorOptions: {
+            attack: transient,
+            sustain: transsustain,
+            begin: t,
+            end: endWithRelease,
+          },
+        },
+      ),
+    );
+
  // gain stage
  chain.push(gainNode(gain));

@@ -553,16 +569,21 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      rate: 'lprate',
      sync: 'lpsync',
      depth: 'lpdepth',
+      depthfrequency: 'lpdepthfrequency',
      shape: 'lpshape',
      dcoffset: 'lpdc',
      skew: 'lpskew',
    };
    const lpParams = pickAndRename(value, lpMap);
    lpParams.type = 'lowpass';
-    let lp = () => createFilter(ac, t, end, lpParams, cps);
-    chain.push(lp());
+    const lp = () => createFilter(ac, t, end, lpParams, cps, cycle);
+    const { filter: lpf1, lfo: lfo1 } = lp();
+    chain.push(lpf1);
+    lfo1 && audioNodes.push(lfo1);
    if (ftype === '24db') {
-      chain.push(lp());
+      const { filter: lpf2, lfo: lfo2 } = lp();
+      chain.push(lpf2);
+      lfo2 && audioNodes.push(lfo2);
    }
  }

@@ -581,16 +602,21 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      rate: 'hprate',
      sync: 'hpsync',
      depth: 'hpdepth',
+      depthfrequency: 'hpdepthfrequency',
      shape: 'hpshape',
      dcoffset: 'hpdc',
      skew: 'hpskew',
    };
    const hpParams = pickAndRename(value, hpMap);
    hpParams.type = 'highpass';
-    let hp = () => createFilter(ac, t, end, hpParams, cps);
-    chain.push(hp());
+    const hp = () => createFilter(ac, t, end, hpParams, cps, cycle);
+    const { filter: hpf1, lfo: lfo1 } = hp();
+    chain.push(hpf1);
+    lfo1 && audioNodes.push(lfo1);
    if (ftype === '24db') {
-      chain.push(hp());
+      const { filter: hpf2, lfo: lfo2 } = hp();
+      chain.push(hpf2);
+      lfo2 && audioNodes.push(lfo2);
    }
  }

@@ -609,16 +635,21 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      rate: 'bprate',
      sync: 'bpsync',
      depth: 'bpdepth',
+      depthfrequency: 'bpdepthfrequency',
      shape: 'bpshape',
      dcoffset: 'bpdc',
      skew: 'bpskew',
    };
    const bpParams = pickAndRename(value, bpMap);
    bpParams.type = 'bandpass';
-    let bp = () => createFilter(ac, t, end, bpParams, cps);
-    chain.push(bp());
+    const bp = () => createFilter(ac, t, end, bpParams, cps, cycle);
+    const { filter: bpf1, lfo: lfo1 } = bp();
+    chain.push(bpf1);
+    lfo1 && audioNodes.push(lfo1);
    if (ftype === '24db') {
-      chain.push(bp());
+      const { filter: bpf2, lfo: lfo2 } = bp();
+      chain.push(bpf2);
+      lfo2 && audioNodes.push(lfo2);
    }
  }

@@ -665,6 +696,7 @@ 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);
  }

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

  // last gain
@@ -692,7 +725,8 @@ 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);
-    orbitBus.sendDelay(post, delay);
+    const send = orbitBus.sendDelay(post, delay);
+    audioNodes.push(send);
  }
  // reverb
  if (room > 0) {
@@ -82,7 +82,7 @@ export class Orbit {
  }

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

  duck(t, onsettime = 0, attacktime = 0.1, depth = 1) {
@@ -3,7 +3,6 @@ import { registerSound, soundMap } from './superdough.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import {
  applyFM,
-  destroyAudioWorkletNode,
  gainNode,
  getADSRValues,
  getFrequencyFromValue,
@@ -13,6 +12,7 @@ import {
  getVibratoOscillator,
  getWorklet,
  noises,
+  releaseAudioNode,
  webAudioTimeout,
 } from './helpers.mjs';
 import { logger } from './logger.mjs';
@@ -48,19 +48,17 @@ 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);

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

        const envGain = gainNode(1);
        let node = o.connect(g).connect(envGain);
@@ -174,31 +172,27 @@ export function registerSynthSounds() {
          begin,
          end,
          freqspread: detune,
+          voices,
          panspread,
-          power: value.dpow,
-          blend: value.dblend,
        },
        {
          outputChannelCount: [2],
-          processorOptions: {
-            voices,
-            stackmode: value.dstack,
-          },
        },
      );
+
+      const gainAdjustment = 1 / Math.sqrt(voices);
      getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
      const vibratoOscillator = getVibratoOscillator(o.parameters.get('detune'), value, begin);
      const fm = applyFM(o.parameters.get('frequency'), value, begin);
      let envGain = gainNode(1);
      envGain = o.connect(envGain);

-      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3, begin, holdend, 'linear');
+      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3 * gainAdjustment, begin, holdend, 'linear');

      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          destroyAudioWorkletNode(o);
-          envGain.disconnect();
+          releaseAudioNode(o);
          onended();
          fm?.stop();
          vibratoOscillator?.stop();
@@ -275,8 +269,7 @@ export function registerSynthSounds() {
      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          destroyAudioWorkletNode(o);
-          envGain.disconnect();
+          releaseAudioNode(o);
          onended();
        },
        begin,
@@ -349,9 +342,8 @@ export function registerSynthSounds() {
      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          destroyAudioWorkletNode(o);
-          destroyAudioWorkletNode(lfo);
-          envGain.disconnect();
+          releaseAudioNode(o);
+          releaseAudioNode(lfo);
          onended();
          fm?.stop();
          vibratoOscillator?.stop();
@@ -463,7 +455,7 @@ export function waveformN(partials, phases, type) {
 }

 // expects one of waveforms as s
-export function getOscillator(s, t, value) {
+export function getOscillator(s, t, value, onended) {
  const { duration, noise = 0 } = value;
  const partials = value.partials ?? value.n;
  let o;
@@ -485,7 +477,6 @@ export function getOscillator(s, t, value) {
  }
  // set frequency
  o.frequency.value = getFrequencyFromValue(value);
-  o.start(t);

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

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

+  o.onended = () => {
+    noiseMix || o.disconnect();
+    noiseMix?.node.disconnect();
+    onended();
+  };
+  o.start(t);
+
  return {
    node: noiseMix?.node || o,
    stop: (time) => {
@@ -114,3 +114,13 @@ export function getCommonSampleInfo(hapValue, bank) {
 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,7 +45,8 @@ if (typeof GainNode !== 'undefined') {
        throw new Error('vowel: unknown vowel ' + letter);
      }
      const { gains, qs, freqs } = vowelFormant[letter];
-      const makeupGain = ac.createGain();
+      this.makeupGain = ac.createGain();
+      this.audioNodes = [];
      for (let i = 0; i < 5; i++) {
        const gain = ac.createGain();
        gain.gain.value = gains[i];
@@ -53,14 +54,25 @@ if (typeof GainNode !== 'undefined') {
        filter.type = 'bandpass';
        filter.Q.value = qs[i];
        filter.frequency.value = freqs[i];
-        this.connect(filter);
+        super.connect(filter);
        filter.connect(gain);
-        gain.connect(makeupGain);
+        this.audioNodes.push(filter);
+        gain.connect(this.makeupGain);
+        this.audioNodes.push(gain);
      }
-      makeupGain.gain.value = 8; // how much makeup gain to add?
-      this.connect = (target) => makeupGain.connect(target);
+      this.makeupGain.gain.value = 8; // how much makeup gain to add?
      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 { getCommonSampleInfo } from './util.mjs';
+import { getBaseURL, 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,6 +190,7 @@ 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;
@@ -200,7 +201,7 @@ export const tables = async (url, frameLen, json, options = {}) => {
  }
  return fetch(url)
    .then((res) => res.json())
-    .then((json) => _processTables(json, url, frameLen, options))
+    .then((json) => _processTables(json, base, frameLen, options))
    .catch((error) => {
      console.error(error);
      throw new Error(`error loading "${url}"`);
@@ -234,19 +235,12 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
      freqspread: value.detune,
      position: value.wt,
      warp: value.warp,
+      warpMode: warpmode,
+      voices: Math.max(value.unison ?? 1, 1),
      panspread: value.spread,
-      power: value.dpow,
-      blend: value.dblend,
-    },
-    {
-      outputChannelCount: [2],
-      processorOptions: {
-        voices: Math.max(value.unison ?? 1, 1),
-        stackmode: value.dstack,
-        phaserand: (value.wtphaserand ?? value.unison > 1) ? 1 : 0,
-        warpmode,
-      },
+      phaserand: (value.wtphaserand ?? value.unison > 1) ? 1 : 0,
    },
+    { outputChannelCount: [2] },
  );
  source.port.postMessage({ type: 'table', payload });
  if (ac.currentTime > t) {
@@ -325,10 +319,9 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
  const timeoutNode = webAudioTimeout(
    ac,
    () => {
-      destroyAudioWorkletNode(source);
+      releaseAudioNode(source);
      vibratoOscillator?.stop();
      fm?.stop();
-      node.disconnect();
      wtPosModulators?.disconnect();
      wtWarpModulators?.disconnect();
      onended();
@@ -4,13 +4,16 @@

 import OLAProcessor from './ola-processor';
 import FFT from './fft.js';
-import { getDistortionAlgorithm, getDetuner } from './helpers.mjs';
+import { getDistortionAlgorithm } from './helpers.mjs';

 const blockSize = 128;
 const PI = Math.PI;
 const TWO_PI = 2 * PI;
 const INVSR = 1 / sampleRate;

+const timeToCoeff = (t) => 1 - Math.exp(-INVSR / t);
+const dbToLin = (db) => Math.pow(10, db / 20);
+
 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;
@@ -28,6 +31,16 @@ const fast_tanh = (x) => {
  return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
 };

+// Optimized per-voice detuner which precomputes constants
+const getDetuner = (unison, detune) => {
+  if (unison < 2) {
+    return (_voiceIdx) => 0;
+  }
+  const scale = detune / (unison - 1);
+  const center = detune * 0.5;
+  return (voiceIdx) => voiceIdx * scale - center;
+};
+
 const applySemitoneDetuneToFrequency = (frequency, detune) => {
  return frequency * Math.pow(2, detune / 12);
 };
@@ -444,68 +457,11 @@ class DistortProcessor extends AudioWorkletProcessor {
 }
 registerProcessor('distort-processor', DistortProcessor);

-const INTERVALS = [
-  [1],
-  [1, 2],
-  [1, 3],
-  [1, 2, 4],
-  [1, 2, 4, 8],
-  [1, 2, 3],
-  [1, 1.5, 2.4],
-  [1, 2.5],
-  [1, 1.782],
-  [1, 2.4],
-  [1, 1.5, 2.5],
-  [1, 1.667],
-  [1, 2.25],
-];
-const _getIntervals = (mode = 0) => {
-  return INTERVALS[mode] ?? INTERVALS[0];
-};
-
-const initUnisonProcessor = (processor, processorOptions) => {
-  processor.intervals = _getIntervals(processorOptions.stackmode);
-  processor.intervalGains = processor.intervals.map((i) => 1 / i ** 0.5); // reduce volume of upper harmonics
-  processor.intNorm = Math.sqrt(1 / processor.intervalGains.reduce((acc, i) => acc + i ** 2, 0));
-  processor.numIntervals = processor.intervals.length;
-  processor.voices = processorOptions.voices;
-  processor.isDetuned = processor.voices > 1;
-  processor.isCenter = (idx) => {
-    if (!processor.isDetuned) return true;
-    if (processor.voices % 2 === 1) {
-      return idx === (processor.voices - 1) >> 1;
-    } else {
-      const right = processor.voices >> 1;
-      const left = right - 1;
-      return idx === left || idx === right;
-    }
-  };
-  const totalVoices = processor.voices * processor.numIntervals;
-  processor.blendGains = new Array(processor.voices).fill(1);
-  const phaserand = processorOptions.phaserand ?? 1;
-  processor.phases = new Array(totalVoices).fill(0).map(() => Math.random() * phaserand);
-  return totalVoices;
-};
-
-const getUnisonData = (processor, params, i) => {
-  const detune = pv(params.detune, i);
-  const freqspread = pv(params.freqspread, i);
-  const blend = pv(params.blend, i) * 0.95;
-  const blendGains = processor.blendGains.map((_, idx) => (processor.isCenter(idx) ? 1 - blend : 1 + blend));
-  const blendNorm = 1 / Math.sqrt(blendGains.reduce((acc, g) => acc + g ** 2, 0));
-  const normalizer = blendNorm * processor.intNorm;
-  const power = pv(params.power, i);
-  const freq = applySemitoneDetuneToFrequency(pv(params.frequency, i), detune / 100);
-  const detuner = getDetuner(freqspread, power);
-  const inv = processor.voices > 1 ? 1 / (processor.voices - 1) : 0;
-  return { blendGains, normalizer, detuner, inv, freq };
-};
-
 // SUPERSAW
 class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
-  constructor({ processorOptions }) {
+  constructor() {
    super();
-    initUnisonProcessor(this, processorOptions);
+    this.phase = [];
  }
  static get parameterDescriptors() {
    return [
@@ -515,17 +471,20 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        max: Number.POSITIVE_INFINITY,
        min: 0,
      },
+
      {
        name: 'end',
        defaultValue: 0,
        max: Number.POSITIVE_INFINITY,
        min: 0,
      },
+
      {
        name: 'frequency',
        defaultValue: 440,
        min: Number.EPSILON,
      },
+
      {
        name: 'panspread',
        defaultValue: 0.4,
@@ -542,54 +501,55 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        defaultValue: 0,
        min: 0,
      },
+
      {
-        name: 'blend',
-        defaultValue: 0,
-        min: -1,
-        max: 1,
-      },
-      {
-        name: 'power',
-        defaultValue: 0,
-        min: -1,
-        max: 1,
+        name: 'voices',
+        defaultValue: 5,
+        min: 1,
+        automationRate: 'k-rate',
      },
    ];
  }
  process(_input, outputs, params) {
-    if (currentTime <= params.begin[0]) {
-      return true;
-    }
    if (currentTime >= params.end[0]) {
+      // should terminate
      return false;
    }
+    if (currentTime <= params.begin[0]) {
+      // keep alive
+      return true;
+    }
    const output = outputs[0];
+    const voices = params.voices[0]; // k-rate
    for (let i = 0; i < output[0].length; i++) {
-      const { blendGains, normalizer, detuner, inv, freq } = getUnisonData(this, params, i);
+      const detune = pv(params.detune, i);
+      const freqspread = pv(params.freqspread, i);
      const panspread = pv(params.panspread, i) * 0.5 + 0.5;
-      let gainL = Math.sqrt(1 - panspread) * normalizer;
-      let gainR = Math.sqrt(panspread) * normalizer;
-      for (let n = 0; n < this.voices; n++) {
+      let gainL = Math.sqrt(1 - panspread);
+      let gainR = 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++) {
        // Individual voice detuning
-        const freqVoice = this.isDetuned ? applySemitoneDetuneToFrequency(freq, detuner(n * inv)) : freq; // voice detune
-        const bG = blendGains[n];
-        for (let idx = 0; idx < this.numIntervals; idx++) {
-          const g = bG * this.intervalGains[idx];
-          const freqStack = freqVoice * this.intervals[idx];
-          // We must wrap this here because it is passed into sawblep below which
-          // has domain [0, 1]
-          const dt = ffrac(freqStack * INVSR);
-          const voiceNum = n * this.numIntervals + idx;
-          const v = waveshapes.sawblep(this.phases[voiceNum], dt);
-          output[0][i] += v * gainL * g;
-          output[1][i] += v * gainR * g;
-          let pn = this.phases[voiceNum] + dt;
-          if (pn >= 1.0) pn -= 1.0;
-          this.phases[voiceNum] = pn;
-          // invert right and left gain
-          gainL = gainR;
-          gainR = gainL;
-        }
+        const freqVoice = applySemitoneDetuneToFrequency(freq, detuner(n));
+        // We must wrap this here because it is passed into sawblep below which
+        // has domain [0, 1]
+        const dt = frac(freqVoice * INVSR);
+        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;
+
+        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;
      }
    }
    return true;
@@ -1169,24 +1129,24 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      { name: 'freqspread', defaultValue: 0.18, min: 0 },
      { 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: 'panspread', defaultValue: 0.7, min: 0, max: 1 },
-      { name: 'blend', defaultValue: 0, min: -1, max: 1 },
-      { name: 'power', defaultValue: 0, min: -1, max: 1 },
+      { name: 'phaserand', defaultValue: 0, min: 0, max: 1 },
    ];
  }

-  constructor({ processorOptions }) {
-    super();
-    initUnisonProcessor(this, processorOptions);
-    this.warpmode = processorOptions.warpmode;
+  constructor(options) {
+    super(options);
    this.frameLen = 0;
    this.numFrames = 0;
+    this.phase = [];
+
    this.port.onmessage = (e) => {
      const { type, payload } = e.data || {};
      if (type === 'table') {
        const key = payload.key;
        this.frameLen = payload.frameLen;
-        this.baseThreshold = this.frameLen >>> 3; // used for mipmaps
        if (!tablesCache[key]) {
          const tables = [payload.frames];
          let table = tables[0];
@@ -1354,13 +1314,10 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
  }

  _chooseMip(dphi) {
-    const approxHarm = Math.min(64, 1 / Math.max(1e-6, dphi));
-    const numTables = this.tables.length;
-    let level = 0,
-      threshold = this.baseThreshold;
-    while (level + 1 < numTables && approxHarm < threshold) {
+    const approxHarm = clamp(dphi, 1e-6, 64);
+    let level = 0;
+    while (level + 1 < (this.tables?.length || 1) && approxHarm < this.tables[level][0].length / 8) {
      level++;
-      threshold *= 2;
    }
    return level;
  }
@@ -1379,41 +1336,50 @@ 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 { blendGains, normalizer, detuner, inv, freq } = getUnisonData(this, parameters, 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 frac = idx - fIdx;
+      const interpT = idx - fIdx;
      const warpAmount = clamp(pv(parameters.warp, i), 0, 1);
-      const panspread = this.isDetuned ? clamp(pv(parameters.panspread, i), 0, 1) : 0;
-      let gainL = Math.sqrt(0.5 - 0.5 * panspread) * normalizer;
-      let gainR = Math.sqrt(0.5 + 0.5 * panspread) * normalizer;
-      for (let n = 0; n < this.voices; n++) {
-        const fVoice = this.isDetuned ? applySemitoneDetuneToFrequency(freq, detuner(n * inv)) : freq; // voice detune
-        const bG = blendGains[n];
-        for (let idx = 0; idx < this.numIntervals; idx++) {
-          const g = bG * this.intervalGains[idx];
-          const fStack = fVoice * this.intervals[idx];
-          const dt = fStack * INVSR;
-          const voiceNum = n * this.numIntervals + idx;
-          const level = this._chooseMip(dt);
-          const table = this.tables[level];
-          // warp phase then sample
-          const ph = this._warpPhase(this.phases[voiceNum], warpAmount, this.warpmode);
-          const s0 = this._sampleFrame(table[fIdx], ph);
-          const s1 = this._sampleFrame(table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
-          let s = s0 + (s1 - s0) * frac;
-          if (this.warpmode === WarpMode.FLIP && this.phase[n] < warpAmount) {
-            s = -s;
-          }
-          outL[i] += s * gainL * g;
-          outR[i] += s * gainR * g;
-          this.phases[voiceNum] = ffrac(this.phases[voiceNum] + dt);
-          // invert right and left gain
-          gainL = gainR;
-          gainR = gainL;
+      const warpMode = pv(parameters.warpMode, 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);
+      const gain2 = Math.sqrt(0.5 + 0.5 * panspread);
+      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;
+        let gainR = gain2;
+        // invert right and left gain
+        if (isOdd) {
+          gainL = gain2;
+          gainR = gain1;
        }
+        const fVoice = applySemitoneDetuneToFrequency(f, detuner(n)); // voice detune
+        const dPhase = fVoice * INVSR;
+        const level = this._chooseMip(dPhase);
+        const table = this.tables[level];
+
+        // warp phase then sample
+        this.phase[n] = this.phase[n] ?? Math.random() * phaseRand;
+        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);
+        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);
      }
    }
    return true;
@@ -1421,3 +1387,82 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
 }

 registerProcessor('wavetable-oscillator-processor', WavetableOscillatorProcessor);
+
+class TransientProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [];
+  }
+
+  constructor(options) {
+    super();
+    this.gainCoeff = timeToCoeff(0.2);
+    this.avgGain = 1;
+    let {
+      attackTime = 0.003,
+      sustainTime = 0.08,
+      attack = 0,
+      sustain = 0,
+      sensitivity = 0.1,
+      mix = 1,
+      begin = 0,
+      end = 0,
+    } = options.processorOptions;
+    attackTime = clamp(attackTime, 0.0005, 0.05);
+    sustainTime = clamp(sustainTime, 0.01, 0.5);
+    this.attackCoeff = timeToCoeff(attackTime);
+    this.sustainCoeff = timeToCoeff(sustainTime);
+    this.attackAmt = clamp(attack, -1, 1);
+    this.sustainAmt = clamp(sustain, -1, 1);
+    this.scaling = 0.5 + 5 * clamp(sensitivity, 0, 1);
+    this.mix = clamp(mix, 0, 1);
+    this.begin = begin;
+    this.end = end;
+    this.attackEnv = new Float32Array(2); // assume stereo
+    this.sustainEnv = new Float32Array(2);
+  }
+
+  process(inputs, outputs, _params) {
+    const input = inputs[0];
+    const output = outputs[0];
+    if (currentTime >= this.end) {
+      return false;
+    }
+    if (currentTime <= this.begin) {
+      return true;
+    }
+    const channels = input.length;
+    if (channels > this.attackEnv.length) {
+      this.attackEnv = new Float32Array(channels);
+      this.sustainEnv = new Float32Array(channels);
+    }
+    let avgGain = this.avgGain;
+    for (let ch = 0; ch < channels; ch++) {
+      let attEnv = this.attackEnv[ch];
+      let susEnv = this.sustainEnv[ch];
+      for (let n = 0; n < blockSize; n++) {
+        const sample = input[ch][n];
+        const x = Math.abs(sample);
+        attEnv = lerp(attEnv, x, this.attackCoeff);
+        susEnv = lerp(susEnv, x, this.sustainCoeff);
+        const peakiness = clamp((this.scaling * (attEnv - susEnv)) / (susEnv + 1e-6), -1.5, 1.5);
+        const attScale = peakiness > 0 ? peakiness : 0;
+        const susScale = peakiness < 0 ? -peakiness : 0;
+        const attackGain = dbToLin(this.attackAmt * attScale * 18);
+        const sustainGain = dbToLin(this.sustainAmt * susScale * 36);
+        const gain = clamp(attackGain * sustainGain, 0, 8);
+        avgGain = lerp(avgGain, gain, this.gainCoeff);
+        const makeup = avgGain > 1e-3 ? 1 / avgGain : 1;
+        const wet = sample * gain * makeup;
+        let y = lerp(sample, wet, this.mix);
+        y /= 1 + Math.abs(y); // soft clip
+        output[ch][n] = y;
+      }
+      this.attackEnv[ch] = attEnv;
+      this.sustainEnv[ch] = susEnv;
+    }
+    this.avgGain = avgGain;
+    return true;
+  }
+}
+
+registerProcessor('transient-processor', TransientProcessor);
@@ -3,6 +3,7 @@ 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 {
@@ -83,10 +84,10 @@ export function registerZZFXSounds() {
      wave,
      (t, value, onended) => {
        const { node: o } = getZZFX({ s: wave, ...value }, t);
-        o.onended = () => {
-          o.disconnect();
+        onceEnded(o, () => {
+          releaseAudioNode(o);
          onended();
-        };
+        });
        return {
          node: o,
          stop: () => {},
@@ -5,7 +5,16 @@ This program is free software: you can redistribute it and/or modify it under th
 */

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

 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
@@ -294,7 +303,7 @@ export const scale = register(
            }
            if (offset != 0) scaleNote = Note.transpose(scaleNote, Interval.fromSemitones(offset));
          } catch (err) {
-            logger(`[tonal] ${err.message}`, 'error');
+            errorLogger(err, 'tonal');
            return; // will be removed
          }
        }
@@ -1,4 +1,5 @@
 {
+  "name": "dbpatch",
  "dependencies": {
    "csv": "^6.3.11"
  },
@@ -0,0 +1,14 @@
+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);
+  });
+
+/*
+
+  */
@@ -8,3 +8,34 @@ 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>}
+    />
+  );
+}
@@ -0,0 +1,29 @@
+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])}
+    />
+  );
+}
@@ -7,6 +7,8 @@ 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 (
@@ -113,6 +115,7 @@ export function SettingsTab({ started }) {
    isTabIndentationEnabled,
    isMultiCursorEnabled,
    patternAutoStart,
+    includePrebakeScriptInShare,
  } = useSettings();
  const shouldAlwaysSync = isUdels();
  const canChangeAudioDevice = AudioContext.prototype.setSinkId != null;
@@ -204,6 +207,15 @@ 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}
@@ -313,8 +325,7 @@ export function SettingsTab({ started }) {
      </FormItem>
      <FormItem label="Zen Mode">Try clicking the logo in the top left!</FormItem>
      <FormItem label="Reset Settings">
-        <button
-          className="bg-background p-2 max-w-[300px] rounded-md hover:opacity-50"
+        <SpecialActionButton
          onClick={() => {
            confirmDialog('Sure?').then((r) => {
              if (r) {
@@ -325,7 +336,7 @@ export function SettingsTab({ started }) {
          }}
        >
          restore default settings
-        </button>
+        </SpecialActionButton>
      </FormItem>
    </div>
  );
@@ -14,6 +14,10 @@ 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);

@@ -56,9 +60,7 @@ export function SoundsTab() {

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

  // stop current sound on mouseup
  useEvent('mouseup', () => {
@@ -66,6 +68,14 @@ export function SoundsTab() {
    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;
+  });
  return (
    <div id="sounds-tab" className="px-4 flex gap-2 flex-col w-full h-full text-foreground">
      <Textbox placeholder="Search" value={search} onChange={(v) => setSearch(v)} />
@@ -115,25 +125,34 @@ export function SoundsTab() {
                const params = {
                  note: ['synth', 'soundfont'].includes(data.type) ? 'a3' : undefined,
                  s: name,
-                  n: soundPreviewIdx,
+                  n: numRef.current,
                  clip: 1,
                  release: 0.5,
                  sustain: 1,
                  duration: 0.5,
                };
-                soundPreviewIdx++;
                const onended = () => trigRef.current?.node?.disconnect();
-                try {
-                  // Pre-load the sample by calling onTrigger with a future time
-                  // This triggers the loading but schedules playback for later
-                  const time = ctx.currentTime + 0.5; // Give 500ms for loading
-                  const ref = await onTrigger(time, params, onended);
-                  trigRef.current = ref;
-                  if (ref?.node) {
-                    connectToDestination(ref.node);
+                // 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);
                  }
-                } catch (err) {
-                  console.warn('Failed to trigger sound:', err);
                }
              }}
            >
@@ -3,6 +3,8 @@ 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 { transpiler } from '@strudel/transpiler';
+import { evaluate, transpiler } from '@strudel/transpiler';
 import {
  getAudioContextCurrentTime,
  webaudioOutput,
@@ -63,11 +63,10 @@ async function getModule(name) {
 const initialCode = `// LOADING`;

 export function useReplContext() {
-  const { isSyncEnabled, audioEngineTarget } = useSettings();
+  const { isSyncEnabled, audioEngineTarget, prebakeScript, includePrebakeScriptInShare } = 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();
@@ -84,7 +83,12 @@ export function useReplContext() {
      pattern: silence,
      drawTime,
      drawContext,
-      prebake: async () => Promise.all([modulesLoading, presets]),
+      prebake: async () =>
+        Promise.all([modulesLoading, presets]).then(() => {
+          if (prebakeScript?.length) {
+            return evaluate(prebakeScript ?? '');
+          }
+        }),
      onUpdateState: (state) => {
        setReplState({ ...state });
      },
@@ -214,7 +218,13 @@ export function useReplContext() {
    editorRef.current.repl.evaluate(code);
  };

-  const handleShare = async () => shareCode(replState.code);
+  const handleShare = async () => {
+    let code = replState.code;
+    if (includePrebakeScriptInShare) {
+      code = prebakeScript + '\n' + code;
+    }
+    shareCode(code);
+  };
  const context = {
    started,
    pending,
@@ -1,11 +1,10 @@
-import { evalScope, hash2code, logger } from '@strudel/core';
+import { code2hash, 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';

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

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

-export async function shareCode() {
+export async function shareCode(codeToShare) {
  try {
-    const shareUrl = window.location.href;
+    const hash = '#' + code2hash(codeToShare);
+    const shareUrl = window.location.origin + window.location.pathname + hash;
    if (isTauri()) {
      await writeText(shareUrl);
    } else {
@@ -45,11 +45,13 @@ 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;
@@ -96,6 +98,7 @@ export function useSettings() {
    isPanelOpen: parseBoolean(state.isPanelOpen),
    userPatterns: userPatterns,
    multiChannelOrbits: parseBoolean(state.multiChannelOrbits),
+    includePrebakeScriptInShare: parseBoolean(state.includePrebakeScriptInShare),
    patternAutoStart: isUdels()
      ? false
      : state.patternAutoStart === undefined
@@ -108,6 +111,8 @@ 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
Aria	48231ea12a	Merge branch 'main' into glossing/midin-channels	2025-12-07 21:23:57 +01:00
Aria	c8a442234e	Merge pull request 'Feat: Transient shaper' (#1777 ) from glossing/transient-processor into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1777	2025-12-07 21:23:42 +01:00
Aria	efda32eedb	Merge branch 'main' into glossing/transient-processor	2025-12-07 20:29:50 +01:00
Aria	95d04d1149	Merge branch 'main' into glossing/midin-channels	2025-12-07 20:29:39 +01:00
Aria	358b1e3f56	Make sure processor turns off; fix array sizes for JIT	2025-12-07 13:28:57 -06:00
Aria	fe7e8f7add	Clearer docstring	2025-12-07 13:21:06 -06:00
Aria	45d329d3d1	Merge pull request 'Add vel as a synonym for velocity & update a few docstrings' (#1781 ) from glossing/controls-various into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1781	2025-12-07 19:15:42 +01:00
Aria	5e99393f5a	Merge branch 'main' into glossing/controls-various	2025-12-07 18:54:18 +01:00
Aria	9650c8eb50	Merge pull request '[perf] fix phaser leak of unused biquads' (#1800 ) from jeromew/strudel:fix-perf10 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1800 Reviewed-by: Aria <glossing@noreply.codeberg.org>	2025-12-07 18:53:03 +01:00
Aria	fab8d2193d	Merge branch 'main' into glossing/midin-channels	2025-12-07 18:45:16 +01:00
Aria	150835aa4d	Merge branch 'main' into glossing/transient-processor	2025-12-07 18:45:11 +01:00
Aria	76237016a3	Merge branch 'main' into glossing/controls-various	2025-12-07 18:45:02 +01:00
Aria	6f4d8ebacf	Merge branch 'main' into fix-perf10	2025-12-07 18:44:47 +01:00
Aria	3cecf4a50e	Merge pull request 'Bug fix: Remove failing tests due to shabda removal' (#1820 ) from glossing/shabda-test-fix into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1820	2025-12-07 18:42:49 +01:00
Aria	16b5faf333	Removing failing tests due to shabda removal	2025-12-07 11:23:55 -06:00
Aria	c4826b7dfb	Merge branch 'main' into glossing/midin-channels	2025-12-07 18:11:59 +01:00
Aria	bd61c1dc7e	Merge branch 'main' into glossing/transient-processor	2025-12-07 18:11:50 +01:00
Aria	ceb3aa797d	Merge branch 'main' into glossing/controls-various	2025-12-07 18:11:39 +01:00
Aria	9b3277da1c	Merge branch 'main' into fix-perf10	2025-12-07 18:09:00 +01:00
jeromew	0b711e879c	Improve naming & backward compat	2025-12-04 08:23:36 +00:00
Aria	e01621d0cc	Merge pull request 'Feature: Eight FMs' (#1628 ) from glossing/strudel:glossing/fmsss into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1628	2025-12-03 18:27:27 +01:00
Aria	196f70ab6b	Formatting	2025-12-03 11:13:21 -06:00
Aria	1d4f2b81d8	Switch back to explicit exports and use new release mechanism	2025-12-03 11:12:30 -06:00
Aria	d28c8dac8e	Merge branch 'main' into glossing/fmsss	2025-12-03 10:42:35 -06:00
Aria	eb18648a2a	Merge pull request '[perf] release unused AudioBufferSourceNode + releaseAudioNode' (#1805 ) from jeromew/strudel:fix-perf11 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1805 Reviewed-by: Aria <glossing@noreply.codeberg.org>	2025-12-03 17:35:03 +01:00
jeromew	0ec9826de5	onceEnded mechanism to clean audioNode.onended callbacks	2025-12-02 09:29:50 +00:00
jeromew	af7855402f	Accept non-instanciated nodes for better developer experience	2025-12-01 20:43:55 +00:00
jeromew	68b1cb87ca	[perf] release unused AudioBufferSourceNode + releaseAudioNode	2025-12-01 15:29:19 +00:00
jeromew	b65cc2128f	[perf] fix phaser leak of unused biquads	2025-11-29 14:47:03 +00:00
froos	7a3e0fd3fe	Merge pull request 'added export to getSuperdoughAudioController() so that its possible to route superdough audio through other webaudio applications.' (#1796 ) from ndr0n/strudel:exportSuperdoughAudioController into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1796	2025-11-29 01:00:41 +01:00
Alex McLean	4061dd4cf8	Merge pull request 'add revv() for reversing whole patterns' (#1791 ) from revv into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1791	2025-11-28 23:26:19 +01:00
alex	b523205590	Merge branch 'revv' of ssh://codeberg.org/uzu/strudel into revv	2025-11-28 22:03:32 +00:00
alex	956598da18	snapshot	2025-11-28 22:03:21 +00:00
Alex McLean	e011f3b982	Merge branch 'main' into revv	2025-11-28 22:37:03 +01:00
alex	cb591815ed	fix copy paste errors	2025-11-28 21:35:35 +00:00
Alex McLean	6a4fd27f5b	Merge branch 'main' into exportSuperdoughAudioController	2025-11-28 22:32:10 +01:00
Aria	d30df8d4cf	Merge pull request '[perf] Disconnect lfos for phaser and filters' (#1787 ) from glossing/perf-lfos into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1787	2025-11-28 20:19:14 +01:00
Aria	e10cd22c26	Merge branch 'main' into glossing/perf-lfos	2025-11-28 19:59:51 +01:00
Aria	18dc4944bf	Typos and cleanup	2025-11-28 12:36:23 -06:00
ndr0n	a6008e2700	added export to getSuperdoughAudioController() so that its possible to route superdough audio on external application integrations.	2025-11-28 04:03:48 +00:00
froos	2f8cabbb6b	Merge pull request 'fix: return silence when no pattern is returned' (#1795 ) from fix-empty-pattern into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1795	2025-11-27 23:08:50 +01:00
Felix Roos	ec26392509	fix: return silence when no pattern is returned	2025-11-27 22:53:38 +01:00
froos	30cd486f37	Merge pull request 'fix(tool/dbpatch): add missing package name' (#1765 ) from peterpf/strudel:bugfix/add-package-name-for-dbpatch into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1765	2025-11-27 22:47:01 +01:00
froos	cde0520ed9	Merge pull request 'add CHANGELOG.md + basic script to generate' (#1794 ) from changelog into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1794	2025-11-27 22:38:04 +01:00
Felix Roos	405338e4f0	add CHANGELOG.md + basic script to generate	2025-11-27 22:25:32 +01:00
froos	afbcaa54d0	Merge pull request '[perf] in `noise`, let noiseMix do the disconnect when it exists' (#1783 ) from jeromew/strudel:fix-perf9 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1783	2025-11-27 22:03:51 +01:00
froos	6a1c6081e0	Merge pull request 'Bug Fix: Retries for sounds tab' (#1754 ) from glossing/sounds-tab-preview into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1754	2025-11-27 22:01:00 +01:00
Felix Roos	3c4ba667c8	cleanup	2025-11-27 21:29:37 +01:00
Felix Roos	7fcb5262b8	Merge remote-tracking branch 'origin/main' into glossing/sounds-tab-preview	2025-11-27 21:14:22 +01:00
Felix Roos	b824c45ba4	Merge remote-tracking branch 'origin/main' into glossing/sounds-tab-preview	2025-11-27 21:11:50 +01:00
froos	e47e6c87fc	Merge pull request '[hydra] return the hydra object when await initHydra(..) is called' (#1784 ) from jeromew/strudel:return-hydra into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1784	2025-11-27 20:36:44 +01:00
froos	69b5ba89cb	Merge pull request 'Use errorLogger for query and tonal errors' (#1782 ) from glossing/query-error into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1782	2025-11-27 20:36:12 +01:00
froos	33a51761ce	Merge pull request '[perf] level 5 `connect-leak` on `vowel`' (#1779 ) from jeromew/strudel:fix-perf7 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1779	2025-11-27 20:27:09 +01:00
Alex McLean	f4b1baac87	add revv() for reversing whole patterns	2025-11-27 15:34:18 +00:00
Peter Egger	d217119391	fix(tool/dbpatch): add missing package name	2025-11-26 19:48:48 +01:00
Switch Angel AKA Jade Rose	d5d6284a90	Merge pull request 'feat: add prebake script import button for loading .strudel files' (#1774 ) from pre_eval into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1774	2025-11-26 08:23:37 +01:00
Switch Angel AKA Jade Rose	fb790de26c	Merge branch 'main' into pre_eval	2025-11-26 08:05:05 +01:00
Aria	ec6f6a1f1c	Merge pull request 'Fix Sampler port trampling' (#1717 ) from Dayglo/strudel:fix-port-trampling into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1717 Reviewed-by: Aria <glossing@noreply.codeberg.org>	2025-11-26 07:39:27 +01:00
W-A-James	a126bc9b86	Fix lint	2025-11-25 22:20:55 -05:00
Aria	a5c7fcc136	Add back options code (will resolve in another PR)	2025-11-25 22:16:23 -05:00
Aria	d70b758065	Remove base url from sample server and properly handle url schemes	2025-11-25 22:16:11 -05:00
W-A-James	9fdba6374c	remove extraneous eslint ignore directive	2025-11-25 22:14:19 -05:00
W-A-James	af90baea33	Fix trampling of port env variable	2025-11-25 22:14:15 -05:00
Aria	692359309f	Typo and formatting	2025-11-25 17:31:11 -06:00
Aria	d65b908bda	Disconnect lfos for phaser and filters	2025-11-25 17:27:37 -06:00
Aria	743e239e52	Merge pull request 'Feat: Hook up octave and fix example' (#1773 ) from glossing/hook-up-octave into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1773	2025-11-25 20:59:08 +01:00
Aria	f44a96a5ce	Merge branch 'main' into glossing/hook-up-octave	2025-11-25 20:50:49 +01:00
Aria	b94a686394	Merge pull request '[perf] fix `connect-leak` in `tremolo` param' (#1780 ) from jeromew/strudel:fix-perf8 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1780 Reviewed-by: Aria <glossing@noreply.codeberg.org>	2025-11-25 20:48:07 +01:00
Aria	728552b669	Merge branch 'main' into fix-perf8	2025-11-25 20:30:18 +01:00
Aria	8b427bc1dd	Add oct synonym	2025-11-25 13:19:39 -06:00
Aria	ae47d767ce	Merge branch 'main' into glossing/hook-up-octave	2025-11-25 20:02:43 +01:00
jeromew	ab64451d65	[hydra] return the hydra object when await initHydra(..) is called	2025-11-25 10:49:30 +00:00
jeromew	89da9bbdb0	[perf] in `noise`, let noiseMix do the disconnect when it exists	2025-11-25 10:31:53 +00:00
Aria	2bc208d8f5	Use errorLogger for query and tonal errors	2025-11-24 19:05:42 -06:00
Aria	39e7f70079	Remove synonym	2025-11-24 18:44:29 -06:00
Aria	7e5a907ce5	Add a few more functions to autocomplete	2025-11-24 18:41:25 -06:00
Aria	d7afb8a6c0	Add register example	2025-11-24 18:01:20 -06:00
Aria	a278f21f1b	Allow register in autocomplete, add vel as synonym for velocity, fix some controls	2025-11-24 17:52:00 -06:00
Switch Angel AKA Jade Rose	cfeff26d42	Merge pull request 'filter modulation improvements!' (#1769 ) from filter_mod_improvements into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1769	2025-11-24 17:51:19 +01:00
jeromew	e60ecba393	Merge branch 'fix-perf8' of https://codeberg.org/jeromew/strudel into fix-perf8	2025-11-24 16:36:14 +00:00
jeromew	f0d49e0e22	[perf] fix `connect-leak` from audioworklet=>param in lfo/tremolo	2025-11-24 16:35:48 +00:00
Jade (Rose) Rowland	7ee6b933cc	add tests	2025-11-24 11:33:21 -05:00
jeromew	a3947d1ccf	[perf] fix `connect-leak` from audioworklet=>param in lfo/tremolo	2025-11-24 16:33:20 +00:00
Jade (Rose) Rowland	e86850b6d8	frequency mod	2025-11-24 11:19:49 -05:00
jeromew	89a6efb69e	[perf] level 5 `connect-leak` on `vowel`	2025-11-24 16:10:00 +00:00
Jade (Rose) Rowland	31c694b596	Merge branch 'main' into filter_mod_improvements	2025-11-24 10:44:11 -05:00
Jade (Rose) Rowland	7a4babf6e1	format	2025-11-24 10:40:16 -05:00
Jade (Rose) Rowland	d5e5ab83ac	fix style	2025-11-24 10:39:37 -05:00
Aria	36587ae747	Switch back to original version	2025-11-23 22:55:36 -06:00
Aria	6c01c16a0c	Fix typo	2025-11-23 22:39:21 -06:00
Aria	be36898803	Formatting and examples	2025-11-23 22:29:33 -06:00
Aria	df047fd48d	Optimizations	2025-11-23 22:28:10 -06:00
Aria	68840de188	Working version	2025-11-23 20:58:28 -06:00
Aria	020a6bc75f	First pass at transient processor	2025-11-23 20:31:31 -06:00
Jade (Rose) Rowland	20016fd9aa	update hash	2025-11-23 20:25:13 -05:00
Aria	7bc6fcbf2a	Add channel support to midi in	2025-11-23 18:24:48 -06:00
Switch Angel AKA Jade Rose	132a124644	Merge pull request 'Add o as a synonym for orbit' (#1766 ) from jade/orbitsynonym into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1766 Reviewed-by: Aria <glossing@noreply.codeberg.org>	2025-11-24 01:20:52 +01:00
Jade (Rose) Rowland	4caacb0de1	only eval if script	2025-11-23 19:12:28 -05:00
Jade (Rose) Rowland	8325b4cfc4	Merge branch 'main' into jade/orbitsynonym	2025-11-23 19:06:16 -05:00
Jade (Rose) Rowland	3b2df0b725	synonym:	2025-11-23 19:05:57 -05:00
Jade (Rose) Rowland	f80fdbc38a	Merge branch 'pre_eval' of ssh://codeberg.org/uzu/strudel into pre_eval	2025-11-23 18:59:26 -05:00
Jade (Rose) Rowland	3a7b237765	change variable name	2025-11-23 18:59:16 -05:00
Switch Angel AKA Jade Rose	f5af55b63b	Merge branch 'main' into pre_eval	2025-11-24 00:47:37 +01:00
Jade (Rose) Rowland	d5dfbd7aa4	cleanup	2025-11-23 18:45:13 -05:00
Jade (Rose) Rowland	6221099af8	working	2025-11-23 18:09:38 -05:00
froos	22f1512697	Merge pull request '[perf] fix `connect-leak` in `fm` modulation' (#1758 ) from jeromew/strudel:fix-perf6 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1758	2025-11-23 22:23:24 +01:00
Aria	6c0d550b6b	Fix example	2025-11-23 12:25:40 -06:00
Aria	cf12e3e1d8	Hook up the octave control	2025-11-23 12:21:55 -06:00
froos	9a05a679aa	Merge pull request 'Fix interoperability issue between `all` and `await initHydra()`' (#1663 ) from jeromew/strudel:jeromew-hydra-all into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1663	2025-11-23 09:47:22 +01:00
Switch Angel AKA Jade Rose	321e76166a	Merge branch 'main' into filter_mod_improvements	2025-11-23 06:35:22 +01:00
Jade (Rose) Rowland	bde17594ce	test	2025-11-23 00:33:52 -05:00
Jade (Rose) Rowland	7bbb653963	fixed	2025-11-22 23:42:20 -05:00
Jade (Rose) Rowland	30e672a027	wip	2025-11-22 22:49:23 -05:00
Aria	f7f3aa7668	Merge pull request 'Bug fix: Swap l/r gains with temp variable' (#1768 ) from glossing/stereo-bug into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1768	2025-11-23 04:23:04 +01:00
Aria	adc3a9ac6c	Swap with temp variable	2025-11-22 20:51:30 -06:00
Switch Angel AKA Jade Rose	2518b2aed2	Merge pull request 'FIX: prevent LFO filter modulation from popping from negative values' (#1767 ) from lpmod_improvements into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1767	2025-11-23 00:52:27 +01:00
Jade (Rose) Rowland	1d5f3a4f30	prevent filter modulation pops	2025-11-22 18:21:24 -05:00
Jade (Rose) Rowland	2efd56e331	add synonym	2025-11-22 18:10:28 -05:00
Switch Angel AKA Jade Rose	5fa6cb4653	Merge pull request 'prefix "S" for solo' (#1481 ) from solo into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1481	2025-11-23 00:03:31 +01:00
Jade (Rose) Rowland	19fd0fc649	rm unessecary file	2025-11-22 17:17:41 -05:00
Jade (Rose) Rowland	e72e26eb81	add comment	2025-11-22 17:11:17 -05:00
Jade (Rose) Rowland	1c4b05d55f	solo search n = 1	2025-11-22 16:40:31 -05:00
jeromew	d453c861d3	Merge branch 'fix-perf6' of https://codeberg.org/jeromew/strudel into fix-perf6	2025-11-21 09:01:02 +00:00
jeromew	f637b8b0dd	[perf] fix `connect-leak` in fm modulation	2025-11-21 09:00:17 +00:00
Aria	06bf17f444	Merge pull request 'Bug Fix: Use frac due to negative frequencies from FM' (#1759 ) from glossing/droponelettertosaveears into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1759	2025-11-21 01:56:10 +01:00
Aria	21543956c6	Also for wavetable	2025-11-20 18:30:53 -06:00
Aria	4758effdc6	Use frac due to negative frequencies from FM	2025-11-20 18:22:44 -06:00
froos	6f58e74bea	Merge pull request '[perf] fix `connect-leak` added by #1742 when noise() is not used' (#1757 ) from jeromew/strudel:fix-perf5 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1757	2025-11-20 19:48:15 +01:00
jeromew	907f03f3bf	[perf] fix `connect-leak` in fm modulation	2025-11-20 17:40:51 +00:00
jeromew	0435711051	[perf] fix `connect-leak` added by #1742 when noise() is not used	2025-11-20 17:36:00 +00:00
froos	8f6718b9e8	Merge pull request '[perf] fix `connect-leak` in `delay` effect' (#1755 ) from jeromew/strudel:fix-perf4 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1755	2025-11-20 14:50:59 +01:00
froos	aa77255d98	Merge pull request '[perf] fix `connect leak` when .noise() is in the mix' (#1742 ) from jeromew/strudel:fix-perf3 into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1742	2025-11-20 14:49:40 +01:00
jeromew	7267990e20	Fix codeformat	2025-11-20 13:35:37 +00:00
jeromew	387e5db0fe	Merge branch 'fix-perf3' of https://codeberg.org/jeromew/strudel into fix-perf3	2025-11-20 13:24:03 +00:00
jeromew	d9f63b8dfa	[perf] fix `connect leak` when .noise() is in the mix	2025-11-20 13:21:09 +00:00
jeromew	8ed72b4573	[perf] fix `connect-leak` in `delay` effect	2025-11-20 13:05:41 +00:00
Aria	74488f8480	Stray log message	2025-11-19 18:41:56 -06:00
Aria	8144ec46bd	Attempt system for sounds tab previews	2025-11-19 18:35:35 -06:00
Felix Roos	dd2c808cd7	hotfix: reduce sounds-tab click to play latency	2025-11-19 21:55:35 +01:00
Alex McLean	389a63a850	Merge pull request 'wchooseCycles has now notes in an example' (#1748 ) from scrappy_fiddler/strudel:documentation into main Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1748	2025-11-18 23:52:43 +01:00
Aria	654c1a86f0	Simplify declarations via globalThis; fix cleanup/stop	2025-11-18 16:02:33 -06:00
scrappy_fiddler	99beb4454d	update snapshot with note example	2025-11-17 20:49:26 +01:00
scrappy_fiddler	30cc46ea66	wchooseCycles has now notes in an example	2025-11-17 20:04:40 +01:00
Aria	ac3f477f30	Merge branch 'main' into glossing/fmsss	2025-11-16 22:32:38 -06:00
Aria	573cd1ae41	Merge branch 'main' into glossing/fmsss	2025-11-16 22:23:31 -06:00
jeromew	bfa8fa3c75	[perf] fix `connect leak` when .noise() is in the mix	2025-11-16 09:23:11 +00:00
Aria	4c49cd9297	More examples	2025-10-18 11:24:56 -05:00
Aria	70d2da81d8	Merge branch 'main' into glossing/fmsss	2025-10-18 11:01:23 -05:00
jeromew	47c85f8540	fix interoperability of `all` with hydra Hydra add methods on Array.prototype which breaks the Array enumeration with for...in. Use for...of instead cf https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of#difference_between_for...of_and_for...in for details on the issue without this fix, it is impossible to use both `await initHydra()` and `all` in the same strudel code. Strudel errors with "Error: got "undefined" instead of pattern." example code: https://strudel.cc/#YXdhaXQgaW5pdEh5ZHJhKCkKCmFsbChwaWFub3JvbGwpCgokOiBzKCJiZCIp	2025-10-16 14:06:33 +02:00
Aria	bd73d96847	Cleanup	2025-10-03 18:49:49 -05:00
Aria	7cf9db4872	Big matrix refactor	2025-10-03 18:20:41 -05:00
Aria	c9381a11f9	Working version	2025-10-03 17:21:05 -05:00
Switch Angel AKA Jade Rose	f4cf77f5c6	Merge branch 'main' into solo	2025-09-30 08:09:37 +02:00
Felix Roos	7f103e77e3	prefix "S" for solo	2025-07-28 04:05:21 +02:00