fix: return silence when no pattern is returned

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
2026-07-14 06:43:47 -04:00 · 2025-11-27 22:53:38 +01:00 · 2025-11-27 22:47:01 +01:00 · 2025-11-27 22:38:04 +01:00 · 2025-11-27 22:25:32 +01:00 · 2025-11-27 22:03:51 +01:00
112 changed files with 10238 additions and 7183 deletions
@@ -0,0 +1,37 @@
+name: Build and Deploy to beta (warm.strudel.cc)
+
+on: [workflow_dispatch]
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: docker
+    env:
+      SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 9.12.2
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          # cache: "pnpm"
+      - name: Install Dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Deploy
+        run: |
+          eval $(ssh-agent -s)
+          echo "$SSH_PRIVATE_KEY" | ssh-add -
+          apt update && apt install -y rsync
+          mkdir ~/.ssh
+          ssh-keyscan matrix.toplap.org  > ~/.ssh/known_hosts
+          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/warm.strudel.cc
@@ -1,4 +1,4 @@
-name: Build and Deploy
+name: Build and Deploy to live (strudel.cc)

 on: [workflow_dispatch]

@@ -34,4 +34,4 @@ jobs:
          apt update && apt install -y rsync
          mkdir ~/.ssh
          ssh-keyscan matrix.toplap.org  > ~/.ssh/known_hosts
-          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy
+          rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/strudel.cc
@@ -45,6 +45,20 @@ tidal-drum-machines
 webaudiofontdata
 src-tauri/target

+
+
+### BEGIN Visual Studio Code ###
+# Blanket, recursive exclude for .vscode directory and files
+.vscode/**/*
+# Unexclude specific files and directories within .vscode
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+### END Visual Studio Code ###
+
+
+
 # BEGIN JetBrains -> END JetBrains

 # for JetBrains IDE users, e.g. WebStorm. Source: https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
@@ -0,0 +1 @@
+22
@@ -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) 
@@ -13,7 +13,7 @@ https://strudel.cc/

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

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

 const escapeHtml = (str) => {
  const div = document.createElement('div');
@@ -75,6 +80,53 @@ const isValidDoc = (doc) => {
 const hasExcludedTags = (doc) =>
  ['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag));

+export function bankCompletions() {
+  // TODO: FIX IMPORT
+  const soundDict = soundMap?.get() ?? {};
+
+  const banks = new Set();
+  for (const key of Object.keys(soundDict)) {
+    const [bank, suffix] = key.split('_');
+    if (suffix && bank) banks.add(bank);
+  }
+  return Array.from(banks)
+    .sort()
+    .map((name) => ({ label: name, type: 'bank' }));
+}
+
+// Attempt to get all scale names from Tonal TODO: FIX IMPORT
+let scaleCompletions = [];
+// try {
+//   scaleCompletions = (Scale.names ? Scale.names() : []).map((name) => ({ label: name, type: 'scale' }));
+// } catch (e) {
+//   console.warn('[autocomplete] Could not load scale names from Tonal:', e);
+// }
+
+// Valid mode values for voicing
+const modeCompletions = [
+  { label: 'below', type: 'mode' },
+  { label: 'above', type: 'mode' },
+  { label: 'duck', type: 'mode' },
+  { label: 'root', type: 'mode' },
+];
+
+// Valid chord symbols from ireal dictionary plus empty string for major triads
+const chordSymbols = ['', ...Object.keys(complex)].sort();
+const chordSymbolCompletions = chordSymbols.map((symbol) => {
+  if (symbol === '') {
+    return {
+      label: 'major',
+      apply: '',
+      type: 'chord-symbol',
+    };
+  }
+  return {
+    label: symbol,
+    apply: symbol,
+    type: 'chord-symbol',
+  };
+});
+
 export const getSynonymDoc = (doc, synonym) => {
  const synonyms = doc.synonyms || [];
  const docLabel = getDocLabel(doc);
@@ -113,19 +165,299 @@ const jsdocCompletions = (() => {
  return completions;
 })();

-export const strudelAutocomplete = (context) => {
-  const word = context.matchBefore(/\w*/);
-  if (word.from === word.to && !context.explicit) return null;
+// --- Handler functions for each context ---
+const pitchNames = [
+  'C',
+  'C#',
+  'Db',
+  'D',
+  'D#',
+  'Eb',
+  'E',
+  'E#',
+  'Fb',
+  'F',
+  'F#',
+  'Gb',
+  'G',
+  'G#',
+  'Ab',
+  'A',
+  'A#',
+  'Bb',
+  'B',
+  'B#',
+  'Cb',
+];

+// Cached regex patterns for scaleHandler
+const SCALE_NO_QUOTES_REGEX = /scale\(\s*$/;
+const SCALE_AFTER_COLON_REGEX = /scale\(\s*['"][^'"]*:[^'"]*$/;
+const SCALE_PRE_COLON_REGEX = /scale\(\s*['"][^'"]*$/;
+const SCALE_PITCH_MATCH_REGEX = /([A-Ga-g][#b]*)?$/;
+const SCALE_SPACES_TO_COLON_REGEX = /\s+/g;
+
+function scaleHandler(context) {
+  // First check for scale context without quotes - block with empty completions
+  let scaleNoQuotesContext = context.matchBefore(SCALE_NO_QUOTES_REGEX);
+  if (scaleNoQuotesContext) {
+    return {
+      from: scaleNoQuotesContext.to,
+      options: [],
+    };
+  }
+
+  // Check for after-colon context first (more specific)
+  let scaleAfterColonContext = context.matchBefore(SCALE_AFTER_COLON_REGEX);
+  if (scaleAfterColonContext) {
+    const text = scaleAfterColonContext.text;
+    const colonIdx = text.lastIndexOf(':');
+    if (colonIdx !== -1) {
+      const fragment = text.slice(colonIdx + 1);
+      const filteredScales = scaleCompletions.filter((s) => s.label.startsWith(fragment));
+      const options = filteredScales.map((s) => ({
+        ...s,
+        apply: s.label.replace(SCALE_SPACES_TO_COLON_REGEX, ':'),
+      }));
+      const from = scaleAfterColonContext.from + colonIdx + 1;
+      return {
+        from,
+        options,
+      };
+    }
+  }
+
+  // Then check for pre-colon context
+  let scalePreColonContext = context.matchBefore(SCALE_PRE_COLON_REGEX);
+  if (scalePreColonContext) {
+    if (!scalePreColonContext.text.includes(':')) {
+      if (context.explicit) {
+        const text = scalePreColonContext.text;
+        const match = text.match(SCALE_PITCH_MATCH_REGEX);
+        const fragment = match ? match[0] : '';
+        const filtered = pitchNames.filter((p) => p.toLowerCase().startsWith(fragment.toLowerCase()));
+        const from = scalePreColonContext.to - fragment.length;
+        const options = filtered.map((p) => ({ label: p, type: 'pitch' }));
+        return { from, options };
+      } else {
+        return { from: scalePreColonContext.to, options: [] };
+      }
+    }
+  }
+  return null;
+}
+
+// Cached regex patterns for soundHandler
+const SOUND_NO_QUOTES_REGEX = /(s|sound)\(\s*$/;
+const SOUND_WITH_QUOTES_REGEX = /(s|sound)\(\s*['"][^'"]*$/;
+const SOUND_FRAGMENT_MATCH_REGEX = /(?:[\s[{(<])([\w]*)$/;
+
+function soundHandler(context) {
+  // First check for sound context without quotes - block with empty completions
+  let soundNoQuotesContext = context.matchBefore(SOUND_NO_QUOTES_REGEX);
+  if (soundNoQuotesContext) {
+    return {
+      from: soundNoQuotesContext.to,
+      options: [],
+    };
+  }
+
+  // Then check for sound context with quotes - provide completions
+  let soundContext = context.matchBefore(SOUND_WITH_QUOTES_REGEX);
+  if (!soundContext) return null;
+
+  const text = soundContext.text;
+  const quoteIdx = Math.max(text.lastIndexOf('"'), text.lastIndexOf("'"));
+  if (quoteIdx === -1) return null;
+  const inside = text.slice(quoteIdx + 1);
+  const fragMatch = inside.match(SOUND_FRAGMENT_MATCH_REGEX);
+  const fragment = fragMatch ? fragMatch[1] : inside;
+  const soundNames = Object.keys(soundMap?.get() ?? {}).sort();
+  const filteredSounds = soundNames.filter((name) => name.includes(fragment));
+  let options = filteredSounds.map((name) => ({ label: name, type: 'sound' }));
+  const from = soundContext.to - fragment.length;
  return {
-    from: word.from,
-    options: jsdocCompletions,
-    /*     options: [
-      { label: 'match', type: 'keyword' },
-      { label: 'hello', type: 'variable', info: '(World)' },
-      { label: 'magic', type: 'text', apply: '⠁⭒*.✩.*⭒⠁', detail: 'macro' },
-    ], */
+    from,
+    options,
  };
+}
+
+// Cached regex patterns for bankHandler
+const BANK_NO_QUOTES_REGEX = /bank\(\s*$/;
+const BANK_WITH_QUOTES_REGEX = /bank\(\s*['"][^'"]*$/;
+
+function bankHandler(context) {
+  // First check for bank context without quotes - block with empty completions
+  let bankNoQuotesContext = context.matchBefore(BANK_NO_QUOTES_REGEX);
+  if (bankNoQuotesContext) {
+    return {
+      from: bankNoQuotesContext.to,
+      options: [],
+    };
+  }
+
+  // Then check for bank context with quotes - provide completions
+  let bankMatch = context.matchBefore(BANK_WITH_QUOTES_REGEX);
+  if (!bankMatch) return null;
+
+  const text = bankMatch.text;
+  const quoteIdx = Math.max(text.lastIndexOf('"'), text.lastIndexOf("'"));
+  if (quoteIdx === -1) return null;
+  const inside = text.slice(quoteIdx + 1);
+  const fragment = inside;
+  let banks = bankCompletions();
+  const filteredBanks = banks.filter((b) => b.label.startsWith(fragment));
+  const from = bankMatch.to - fragment.length;
+  return {
+    from,
+    options: filteredBanks,
+  };
+}
+
+// Cached regex patterns for modeHandler
+const MODE_NO_QUOTES_REGEX = /mode\(\s*$/;
+const MODE_AFTER_COLON_REGEX = /mode\(\s*['"][^'"]*:[^'"]*$/;
+const MODE_PRE_COLON_REGEX = /mode\(\s*['"][^'"]*$/;
+const MODE_FRAGMENT_MATCH_REGEX = /(?:[\s[{(<])([\w:]*)$/;
+
+function modeHandler(context) {
+  // First check for mode context without quotes - block with empty completions
+  let modeNoQuotesContext = context.matchBefore(MODE_NO_QUOTES_REGEX);
+  if (modeNoQuotesContext) {
+    return {
+      from: modeNoQuotesContext.to,
+      options: [],
+    };
+  }
+
+  // Check for after-colon context first (more specific)
+  let modeAfterColonContext = context.matchBefore(MODE_AFTER_COLON_REGEX);
+  if (modeAfterColonContext) {
+    const text = modeAfterColonContext.text;
+    const colonIdx = text.lastIndexOf(':');
+    if (colonIdx !== -1) {
+      const fragment = text.slice(colonIdx + 1);
+      // For anchor after colon, we can suggest pitch names
+      const filtered = pitchNames.filter((p) => p.toLowerCase().startsWith(fragment.toLowerCase()));
+      const options = filtered.map((p) => ({ label: p, type: 'pitch' }));
+      const from = modeAfterColonContext.from + colonIdx + 1;
+      return {
+        from,
+        options,
+      };
+    }
+  }
+
+  // Then check for pre-colon context
+  let modeContext = context.matchBefore(MODE_PRE_COLON_REGEX);
+  if (!modeContext) return null;
+
+  const text = modeContext.text;
+  const quoteIdx = Math.max(text.lastIndexOf('"'), text.lastIndexOf("'"));
+  if (quoteIdx === -1) return null;
+  const inside = text.slice(quoteIdx + 1);
+  const fragMatch = inside.match(MODE_FRAGMENT_MATCH_REGEX);
+  const fragment = fragMatch ? fragMatch[1] : inside;
+  const filteredModes = modeCompletions.filter((m) => m.label.startsWith(fragment));
+  const from = modeContext.to - fragment.length;
+  return {
+    from,
+    options: filteredModes,
+  };
+}
+
+// Cached regex patterns for chordHandler
+const CHORD_NO_QUOTES_REGEX = /chord\(\s*$/;
+const CHORD_WITH_QUOTES_REGEX = /chord\(\s*['"][^'"]*$/;
+const CHORD_FRAGMENT_MATCH_REGEX = /(?:[\s[{(<])([\w#b+^:-]*)$/;
+
+function chordHandler(context) {
+  // First check for chord context without quotes - block with empty completions
+  let chordNoQuotesContext = context.matchBefore(CHORD_NO_QUOTES_REGEX);
+  if (chordNoQuotesContext) {
+    return {
+      from: chordNoQuotesContext.to,
+      options: [],
+    };
+  }
+
+  // Then check for chord context with quotes - provide completions
+  let chordContext = context.matchBefore(CHORD_WITH_QUOTES_REGEX);
+  if (!chordContext) return null;
+
+  const text = chordContext.text;
+  const quoteIdx = Math.max(text.lastIndexOf('"'), text.lastIndexOf("'"));
+  if (quoteIdx === -1) return null;
+  const inside = text.slice(quoteIdx + 1);
+
+  // Use same fragment matching as sound/mode for expressions like "<G Am>"
+  const fragMatch = inside.match(CHORD_FRAGMENT_MATCH_REGEX);
+  const fragment = fragMatch ? fragMatch[1] : inside;
+
+  // Check if fragment contains any pitch name at start (for root + symbol)
+  let rootMatch = null;
+  let symbolFragment = fragment;
+  for (const pitch of pitchNames) {
+    if (fragment.toLowerCase().startsWith(pitch.toLowerCase())) {
+      rootMatch = pitch;
+      symbolFragment = fragment.slice(pitch.length);
+      break;
+    }
+  }
+
+  if (rootMatch) {
+    // We have a root, now complete chord symbols
+    const filteredSymbols = chordSymbolCompletions.filter((s) =>
+      s.label.toLowerCase().startsWith(symbolFragment.toLowerCase()),
+    );
+
+    // Create completions that replace the entire chord, not just the symbol part
+    const options = filteredSymbols;
+
+    const from = chordContext.to - symbolFragment.length;
+    return { from, options };
+  } else {
+    // No root yet, complete with pitch names
+    const filteredPitches = pitchNames.filter((p) => p.toLowerCase().startsWith(fragment.toLowerCase()));
+    const options = filteredPitches.map((p) => ({ label: p, type: 'pitch' }));
+    const from = chordContext.to - fragment.length;
+    return { from, options };
+  }
+}
+
+// Cached regex patterns for fallbackHandler
+const FALLBACK_WORD_REGEX = /\w*/;
+
+function fallbackHandler(context) {
+  const word = context.matchBefore(FALLBACK_WORD_REGEX);
+  if (word && word.from === word.to && !context.explicit) return null;
+  if (word) {
+    return {
+      from: word.from,
+      options: jsdocCompletions,
+    };
+  }
+  return null;
+}
+
+const handlers = [
+  soundHandler,
+  bankHandler,
+  chordHandler,
+  scaleHandler,
+  modeHandler,
+  // this handler *must* be last
+  fallbackHandler,
+];
+
+export const strudelAutocomplete = (context) => {
+  for (const handler of handlers) {
+    const result = handler(context);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
 };

 export const isAutoCompletionEnabled = (enabled) =>
@@ -1,30 +1,31 @@
 import { closeBrackets } from '@codemirror/autocomplete';
-export { toggleComment, toggleBlockComment, toggleLineComment, toggleBlockCommentByLine } from '@codemirror/commands';
-// import { search, highlightSelectionMatches } from '@codemirror/search';
-import { indentWithTab } from '@codemirror/commands';
+import { indentWithTab, toggleLineComment } from '@codemirror/commands';
 import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
-import { defaultHighlightStyle, syntaxHighlighting, bracketMatching } from '@codemirror/language';
+import { bracketMatching, defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
 import { Compartment, EditorState, Prec } from '@codemirror/state';
 import {
+  drawSelection,
  EditorView,
-  highlightActiveLineGutter,
  highlightActiveLine,
+  highlightActiveLineGutter,
  keymap,
  lineNumbers,
-  drawSelection,
 } from '@codemirror/view';
-import { repl, registerControl } from '@strudel/core';
-import { Drawer, cleanupDraw } from '@strudel/draw';
+import { persistentAtom } from '@nanostores/persistent';
+import { logger, registerControl, repl } from '@strudel/core';
+import { cleanupDraw, Drawer } from '@strudel/draw';
+
 import { isAutoCompletionEnabled } from './autocomplete.mjs';
-import { isTooltipEnabled } from './tooltip.mjs';
+import { basicSetup } from './basicSetup.mjs';
 import { flash, isFlashEnabled } from './flash.mjs';
 import { highlightMiniLocations, isPatternHighlightingEnabled, updateMiniLocations } from './highlight.mjs';
 import { keybindings } from './keybindings.mjs';
-import { initTheme, activateTheme, theme } from './themes.mjs';
 import { sliderPlugin, updateSliderWidgets } from './slider.mjs';
-import { widgetPlugin, updateWidgets } from './widget.mjs';
-import { persistentAtom } from '@nanostores/persistent';
-import { basicSetup } from './basicSetup.mjs';
+import { activateTheme, initTheme, theme } from './themes.mjs';
+import { isTooltipEnabled } from './tooltip.mjs';
+import { updateWidgets, widgetPlugin } from './widget.mjs';
+
+export { toggleBlockComment, toggleBlockCommentByLine, toggleComment, toggleLineComment } from '@codemirror/commands';

 const extensions = {
  isLineWrappingEnabled: (on) => (on ? EditorView.lineWrapping : []),
@@ -94,8 +95,8 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
      }),
      sliderPlugin,
      widgetPlugin,
-      // indentOnInput(), // works without. already brought with javascript extension?
-      // bracketMatching(), // does not do anything
+      // indentOnInput(), // works without. already brought with javascript
+      // extension? bracketMatching(), // does not do anything
      syntaxHighlighting(defaultHighlightStyle),
      EditorView.updateListener.of((v) => onChange(v)),
      drawSelection({ cursorBlinkRate: 0 }),
@@ -119,13 +120,13 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
            run: () => onStop?.(),
          },
          /* {
-          key: 'Ctrl-Shift-.',
-          run: () => (onPanic ? onPanic() : onStop?.()),
-        },
-        {
-          key: 'Ctrl-Shift-Enter',
-          run: () => (onReEvaluate ? onReEvaluate() : onEvaluate?.()),
-        }, */
+            key: 'Ctrl-Shift-.',
+            run: () => (onPanic ? onPanic() : onStop?.()),
+          },
+          {
+            key: 'Ctrl-Shift-Enter',
+            run: () => (onReEvaluate ? onReEvaluate() : onEvaluate?.()),
+          }, */
        ]),
      ),
    ],
@@ -206,7 +207,8 @@ export class StrudelMirror {
        updateWidgets(this.editor, widgets);
        updateMiniLocations(this.editor, this.miniLocations);
        replOptions?.afterEval?.(options);
-        // if no painters are set (.onPaint was not called), then we only need the present moment (for highlighting)
+        // if no painters are set (.onPaint was not called), then we only need
+        // the present moment (for highlighting)
        const drawTime = options.pattern.getPainters().length ? this.drawTime : [0, 0];
        this.drawer.setDrawTime(drawTime);
        // invalidate drawer after we've set the appropriate drawTime
@@ -245,6 +247,33 @@ export class StrudelMirror {
      }
    };
    document.addEventListener('start-repl', this.onStartRepl);
+
+    // Handle global evaluation requests (e.g., from Vim :w)
+    this.onEvaluateRequest = (e) => {
+      try {
+        // Evaluate current editor on repl-evaluate
+        logger('[repl] evaluate via event');
+        this.evaluate();
+        e?.cancelable && e.preventDefault?.();
+      } catch (err) {
+        console.error('Error handling repl-evaluate event', err);
+      }
+    };
+    document.addEventListener('repl-evaluate', this.onEvaluateRequest);
+    document.addEventListener('repl-stop', this.onStopRequest);
+
+    // Toggle comments requested from Vim (gc)
+    this.onToggleComment = (e) => {
+      try {
+        // Honor selections; toggleLineComment handles both selections and
+        // single line
+        toggleLineComment(this.editor);
+        e?.cancelable && e.preventDefault?.();
+      } catch (err) {
+        console.error('Error handling repl-toggle-comment event', err);
+      }
+    };
+    document.addEventListener('repl-toggle-comment', this.onToggleComment);
  }
  draw(haps, time, painters) {
    painters?.forEach((painter) => painter(this.drawContext, time, haps, this.drawTime));
@@ -271,6 +300,16 @@ export class StrudelMirror {
  async stop() {
    this.repl.scheduler.stop();
  }
+
+  // Listen for global stop requests (e.g., from Vim :q)
+  onStopRequest = (e) => {
+    try {
+      this.stop();
+      e?.cancelable && e.preventDefault?.();
+    } catch (err) {
+      console.error('Error handling repl-stop event', err);
+    }
+  };
  async toggle() {
    if (this.repl.scheduler.started) {
      this.repl.stop();
@@ -346,11 +385,18 @@ export class StrudelMirror {
    }
  }
  setCode(code) {
-    const changes = { from: 0, to: this.editor.state.doc.length, insert: code };
+    const changes = {
+      from: 0,
+      to: this.editor.state.doc.length,
+      insert: code,
+    };
    this.editor.dispatch({ changes });
  }
  clear() {
    this.onStartRepl && document.removeEventListener('start-repl', this.onStartRepl);
+    this.onEvaluateRequest && document.removeEventListener('repl-evaluate', this.onEvaluateRequest);
+    this.onStopRequest && document.removeEventListener('repl-stop', this.onStopRequest);
+    this.onToggleComment && document.removeEventListener('repl-toggle-comment', this.onToggleComment);
  }
  getCursorLocation() {
    return this.editor.state.selection.main.head;
@@ -1,11 +1,12 @@
+import { defaultKeymap } from '@codemirror/commands';
 import { Prec } from '@codemirror/state';
 import { keymap, ViewPlugin } from '@codemirror/view';
 // import { searchKeymap } from '@codemirror/search';
 import { emacs } from '@replit/codemirror-emacs';
-import { vim } from '@replit/codemirror-vim';
+import { vim, Vim } from '@replit/codemirror-vim';
 // import { vim } from './vim_test.mjs';
 import { vscodeKeymap } from '@replit/codemirror-vscode-keymap';
-import { defaultKeymap } from '@codemirror/commands';
+import { logger } from '@strudel/core';

 const vscodePlugin = ViewPlugin.fromClass(
  class {
@@ -19,6 +20,110 @@ const vscodePlugin = ViewPlugin.fromClass(
 );
 const vscodeExtension = (options) => [vscodePlugin].concat(options ?? []);

+// Map Vim :w to trigger the same action as evaluation. We dispatch a custom
+// event 'repl-evaluate' that the editor listens for, and also simulate
+// Ctrl+Enter/Alt+Enter as a fallback. We log to the Strudel logger so it
+// appears in the Console panel.
+try {
+  if (Vim && typeof Vim.defineEx === 'function') {
+    // Map gc to toggle line comments by dispatching a custom event that our
+    // CodeMirror integration listens to. This avoids depending on Vim's
+    // internal actions and works with current selections/visual mode.
+    try {
+      Vim.defineAction('strudelToggleComment', (cm) => {
+        const view = cm?.view || cm;
+        try {
+          const ev = new CustomEvent('repl-toggle-comment', { detail: { source: 'vim', view }, cancelable: true });
+          document.dispatchEvent(ev);
+        } catch (e) {
+          console.error('strudelToggleComment dispatch failed', e);
+        }
+      });
+      Vim.mapCommand('gc', 'action', 'strudelToggleComment', {}, { context: 'normal' });
+      Vim.mapCommand('gc', 'action', 'strudelToggleComment', {}, { context: 'visual' });
+    } catch (e) {
+      console.error('Vim gc mapping failed', e);
+    }
+
+    // :q to pause/stop
+    Vim.defineEx('quit', 'q', (cm) => {
+      try {
+        const view = cm?.view || cm;
+        // First try dispatching our custom stop event, then fallback to Alt+.
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-stop', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false;
+        } catch (e) {
+          console.error('Error dispatching repl-stop event', e);
+        }
+        if (!handled) {
+          const altDot = new KeyboardEvent('keydown', {
+            key: '.',
+            code: 'Period',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altDot);
+        }
+      } catch (e) {
+        console.error('Error dispatching :q stop event', e);
+      }
+    });
+
+    // :w to evaluate
+    Vim.defineEx('write', 'w', (cm) => {
+      const view = cm?.view || cm; // CM6 Vim passes either an object with view or the view itself
+      try {
+        view?.focus?.();
+        // Let the app know this came from Vim :w
+        try {
+          logger('[vim] :w — evaluating code');
+        } catch (e) {
+          console.error('Error logging Vim :w evaluation', e);
+        }
+        // Dispatch a dedicated evaluate event first
+        let handled = false;
+        try {
+          const ev = new CustomEvent('repl-evaluate', { detail: { source: 'vim', view }, cancelable: true });
+          handled = document.dispatchEvent(ev) === false; // false means preventDefault was called
+        } catch (e) {
+          console.error('Error dispatching repl-evaluate event', e);
+        }
+        if (handled) {
+          return;
+        }
+        // Try Ctrl+Enter first if not handled by custom event
+        const ctrlEnter = new KeyboardEvent('keydown', {
+          key: 'Enter',
+          code: 'Enter',
+          ctrlKey: true,
+          bubbles: true,
+          cancelable: true,
+        });
+        view?.dom?.dispatchEvent?.(ctrlEnter);
+        // If not handled (no handler called preventDefault), try Alt+Enter as
+        // fallback
+        if (!ctrlEnter.defaultPrevented) {
+          const altEnter = new KeyboardEvent('keydown', {
+            key: 'Enter',
+            code: 'Enter',
+            altKey: true,
+            bubbles: true,
+            cancelable: true,
+          });
+          view?.dom?.dispatchEvent?.(altEnter);
+        }
+      } catch (e) {
+        console.error('Error dispatching :w evaluation event', e);
+      }
+    });
+  }
+} catch (e) {
+  console.error('Vim ex command setup failed (defineEx missing or Vim unavailable)', e);
+}
+
 const keymaps = {
  vim,
  emacs,
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/codemirror",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Codemirror Extensions for Strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -46,10 +46,16 @@
    "@replit/codemirror-vscode-keymap": "^6.0.2",
    "@strudel/core": "workspace:*",
    "@strudel/draw": "workspace:*",
+    "@strudel/tonal": "workspace:*",
    "@strudel/transpiler": "workspace:*",
-    "nanostores": "^0.11.3"
+    "@tonaljs/tonal": "^4.10.0",
+    "nanostores": "^0.11.3",
+    "superdough": "workspace:*"
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1288,6 +1288,196 @@ export const { fanchor } = registerControl('fanchor');
 */
 // currently an alias of 'hcutoff' https://codeberg.org/uzu/strudel/issues/496
 // ['hpf'],
+
+/**
+ * Rate of the LFO for the lowpass filter
+ *
+ * @name lprate
+ * @param {number | Pattern} rate rate in hertz
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lprate("<4 8 2 1>")
+ */
+export const { lprate } = registerControl('lprate');
+
+/**
+ * Cycle-synced rate of the LFO for the lowpass filter
+ *
+ * @name lpsync
+ * @param {number | Pattern} rate rate in cycles
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpsync("<4 8 2 1>")
+ */
+export const { lpsync } = registerControl('lpsync');
+
+/**
+ * Depth of the LFO for the lowpass filter
+ *
+ * @name lpdepth
+ * @param {number | Pattern} depth depth of modulation
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpdepth("<1 .5 1.8 0>")
+ */
+
+export const { lpdepth } = registerControl('lpdepth');
+/**
+ * Depth of the LFO for the lowpass filter, in HZ
+ *
+ * @name lpdepthfrequency
+ * @synonyms
+ * lpdethfreq
+ * @param {number | Pattern} depth depth of modulation
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).lpdepthfrequency("<200 500 100 0>")
+ */
+
+export const { lpdepthfrequency } = registerControl('lpdepthfrequency', 'lpdepthfreq');
+
+/**
+ * Shape of the LFO for the lowpass filter
+ *
+ * @name lpshape
+ * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
+ */
+export const { lpshape } = registerControl('lpshape');
+
+/**
+ * DC offset of the LFO for the lowpass filter
+ *
+ * @name lpdc
+ * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
+ */
+export const { lpdc } = registerControl('lpdc');
+
+/**
+ * Skew of the LFO for the lowpass filter
+ *
+ * @name lpskew
+ * @param {number | Pattern} skew How much to bend the LFO shape
+ */
+export const { lpskew } = registerControl('lpskew');
+
+/**
+ * Rate of the LFO for the bandpass filter
+ *
+ * @name bprate
+ * @param {number | Pattern} rate rate in hertz
+ */
+export const { bprate } = registerControl('bprate');
+
+/**
+ * Cycle-synced rate of the LFO for the bandpass filter
+ *
+ * @name bpsync
+ * @param {number | Pattern} rate rate in cycles
+ */
+export const { bpsync } = registerControl('bpsync');
+
+/**
+ * Depth of the LFO for the bandpass filter
+ *
+ * @name bpdepth
+ * @param {number | Pattern} depth depth of modulation
+ */
+export const { bpdepth } = registerControl('bpdepth');
+
+/**
+ * Depth of the LFO for the bandpass filter, in HZ
+ *
+ * @name bpdepthfrequency
+ * @synonyms
+ * bpdethfreq
+ * @param {number | Pattern} depth depth of modulation
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).bpdepthfrequency("<200 500 100 0>")
+ */
+
+export const { bpdepthfrequency } = registerControl('bpdepthfrequency', 'bpdepthfreq');
+
+/**
+ * Shape of the LFO for the bandpass filter
+ *
+ * @name bpshape
+ * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
+ */
+export const { bpshape } = registerControl('bpshape');
+
+/**
+ * DC offset of the LFO for the bandpass filter
+ *
+ * @name bpdc
+ * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
+ */
+export const { bpdc } = registerControl('bpdc');
+
+/**
+ * Skew of the LFO for the bandpass filter
+ *
+ * @name bpskew
+ * @param {number | Pattern} skew How much to bend the LFO shape
+ */
+export const { bpskew } = registerControl('bpskew');
+
+/**
+ * Rate of the LFO for the highpass filter
+ *
+ * @name hprate
+ * @param {number | Pattern} rate rate in hertz
+ */
+export const { hprate } = registerControl('hprate');
+
+/**
+ * Cycle-synced rate of the LFO for the highpass filter
+ *
+ * @name hpsync
+ * @param {number | Pattern} rate rate in cycles
+ */
+export const { hpsync } = registerControl('hpsync');
+
+/**
+ * Depth of the LFO for the highpass filter
+ *
+ * @name hpdepth
+ * @param {number | Pattern} depth depth of modulation
+ */
+export const { hpdepth, hpdepthfreq } = registerControl('hpdepth');
+
+/**
+ * Depth of the LFO for the hipass filter, in hz
+ *
+ * @name hpdepthfrequency
+ * @synonyms
+ * hpdethfreq
+ * @param {number | Pattern} depth depth of modulation
+ * @example
+ * note("<c c c# c c c4>*16").s("sawtooth").lpf(600).hpdepthfrequency("<200 500 100 0>")
+ */
+
+export const { hpdepthfrequency } = registerControl('hpdepthfrequency', 'hpdepthfreq');
+
+/**
+ * Shape of the LFO for the highpass filter
+ *
+ * @name hpshape
+ * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
+ */
+export const { hpshape } = registerControl('hpshape');
+
+/**
+ * DC offset of the LFO for the highpass filter
+ *
+ * @name hpdc
+ * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
+ */
+export const { hpdc } = registerControl('hpdc');
+
+/**
+ * Skew of the LFO for the highpass filter
+ *
+ * @name hpskew
+ * @param {number | Pattern} skew How much to bend the LFO shape
+ */
+export const { hpskew } = registerControl('hpskew');
+
 /**
 * Applies a vibrato to the frequency of the oscillator.
 *
@@ -1675,12 +1865,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
@@ -1688,6 +1878,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(
@@ -1695,7 +1886,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
@@ -1750,17 +1941,64 @@ export const { semitone } = registerControl('semitone');
 // TODO: synth param
 export const { voice } = registerControl('voice');
 // voicings // https://codeberg.org/uzu/strudel/issues/506
-// chord to voice, like C Eb Fm7 G7. the symbols can be defined via addVoicings
+/**
+ * The chord to voice
+ * @name chord
+ * @param {string | Pattern} symbols chord symbols to voice e.g., C, Eb, Fm7, G7. The symbols can be defined via addVoicings
+ * @example
+ * chord("<Am C D F Am E Am E>").voicing()
+ **/
 export const { chord } = registerControl('chord');
-// which dictionary to use for the voicings
+/**
+ * Which dictionary to use for the voicings. This falls back to the default dictionary if not provided
+ *
+ * @name dictionary
+ * @param {string} dictionaryName which dictionary (having been defined with `addVoicings`) to use
+ * @example
+ * addVoicings('house', {
+'': ['7 12 16', '0 7 16', '4 7 12'],
+'m': ['0 3 7']
+})
+chord("<Am C D F Am E Am E>")
+.dict('house').anchor(66)
+.voicing().room(.5)
+ **/
 export const { dictionary, dict } = registerControl('dictionary', 'dict');
-// the top note to align the voicing to, defaults to c5
+/** The top note to align the voicing to. Defaults to c5
+ *
+ * @name anchor
+ * @param {string | Pattern} anchorNote the note to align the voicings to
+ * @example
+ * anchor("<c4 g4 c5 g5>").chord("C").voicing()
+ **/
 export const { anchor } = registerControl('anchor');
-// how the voicing is offset from the anchored position
+/**
+ * Sets how the voicing is offset from the anchored position
+ *
+ * @name offset
+ * @param {number | Pattern} shift the amount to shift the voicing up or down
+ * @example
+ * chord("<Am C D F Am E Am E>").offset("<0 1 2 3 4 5>") // alter the voicing each time
+ **/
 export const { offset } = registerControl('offset');
-// how many octaves are voicing steps spread apart, defaults to 1
+/**
+ *  How many octaves are voicing steps spread apart, defaults to 1
+ *
+ *  @name octaves
+ *  @param {number | Pattern} count the number of octaves
+ *  @example
+ *  chord("<Am C D F Am E Am E>").octaves("<2 4>").voicing()
+ **/
 export const { octaves } = registerControl('octaves');
-// below = anchor note will be removed from the voicing, useful for melody harmonization
+/**
+ * Remove anchor note from the voicing. Useful for melody harmonization
+ *
+ * @name mode
+ * @param {string | Pattern} modeName one of {below | above | duck | root}
+ * @example
+ * mode("<below above duck root>").chord("C").voicing()
+ *
+ **/
 export const { mode } = registerControl(['mode', 'anchor']);

 /**
@@ -1887,19 +2125,52 @@ export const { roomsize, size, sz, rsize } = registerControl('roomsize', 'size',
 export const { shape } = registerControl(['shape', 'shapevol']);
 /**
 * Wave shaping distortion. CAUTION: it can get loud.
- * Second option in optional array syntax (ex: ".9:.5") applies a postgain to the output.
+ * Second option in optional array syntax (ex: ".9:.5") applies a postgain to the output. Third option sets the waveshaping type.
 * Most useful values are usually between 0 and 10 (depending on source gain). If you are feeling adventurous, you can turn it up to 11 and beyond ;)
 *
 * @name distort
 * @synonyms dist
- * @param {number | Pattern} distortion
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ * @param {number | string | Pattern} type type of distortion to apply
 * @example
 * s("bd sd [~ bd] sd,hh*8").distort("<0 2 3 10:.5>")
 * @example
 * note("d1!8").s("sine").penv(36).pdecay(.12).decay(.23).distort("8:.4")
+ * @example
+ * s("bd:4*4").bank("tr808").distort("3:0.5:diode")
 *
 */
-export const { distort, dist } = registerControl(['distort', 'distortvol'], 'dist');
+export const { distort, dist } = registerControl(['distort', 'distortvol', 'distorttype'], 'dist');
+
+/**
+ * Postgain for waveshaping distortion.
+ *
+ * @name distortvol
+ * @synonyms distvol
+ * @param {number | Pattern} volume linear postgain of the distortion
+ * @example
+ * s("bd*4").bank("tr909").distort(2).distortvol(0.8)
+ */
+export const { distortvol } = registerControl('distortvol', 'distvol');
+
+/**
+ * Type of waveshaping distortion to apply.
+ *
+ * @name distorttype
+ * @synonyms disttype
+ * @param {number | string | Pattern} type type of distortion to apply
+ * @example
+ * s("bd*4").bank("tr909").distort(2).distorttype("<0 1 2>")
+ *
+ * @example
+ * s("sine").note("F1*2").release(1)
+ *   .penv(24).pdecay(0.05)
+ *   .distort(rand.range(1, 8))
+ *   .distorttype("<fold chebyshev scurve diode asym sinefold>")
+ */
+export const { distorttype } = registerControl('distorttype', 'disttype');
+
 /**
 * Dynamics Compressor. The params are `compressor("threshold:ratio:knee:attack:release")`
 * More info [here](https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode?retiredLocale=de#instance_properties)
@@ -2039,7 +2310,6 @@ export const { tsdelay } = registerControl('tsdelay');
 export const { real } = registerControl('real');
 export const { imag } = registerControl('imag');
 export const { enhance } = registerControl('enhance');
-export const { partials } = registerControl('partials');
 export const { comb } = registerControl('comb');
 export const { smear } = registerControl('smear');
 export const { scram } = registerControl('scram');
@@ -2287,6 +2557,24 @@ export const { miditouch } = registerControl('miditouch');
 // TODO: what is this?
 export const { polyTouch } = registerControl('polyTouch');

+/**
+ * The host to send open sound control messages to. Requires running the OSC bridge.
+ * @name oschost
+ * @param {string | Pattern} oschost e.g. 'localhost'
+ * @example
+ * note("c4").oschost('127.0.0.1').oscport(57120).osc();
+ */
+export const { oschost } = registerControl('oschost');
+
+/**
+ * The port to send open sound control messages to. Requires running the OSC bridge.
+ * @name oscport
+ * @param {number | Pattern} oscport e.g. 57120
+ * @example
+ * note("c4").oschost('127.0.0.1').oscport(57120).osc();
+ */
+export const { oscport } = registerControl('oscport');
+
 export const getControlName = (alias) => {
  if (controlAlias.has(alias)) {
    return controlAlias.get(alias);
@@ -35,18 +35,18 @@ const right = function (n, x) {
  return result;
 };

-const _bjork = function (n, x) {
+const _bjorklund = function (n, x) {
  const [ons, offs] = n;
-  return Math.min(ons, offs) <= 1 ? [n, x] : _bjork(...(ons > offs ? left(n, x) : right(n, x)));
+  return Math.min(ons, offs) <= 1 ? [n, x] : _bjorklund(...(ons > offs ? left(n, x) : right(n, x)));
 };

-export const bjork = function (ons, steps) {
+export const bjorklund = function (ons, steps) {
  const inverted = ons < 0;
  const absOns = Math.abs(ons);
  const offs = steps - absOns;
  const ones = Array(absOns).fill([1]);
  const zeros = Array(offs).fill([0]);
-  const result = _bjork([absOns, offs], [ones, zeros]);
+  const result = _bjorklund([absOns, offs], [ones, zeros]);
  const pattern = flatten(result[1][0]).concat(flatten(result[1][1]));
  return inverted ? pattern.map((x) => 1 - x) : pattern;
 };
@@ -128,7 +128,7 @@ export const bjork = function (ons, steps) {
 */

 const _euclidRot = function (pulses, steps, rotation) {
-  const b = bjork(pulses, steps);
+  const b = bjorklund(pulses, steps);
  if (rotation) {
    return rotate(b, -rotation);
  }
@@ -139,7 +139,7 @@ export const euclid = register('euclid', function (pulses, steps, pat) {
  return pat.struct(_euclidRot(pulses, steps, 0));
 });

-export const e = register('e', function (euc, pat) {
+export const bjork = register('bjork', function (euc, pat) {
  if (!Array.isArray(euc)) {
    euc = [euc];
  }
@@ -216,6 +216,6 @@ export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, s
 * .pan(sine.slow(8))
 */
 export const { euclidish, eish } = register(['euclidish', 'eish'], function (pulses, steps, perc, pat) {
-  const morphed = _morph(bjork(pulses, steps), new Array(pulses).fill(1), perc);
+  const morphed = _morph(bjorklund(pulses, steps), new Array(pulses).fill(1), perc);
  return pat.struct(morphed).setSteps(steps);
 });
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/core",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Port of Tidal Cycles to JavaScript",
  "main": "index.mjs",
  "type": "module",
@@ -37,5 +37,8 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -25,7 +25,7 @@ import {
  stringifyValues,
 } from './util.mjs';
 import drawLine from './drawLine.mjs';
-import { 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 [];
    }
  }
@@ -963,13 +963,26 @@ export const arp = register(
  false,
 );

+/*
+ * Takes a time duration followed by one or more patterns, and shifts the given patterns in time, so they are
+ * distributed equally over the given time duration. They are then combined with the pattern 'weave' is called on, after it has been stretched out (i.e. slowed down by) the time duration.
+ * @name weave
+ * @memberof Pattern
+ * @example pan(saw).weave(4, s("bd(3,8)"), s("~ sd"))
+ * @example n("0 1 2 3 4 5 6 7").weave(8, s("bd(3,8)"), s("~ sd"))
+
+addToPrototype('weave', function (t, ...pats) {
+  return this.weaveWith(t, ...pats.map((x) => set.out(x)));
+});
+
+*/
 /*
 * Like 'weave', but accepts functions rather than patterns, which are applied to the pattern.
 * @name weaveWith
 * @memberof Pattern
- */

-export const weaveWith = register('weaveWith', function (t, funcs, pat) {
+addToPrototype('weaveWith', function (t, ...funcs) {
+  const pat = this;
  const l = funcs.length;
  t = Fraction(t);
  if (l == 0) {
@@ -977,21 +990,7 @@ export const weaveWith = register('weaveWith', function (t, funcs, pat) {
  }
  return stack(...funcs.map((func, i) => pat.inside(t, func).early(Fraction(i).div(l))))._slow(t);
 });
-
-/*
- * Takes a time duration followed by one or more patterns, and shifts the given patterns in time, so they are
- * distributed equally over the given time duration. They are then combined with the pattern 'weave' is called on, after it has been stretched out (i.e. slowed down by) the time duration.
- * @name weave
- * @memberof Pattern
- * @example pan(saw).weave(4, [s("bd(3,8)"), s("~ sd")])
- * @example n("0 1 2 3 4 5 6 7").weave(8, [s("bd(3,8)"), s("~ sd")])
- */
-export const weave = register('weave', function (t, pats, pat) {
-  return pat.weaveWith(
-    t,
-    pats.map((x) => (y) => y.set.out(x)),
-  );
-});
+*/

 //////////////////////////////////////////////////////////////////////
 // compose matrix functions
@@ -2575,8 +2574,8 @@ export const { chunkBack, chunkback } = register(
 * @returns Pattern
 * @example
 * "<0 8> 1 2 3 4 5 6 7"
- * .fastChunk(4, x => x.color('red')).slow(2)
 * .scale("C2:major").note()
+ * .fastChunk(4, x => x.color('red')).slow(2)
 */
 export const { fastchunk, fastChunk } = register(
  ['fastchunk', 'fastChunk'],
@@ -2999,6 +2998,24 @@ export const extend = stepRegister('extend', function (factor, pat) {
  return pat.fast(factor).expand(factor);
 });

+/**
+ * *Experimental*
+ *
+ * `replicate` is similar to `fast` in that it increases its density, but it also increases the step count
+ * accordingly. So `stepcat("a b".replicate(2), "c d")` would be the same as `"a b a b c d"`, whereas
+ * `stepcat("a b".fast(2), "c d")` would be the same as `"[a b] [a b] c d"`.
+ *
+ * TODO: find out how this function differs from extend
+ * @example
+ * stepcat(
+ *   sound("bd bd - cp").replicate(2),
+ *   sound("bd - sd -")
+ * ).pace(8)
+ */
+export const replicate = stepRegister('replicate', function (factor, pat) {
+  return pat.repeatCycles(factor).fast(factor).expand(factor);
+});
+
 /**
 * *Experimental*
 *
@@ -3534,3 +3551,139 @@ export const morph = (frompat, topat, bypat) => {
  bypat = reify(bypat);
  return frompat.innerBind((from) => topat.innerBind((to) => bypat.innerBind((by) => _morph(from, to, by))));
 };
+
+/**
+ * Soft-clipping distortion
+ *
+ * @name soft
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Hard-clipping distortion
+ *
+ * @name hard
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Cubic polynomial distortion
+ *
+ * @name cubic
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Diode-emulating distortion
+ *
+ * @name diode
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Asymmetrical diode distortion
+ *
+ * @name asym
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Wavefolding distortion
+ *
+ * @name fold
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Wavefolding distortion composed with sinusoid
+ *
+ * @name sinefold
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Distortion via Chebyshev polynomials
+ *
+ * @name chebyshev
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+const distAlgoNames = ['scurve', 'soft', 'hard', 'cubic', 'diode', 'asym', 'fold', 'sinefold', 'chebyshev'];
+for (const name of distAlgoNames) {
+  // Add aliases for distortion algorithms
+  Pattern.prototype[name] = function (args) {
+    const argsPat = reify(args).fmap((v) => (Array.isArray(v) ? [...v, name] : [v, 1, name]));
+    return this.distort(argsPat);
+  };
+}
+
+/**
+ * Turns a list of patterns into a single pattern which outputs list-values
+ *
+ * @name parray
+ * @returns Pattern
+ */
+export const parray = (pats) => {
+  const pack = (...xs) => xs;
+  let acc = pure(curry(pack, null, pats.length));
+  for (const p of pats) acc = acc.appBoth(reify(p));
+  return acc;
+};
+
+const _ensureListPattern = (list) => {
+  if (Array.isArray(list)) {
+    return parray(list);
+  }
+  return reify(list);
+};
+
+/**
+ * Scale the magnitude of the harmonics of one of the core synths ('sine', 'tri', 'saw', ..)
+ *
+ * Can also be used to create a new synth via `s('user').partials(...)`
+ *
+ * @name partials
+ * @param {number[] | Pattern} magnitudes List of [0, 1] magnitudes for partials. 0th entry is the fundamental harmonic (i.e. DC offset is skipped)
+ * @example
+ * s("user").seg(16).n(irand(8)).scale("A:major")
+ *   .partials([1, 0, 1, 0, 0, 1])
+ * @example
+ * s("saw").seg(8).n(irand(12)).scale("G#:minor")
+ *   .partials(binaryL(irand(256).add("1")))
+ */
+Pattern.prototype.partials = function (list) {
+  return this.withValue((v) => (l) => ({ ...v, partials: l })).appLeft(_ensureListPattern(list));
+};
+
+// Also create a top-level function
+export const partials = (list) => {
+  return _ensureListPattern(list).as('partials');
+};
+
+/**
+ * Rotates the harmonics of one of the core synths ('sine', 'tri', 'saw', 'user', ..) by a list of phases
+ *
+ * @name phases
+ * @param {number[] | Pattern} phases List of [0, 1) phases for partials. 0th entry is the fundamental phase (i.e. DC offset is skipped)
+ * @example
+ * // Phase cancellation
+ * s("saw").seg(8).n(irand(12)).scale("G#1:minor")
+ *   .partials(partials([1, 1, 1]))
+ *   .superimpose(x => x.phases([0.5, 0.5, 0.5]))
+ */
+Pattern.prototype.phases = function (list) {
+  return this.withValue((v) => (l) => ({ ...v, phases: l })).appLeft(_ensureListPattern(list));
+};
+
+// Also create a top-level function
+export const phases = (list) => {
+  return _ensureListPattern(list).as('phases');
+};
@@ -152,9 +152,9 @@ export function repl({
        // allows muting a pattern x with x_ or _x
        return silence;
      }
-      if (id === '$') {
+      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);
@@ -228,7 +228,7 @@ const timeToRands = (t, n) => timeToRandsPrime(timeToIntSeed(t), n);
 export const run = (n) => saw.range(0, n).round().segment(n);

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

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

+/**
+ * Creates a binary list pattern from a number.
+ *
+ * @name binaryL
+ * @param {number} n - input number to convert to binary
+ * s("saw").seg(8)
+ *   .partials(binaryL(irand(4096).add(1)))
+ */
+export const binaryL = (n) => {
+  const nBits = reify(n).log2(0).floor().add(1);
+  return binaryNL(n, nBits);
+};
+
+/**
+ * Creates a binary list pattern from a number, padded to n bits long.
+ *
+ * @name binaryNL
+ * @param {number} n - input number to convert to binary
+ * @param {number} nBits - pattern length, defaults to 16
+ */
+export const binaryNL = (n, nBits = 16) => {
+  return reify(n)
+    .withValue((v) => (bits) => {
+      const bList = [];
+      for (let i = bits - 1; i >= 0; i--) {
+        bList.push((v >> i) & 1);
+      }
+      return bList;
+    })
+    .appLeft(reify(nBits));
+};
+
+/**
+ * Creates a list of random numbers of the given length
+ *
+ * @name randL
+ * @param {number} n Number of random numbers to sample
+ * @example
+ * s("saw").seg(16).n(irand(12)).scale("F1:minor")
+ *   .partials(randL(8))
+ */
+export const randL = (n) => {
+  return signal((t) => (nVal) => timeToRands(t, nVal).map(Math.abs)).appLeft(reify(n));
+};
+
 export const randrun = (n) => {
  return signal((t) => {
    // Without adding 0.5, the first cycle is always 0,1,2,3,...
@@ -479,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()
@@ -1,14 +1,14 @@
-import { bjork } from '../euclid.mjs';
+import { bjorklund } from '../euclid.mjs';
 import { describe, expect, it } from 'vitest';
 import { fastcat } from '../pattern.mjs';

-describe('bjork', () => {
-  it('should apply bjorklund to ons and steps', () => {
-    expect(bjork(3, 8)).toStrictEqual([1, 0, 0, 1, 0, 0, 1, 0]);
-    expect(bjork(-3, 8)).toStrictEqual([0, 1, 1, 0, 1, 1, 0, 1]);
-    expect(bjork(8, 8)).toStrictEqual([1, 1, 1, 1, 1, 1, 1, 1]);
-    expect(bjork(-8, 8)).toStrictEqual([0, 0, 0, 0, 0, 0, 0, 0]);
-    expect(bjork(5, 8)).toStrictEqual([1, 0, 1, 1, 0, 1, 1, 0]);
+describe('bjorklund', () => {
+  it('should apply bjorklundlund to ons and steps', () => {
+    expect(bjorklund(3, 8)).toStrictEqual([1, 0, 0, 1, 0, 0, 1, 0]);
+    expect(bjorklund(-3, 8)).toStrictEqual([0, 1, 1, 0, 1, 1, 0, 1]);
+    expect(bjorklund(8, 8)).toStrictEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+    expect(bjorklund(-8, 8)).toStrictEqual([0, 0, 0, 0, 0, 0, 0, 0]);
+    expect(bjorklund(5, 8)).toStrictEqual([1, 0, 1, 1, 0, 1, 1, 0]);
  });
 });

@@ -7,8 +7,8 @@ This program is free software: you can redistribute it and/or modify it under th
 import { logger } from './logger.mjs';

 // returns true if the given string is a note
-export const isNoteWithOctave = (name) => /^[a-gA-G][#bs]*[0-9]$/.test(name);
-export const isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]?$/.test(name);
+export const isNoteWithOctave = (name) => /^[a-gA-G][#bsf]*[0-9]*$/.test(name);
+export const isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]*$/.test(name);
 export const tokenizeNote = (note) => {
  if (typeof note !== 'string') {
    return [];
@@ -23,6 +23,10 @@ export const tokenizeNote = (note) => {
 const chromas = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
 const accs = { '#': 1, b: -1, s: 1, f: -1 };

+export const getAccidentalsOffset = (accidentals) => {
+  return accidentals?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+};
+
 // turns the given note into its midi number representation
 export const noteToMidi = (note, defaultOctave = 3) => {
  const [pc, acc, oct = defaultOctave] = tokenizeNote(note);
@@ -30,7 +34,7 @@ export const noteToMidi = (note, defaultOctave = 3) => {
    throw new Error('not a note: "' + note + '"');
  }
  const chroma = chromas[pc.toLowerCase()];
-  const offset = acc?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+  const offset = getAccidentalsOffset(acc);
  return (Number(oct) + 1) * 12 + chroma + offset;
 };
 export const midiToFreq = (n) => {
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/csound",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "csound bindings for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -38,5 +38,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -25,5 +25,8 @@
    "@strudel/core": "workspace:*",
    "@tauri-apps/api": "^2.2.0"
  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme"
+  "homepage": "https://codeberg.org/uzu/strudel#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }
@@ -84,9 +84,18 @@ Pattern.prototype.onPaint = function (painter) {
      state.controls.painters = [];
    }
    state.controls.painters.push(painter);
+    return state;
  });
 };

+// TODO - Why isn't this pure deep copy not working?
+// Pattern.prototype.onPaint = function (painter) {
+//   return this.withState((state) => {
+//     const painters = state.controls.painters ? [...state.controls.painters, painter] : [painter];
+//     return new State(state.span, { ...state.controls, painters });
+//   });
+// };
+
 Pattern.prototype.getPainters = function () {
  let painters = [];
  this.queryArc(0, 0, { painters });
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/draw",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Helpers for drawing with Strudel",
  "main": "index.mjs",
  "type": "module",
@@ -33,5 +33,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -20,5 +20,8 @@
  "bugs": {
    "url": "https://codeberg.org/uzu/strudel/issues"
  },
-  "homepage": "https://codeberg.org/uzu/strudel#readme"
+  "homepage": "https://codeberg.org/uzu/strudel#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }
@@ -40,6 +40,12 @@ const pattern = sequence([
 - D-Pad
  - `up`, `down`, `left`, `right` (or `u`, `d`, `l`, `r` or uppercase)
  - Toggle versions: `tglUp`, `tglDown`, `tglLeft`, `tglRight`(or `tglU`, `tglD`, `tglL`, `tglR`)
+- Stick Buttons
+  - `l3`, `r3` (or `ls`, `rs`)
+  - Toggle versions: `tglL3`, `tglR3` (or `tglLS`, `tglRS`)
+- System Buttons
+  - `start`, `back` (or uppercase `START`, `BACK`)
+  - Toggle versions: `tglStart`, `tglBack` (or `tglSTART`, `tglBACK`)

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

 ### Analog Sticks

@@ -14,6 +14,10 @@ export const buttonMap = {
  rt: 7,
  back: 8,
  start: 9,
+  l3: 10,
+  ls: 10,
+  r3: 11,
+  rs: 11,
  u: 12,
  up: 12,
  d: 13,
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/gamepad",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Gamepad Inputs for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -33,5 +33,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -34,5 +34,8 @@
  "devDependencies": {
    "tree-sitter-haskell": "^0.23.1",
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -35,6 +35,7 @@ export async function initHydra(options = {}) {
      hydra.synth.s0.init({ src: canvas });
    }
  }
+  return hydra;
 }

 export function clearHydra() {
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/hydra",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Hydra integration for strudel",
  "main": "hydra.mjs",
  "type": "module",
@@ -40,5 +40,8 @@
  "devDependencies": {
    "pkg": "^5.8.1",
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -5,9 +5,10 @@ This program is free software: you can redistribute it and/or modify it under th
 */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // Handle midicmd
    if (hap.whole.begin + 0 === 0) {
      // we need to start here because we have the timing info
-      device.sendStart({ time: timeOffsetString });
+      scheduleAtTime(() => {
+        device.sendStart();
+      }, targetTime);
    }
    if (['clock', 'midiClock'].includes(midicmd)) {
-      device.sendClock({ time: timeOffsetString });
+      scheduleAtTime(() => {
+        device.sendClock();
+      }, targetTime);
    } else if (['start'].includes(midicmd)) {
-      device.sendStart({ time: timeOffsetString });
+      scheduleAtTime(() => {
+        device.sendStart();
+      }, targetTime);
    } else if (['stop'].includes(midicmd)) {
-      device.sendStop({ time: timeOffsetString });
+      scheduleAtTime(() => {
+        device.sendStop();
+      }, targetTime);
    } else if (['continue'].includes(midicmd)) {
-      device.sendContinue({ time: timeOffsetString });
+      scheduleAtTime(() => {
+        device.sendContinue();
+      }, targetTime);
    } else if (Array.isArray(midicmd)) {
      if (midicmd[0] === 'progNum') {
-        sendProgramChange(midicmd[1], device, midichan, timeOffsetString);
+        sendProgramChange(midicmd[1], device, midichan, targetTime);
      } else if (midicmd[0] === 'cc') {
        if (midicmd.length === 2) {
-          sendCC(midicmd[0], midicmd[1] / 127, device, midichan, timeOffsetString);
+          sendCC(midicmd[0], midicmd[1] / 127, device, midichan, targetTime);
        }
      } else if (midicmd[0] === 'sysex') {
        if (midicmd.length === 3) {
          const [_, id, data] = midicmd;
-          sendSysex(id, data, device, timeOffsetString);
+          sendSysex(id, data, device, targetTime);
        }
      }
    }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/midi",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Midi API for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -35,5 +35,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/mini",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Mini notation for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -38,5 +38,8 @@
    "peggy": "^4.2.0",
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -21,13 +21,14 @@ export class MondoParser {
    close_curly: /^\}/,
    number: /^-?[0-9]*\.?[0-9]+/, // before pipe!
    // TODO: better error handling when "-" is used as rest, e.g "s [- bd]"
-    op: /^[*/:!@%?+-]|^\.{2}/, // * / : ! @ % ? ..
+    op: /^[*/:!@%?+\-&]|^\.{2}/, // * / : ! @ % ? ..
    // dollar: /^\$/,
    pipe: /^#/,
    stack: /^[,$]/,
    or: /^[|]/,
    plain: /^[a-zA-Z0-9-~_^#]+/,
  };
+  op_precedence = [['*', '/', ':', '!', '@', '%', '?', '+', '-', '..'], ['&']];
  // matches next token
  next_token(code, offset = 0) {
    for (let type in this.token_types) {
@@ -150,9 +151,9 @@ export class MondoParser {
    }
    return children;
  }
-  desugar_ops(children) {
+  desugar_ops(children, types) {
    while (true) {
-      let opIndex = children.findIndex((child) => child.type === 'op');
+      let opIndex = children.findIndex((child) => child.type === 'op' && types.includes(child.value));
      if (opIndex === -1) break;
      const op = { type: 'plain', value: children[opIndex].value };
      if (opIndex === children.length - 1) {
@@ -263,8 +264,10 @@ export class MondoParser {
          // the type we've removed before splitting needs to be added back
          children = [{ type: 'plain', value: type }, ...children];
        }
-        children = this.desugar_ops(children);
-        // children = this.desugar_pipes(children, (children) => this.desugar_dollars(children));
+        // for each precendence group, call desugar_ops once
+        this.op_precedence.forEach((ops) => {
+          children = this.desugar_ops(children, ops);
+        });
        children = this.desugar_pipes(children);
        return children;
      }),
@@ -33,5 +33,8 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -117,6 +117,7 @@ describe('mondo sugar', () => {
  it('should desugar x:y', () => expect(desguar('x:y')).toEqual('(: y x)'));
  it('should desugar x:y:z', () => expect(desguar('x:y:z')).toEqual('(: z (: y x))'));
  it('should desugar x:y*x', () => expect(desguar('bd:0*2')).toEqual('(* 2 (: 0 bd))'));
+  it('should desugar x&y:z', () => expect(desguar('bd&3:8')).toEqual('(& (: 8 3) bd)'));
  it('should desugar a..b', () => expect(desguar('0..2')).toEqual('(.. 2 0)'));
  /* it('should desugar x $ y', () => expect(desguar('x $ y')).toEqual('(x y)'));
  it('should desugar x $ y z', () => expect(desguar('x $ y z')).toEqual('(x (y z))'));
@@ -5,12 +5,13 @@ import {
  slow,
  seq,
  stepcat,
-  extend,
+  replicate,
  expand,
  pace,
  chooseIn,
  degradeBy,
  silence,
+  bjork,
 } from '@strudel/core';
 import { registerLanguage } from '@strudel/transpiler';
 import { MondoRunner } from 'mondolang';
@@ -36,10 +37,11 @@ lib.square = (...args) => stepcat(...args).setSteps(1);
 lib.angle = (...args) => stepcat(...args).pace(1);
 lib['*'] = fast;
 lib['/'] = slow;
-lib['!'] = extend;
+lib['!'] = replicate;
 lib['@'] = expand;
 lib['%'] = pace;
 lib['?'] = degradeBy; // todo: default 0.5 not working..
+lib['&'] = bjork;
 lib[':'] = tail;
 lib['..'] = range;
 lib['def'] = () => silence;
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/mondo",
-  "version": "1.1.4",
+  "version": "1.1.5",
  "description": "mondo notation for strudel",
  "main": "mondough.mjs",
  "type": "module",
@@ -40,5 +40,8 @@
    "mondo": "*",
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/motion",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "DeviceMotion API for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -33,5 +33,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/mqtt",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "MQTT API for strudel",
  "main": "mqtt.mjs",
  "type": "module",
@@ -34,5 +34,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -4,8 +4,6 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-import OSC from 'osc-js';
-
 import { logger, parseNumeral, register, isNote, noteToMidi, ClockCollator } from '@strudel/core';

 let connection; // Promise<OSC>
@@ -13,19 +11,18 @@ function connect() {
  if (!connection) {
    // make sure this runs only once
    connection = new Promise((resolve, reject) => {
-      const osc = new OSC();
-      osc.open();
-      osc.on('open', () => {
-        const url = osc.options?.plugin?.socket?.url;
-        logger(`[osc] connected${url ? ` to ${url}` : ''}`);
-        resolve(osc);
+      const ws = new WebSocket('ws://localhost:8080');
+      ws.addEventListener('open', (event) => {
+        logger(`[osc] websocket connected`);
+        resolve(ws);
      });
-      osc.on('close', () => {
+      ws.addEventListener('close', (event) => {
+        logger(`[osc] websocket closed`);
        connection = undefined; // allows new connection afterwards
        console.log('[osc] disconnected');
        reject('OSC connection closed');
      });
-      osc.on('error', (err) => reject(err));
+      ws.addEventListener('error', (err) => reject(err));
    }).catch((err) => {
      connection = undefined;
      throw new Error('Could not connect to OSC server. Is it running?');
@@ -61,15 +58,19 @@ export function parseControlsFromHap(hap, cps) {
 const collator = new ClockCollator({});

 export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
-  const osc = await connect();
+  const ws = await connect();
  const controls = parseControlsFromHap(hap, cps);
  const keyvals = Object.entries(controls).flat();
+  const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
+  const msg = { address: '/dirt/play', args: keyvals, timestamp: ts };

-  const ts = Math.round(collator.calculateTimestamp(currentTime, targetTime) * 1000);
-  const message = new OSC.Message('/dirt/play', ...keyvals);
-  const bundle = new OSC.Bundle([message], ts);
-  bundle.timestamp(ts); // workaround for https://github.com/adzialocha/osc-js/issues/60
-  osc.send(bundle);
+  if ('oschost' in hap.value) {
+    msg['host'] = hap.value['oschost'];
+  }
+  if ('oscport' in hap.value) {
+    msg['port'] = hap.value['oscport'];
+  }
+  ws.send(JSON.stringify(msg));
 }

 /**
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/osc",
-  "version": "1.2.10",
+  "version": "1.3.0",
  "description": "OSC messaging for strudel",
  "main": "osc.mjs",
  "bin": "./server.js",
@@ -38,10 +38,14 @@
  "homepage": "https://codeberg.org/uzu/strudel#readme",
  "dependencies": {
    "@strudel/core": "workspace:*",
-    "osc-js": "^2.4.1"
+    "osc": "^2.4.5",
+    "ws": "^8.18.3"
  },
  "devDependencies": {
    "pkg": "^5.8.1",
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -6,70 +6,59 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-import OSC from 'osc-js';
+// import OSC from 'osc-js';

-const args = process.argv.slice(2);
-function getArgValue(flag) {
-  const i = args.indexOf(flag);
-  if (i !== -1) {
-    const nextIsFlag = args[i + 1]?.startsWith('--') ?? true;
-    if (nextIsFlag) return true;
-    return args[i + 1];
-  }
-}
+import { WebSocketServer } from 'ws';
+import osc from 'osc';

-let udpClientPort = Number(getArgValue('--port')) || 57120;
-let debug = Number(getArgValue('--debug')) || 0;
+const WS_PORT = 8080; // WebSocket server port
+const OSC_REMOTE_IP = '127.0.0.1';
+const OSC_REMOTE_PORT = 57120;

-const config = {
-  receiver: 'ws', // @param {string} Where messages sent via 'send' method will be delivered to, 'ws' for Websocket clients, 'udp' for udp client
-  udpServer: {
-    host: 'localhost', // @param {string} Hostname of udp server to bind to
-    port: 57121, // @param {number} Port of udp client for messaging
-    // enabling the following line will receive tidal messages:
-    // port: 57120, // @param {number} Port of udp client for messaging
-    exclusive: false, // @param {boolean} Exclusive flag
-  },
-  udpClient: {
-    host: 'localhost', // @param {string} Hostname of udp client for messaging
-    port: udpClientPort, // @param {number} Port of udp client for messaging
-  },
-  wsServer: {
-    host: 'localhost', // @param {string} Hostname of WebSocket server
-    port: 8080, // @param {number} Port of WebSocket server
-  },
-};
-
-const osc = new OSC({ plugin: new OSC.BridgePlugin(config) });
-
-if (debug) {
-  osc.on('*', (message) => {
-    const { address, args } = message;
-    let str = '';
-    for (let i = 0; i < args.length; i += 2) {
-      str += `${args[i]}: ${args[i + 1]} `;
-    }
-    console.log(`${address} ${str}`);
-  });
-}
-
-osc.on('error', (message) => {
-  if (message.toString().includes('EADDRINUSE')) {
-    console.log(`------ ERROR -------
-a server is already running on port 57121! to stop it:
-1. run "lsof -ti :57121 | xargs kill -9" (macos / linux)
-2. re-run the osc server
-`);
-  } else {
-    console.log(message);
-  }
+const udpPort = new osc.UDPPort({
+  localAddress: '0.0.0.0',
+  localPort: 0,
+  remoteAddress: OSC_REMOTE_IP,
+  remotePort: OSC_REMOTE_PORT,
 });

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

-console.log('osc client running on port', config.udpClient.port);
-console.log('osc server running on port', config.udpServer.port);
-console.log('websocket server running on port', config.wsServer.port);
-if (debug) {
-  console.log('debug logs enabled. incoming messages will appear below');
-}
+udpPort.on('error', (e) => {
+  console.log('Error: ', e);
+});
+
+const wss = new WebSocketServer({ port: WS_PORT });
+console.log(`[Listening WS] ws://localhost:${WS_PORT}`);
+
+wss.on('connection', (ws) => {
+  console.log('New WebSocket connection');
+
+  ws.on('message', (message) => {
+    let osc_host = '127.0.0.1';
+    let osc_port = 57120;
+
+    try {
+      const data = JSON.parse(message);
+      if ('host' in data) {
+        osc_host = data['host'];
+      }
+      if ('port' in data) {
+        osc_port = data['port'];
+      }
+      let msg = { address: data['address'], args: data['args'] };
+      if ('timestamp' in data) {
+        msg = { timeTag: osc.timeTag(0, data['timestamp']), packets: [msg] };
+      }
+
+      udpPort.send(msg, osc_host, osc_port);
+    } catch (err) {
+      console.error('Error parsing message:', err);
+    }
+  });
+
+  ws.on('close', () => {
+    console.log('WebSocket connection closed');
+  });
+});
@@ -33,5 +33,8 @@
  "homepage": "https://codeberg.org/uzu/strudel#readme",
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/repl",
-  "version": "1.2.6",
+  "version": "1.2.7",
  "description": "Strudel REPL as a Web Component",
  "module": "index.mjs",
  "publishConfig": {
@@ -48,5 +48,8 @@
    "@rollup/plugin-replace": "^6.0.2",
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -20,10 +20,13 @@ export async function prebake() {
    // import('@strudel/osc'),
  );
  // load samples
-  const ds = 'https://raw.githubusercontent.com/felixroos/dough-samples/main/';
+  const ds = 'https://raw.githubusercontent.com/felixroos/dough-samples/main';

  // TODO: move this onto the strudel repo
-  const ts = 'https://raw.githubusercontent.com/todepond/samples/main/';
+  const ts = 'https://raw.githubusercontent.com/todepond/samples/main';
+
+  const tc = 'https://raw.githubusercontent.com/tidalcycles/uzu-drumkit/main';
+
  await Promise.all([
    modulesLoading,
    registerSynthSounds(),
@@ -36,9 +39,9 @@ export async function prebake() {
    samples(`${ds}/tidal-drum-machines.json`),
    samples(`${ds}/piano.json`),
    samples(`${ds}/Dirt-Samples.json`),
-    samples(`${ds}/uzu-drumkit.json`),
    samples(`${ds}/vcsl.json`),
    samples(`${ds}/mridangam.json`),
+    samples(`${tc}/strudel.json`),
  ]);

  aliasBank(`${ts}/tidal-drum-machines-alias.json`);
@@ -15,5 +15,8 @@
  "type": "module",
  "dependencies": {
    "cowsay": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -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();
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/serial",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Webserial API for strudel",
  "main": "serial.mjs",
  "type": "module",
@@ -33,5 +33,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/soundfonts",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Soundsfont support for strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -37,5 +37,8 @@
  "devDependencies": {
    "node-fetch": "^3.3.2",
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -89,7 +89,7 @@ superdough({ s: 'bd', delay: 0.5 }, 0, 1);
  - `decay`: seconds of decay phase
  - `sustain`: gain of sustain phase
  - `release`: seconds of release phase
- `deadline`: seconds until the sound should play (0 = immediate)
+- `deadline`: seconds from audio context initialization before playing the sound (getAudioContextCurrentTime() = immediate)
 - `duration`: seconds the sound should last. optional for one shot samples, required for synth sounds

 ### registerSynthSounds()
@@ -153,6 +153,7 @@ samples('github:tidalcycles/dirt-samples')

 The format is `github:<user>/<repo>/<branch>`.

+If `<repo>` and `<branch>` are not specified, they will default to `samples` and `main` respectively.
 It expects a `strudel.json` file to be present at the root of the given repository, which declares the sample paths in the repo.

 The format is also expected to be the same as explained above.
@@ -0,0 +1,18 @@
+let audioContext;
+
+export const setDefaultAudioContext = () => {
+  audioContext = new AudioContext();
+  return audioContext;
+};
+
+export const getAudioContext = () => {
+  if (!audioContext) {
+    return setDefaultAudioContext();
+  }
+
+  return audioContext;
+};
+
+export function getAudioContextCurrentTime() {
+  return getAudioContext().currentTime;
+}
@@ -1,4 +1,4 @@
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';

 let worklet;
 export async function dspWorklet(ac, code) {
@@ -1,6 +1,7 @@
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';
 import { getNoiseBuffer } from './noise.mjs';
+import { logger } from './logger.mjs';

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

@@ -153,6 +154,24 @@ export const getADSRValues = (params, curve = 'linear', defaultValues) => {
  return [Math.max(a ?? 0, envmin), Math.max(d ?? 0, envmin), Math.min(sustain, envmax), Math.max(r ?? 0, releaseMin)];
 };

+export function getParamLfo(audioContext, param, start, end, lfoValues) {
+  let { defaultDepth = 1, depth, dcoffset, ...getLfoInputs } = lfoValues;
+  if (depth == null) {
+    const hasLFOParams = Object.values(getLfoInputs).some((v) => v != null);
+    depth = hasLFOParams ? defaultDepth : 0;
+  }
+  let lfo;
+  if (depth) {
+    lfo = getLfo(audioContext, start, end, {
+      depth,
+      dcoffset,
+      ...getLfoInputs,
+    });
+    lfo.connect(param);
+  }
+  return lfo;
+}
+
 // helper utility for applying standard modulators to a parameter
 export function applyParameterModulators(audioContext, param, start, end, envelopeValues, lfoValues) {
  let { amount, offset, defaultAmount = 1, curve = 'linear', values, holdEnd, defaultValues } = envelopeValues;
@@ -169,55 +188,76 @@ export function applyParameterModulators(audioContext, param, start, end, envelo
    const [attack, decay, sustain, release] = getADSRValues(values, curve, defaultValues);
    getParamADSR(param, attack, decay, sustain, release, min, max, start, holdEnd, curve);
  }
-  let lfo;
-  let { defaultDepth = 1, depth, dcoffset, ...getLfoInputs } = lfoValues;
-
-  if (depth == null) {
-    const hasLFOParams = Object.values(getLfoInputs).some((v) => v != null);
-    depth = hasLFOParams ? defaultDepth : 0;
-  }
-  if (depth) {
-    lfo = getLfo(audioContext, start, end, {
-      depth,
-      dcoffset,
-      ...getLfoInputs,
-    });
-    lfo.connect(param);
-  }
-
+  const lfo = getParamLfo(audioContext, param, start, end, lfoValues);
  return { lfo, disconnect: () => lfo?.disconnect() };
 }
+export function createFilter(context, start, end, params, cps, cycle) {
+  let {
+    frequency,
+    anchor,
+    env,
+    type,
+    model,
+    q = 1,
+    drive = 0.69,
+    depth,
+    depthfrequency,
+    dcoffset = -0.5,
+    skew,
+    shape,
+    rate,
+    sync,
+  } = params;

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

@@ -240,7 +280,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'];
@@ -275,10 +323,19 @@ export function getVibratoOscillator(param, value, t) {
    gain.gain.value = vibmod * 100;
    vibratoOscillator.connect(gain);
    gain.connect(param);
+    vibratoOscillator.onended = () => {
+      gain.disconnect(param);
+      vibratoOscillator.disconnect(gain);
+    };
    vibratoOscillator.start(t);
    return vibratoOscillator;
  }
 }
+
+export function scheduleAtTime(callback, targetTime, audioContext = getAudioContext()) {
+  const currentTime = audioContext.currentTime;
+  webAudioTimeout(audioContext, callback, currentTime, targetTime);
+}
 // ConstantSource inherits AudioScheduledSourceNode, which has scheduling abilities
 // a bit of a hack, but it works very well :)
 export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
@@ -323,9 +380,9 @@ const mod = (freq, range = 1, type = 'sine') => {
  }

  osc.start();
-  const g = new GainNode(ctx, { gain: range });
+  const g = gainNode(range);
  osc.connect(g); // -range, range
-  return { node: g, stop: (t) => osc.stop(t) };
+  return { node: g, stop: (t) => osc.stop(t), osc: osc };
 };
 const fm = (frequencyparam, harmonicityRatio, modulationIndex, wave = 'sine') => {
  const carrfreq = frequencyparam.value;
@@ -377,12 +434,113 @@ export function applyFM(param, value, begin) {
      modulator.connect(envGain);
      envGain.connect(param);
    }
+    fmmod.osc.onended = () => {
+      envGain.disconnect();
+      modulator.disconnect();
+      fmmod.osc.disconnect();
+    };
  }
  return { stop };
 }

+// Saturation curves
+
+const __squash = (x) => x / (1 + x); // [0, inf) to [0, 1)
+const _mod = (n, m) => ((n % m) + m) % m;
+
+const _scurve = (x, k) => ((1 + k) * x) / (1 + k * Math.abs(x));
+const _soft = (x, k) => Math.tanh(x * (1 + k));
+const _hard = (x, k) => clamp((1 + k) * x, -1, 1);
+
+const _fold = (x, k) => {
+  // Closed form folding for audio rate
+  let y = (1 + 0.5 * k) * x;
+  const window = _mod(y + 1, 4);
+  return 1 - Math.abs(window - 2);
+};
+
+const _sineFold = (x, k) => Math.sin((Math.PI / 2) * _fold(x, k));
+
+const _cubic = (x, k) => {
+  const t = __squash(Math.log1p(k));
+  const cubic = (x - (t / 3) * x * x * x) / (1 - t / 3); // normalized to go from (-1, 1)
+  return _soft(cubic, k);
+};
+
+const _diode = (x, k, asym = false) => {
+  const g = 1 + 2 * k; // gain
+  const t = __squash(Math.log1p(k));
+  const bias = 0.07 * t;
+  const pos = _soft(x + bias, 2 * k);
+  const neg = _soft(asym ? bias : -x + bias, 2 * k);
+  const y = pos - neg;
+  // We divide by the derivative at 0 so that the distortion is roughly
+  // the identity map near 0 => small values are preserved and undistorted
+  const sech = 1 / Math.cosh(g * bias);
+  const sech2 = sech * sech; // derivative of soft (i.e. tanh) is sech^2
+  const denom = Math.max(1e-8, (asym ? 1 : 2) * g * sech2); // g from chain rule; 2 if both pos/neg have x
+  return _soft(y / denom, k);
+};
+
+const _asym = (x, k) => _diode(x, k, true);
+
+const _chebyshev = (x, k) => {
+  const kl = 10 * Math.log1p(k);
+  let tnm1 = 1;
+  let tnm2 = x;
+  let tn;
+  let y = 0;
+  for (let i = 1; i < 64; i++) {
+    if (i < 2) {
+      // Already set inital conditions
+      y += i == 0 ? tnm1 : tnm2;
+      continue;
+    }
+    tn = 2 * x * tnm1 - tnm2; // https://en.wikipedia.org/wiki/Chebyshev_polynomials#Recurrence_definition
+    tnm2 = tnm1;
+    tnm1 = tn;
+    if (i % 2 === 0) {
+      y += Math.min((1.3 * kl) / i, 2) * tn;
+    }
+  }
+  // Soft clip
+  return _soft(y, kl / 20);
+};
+
+export const distortionAlgorithms = {
+  scurve: _scurve,
+  soft: _soft,
+  hard: _hard,
+  cubic: _cubic,
+  diode: _diode,
+  asym: _asym,
+  fold: _fold,
+  sinefold: _sineFold,
+  chebyshev: _chebyshev,
+};
+const _algoNames = Object.freeze(Object.keys(distortionAlgorithms));
+
+export const getDistortionAlgorithm = (algo) => {
+  let index = algo;
+  if (typeof algo === 'string') {
+    index = _algoNames.indexOf(algo);
+    if (index === -1) {
+      logger(`[superdough] Could not find waveshaping algorithm ${algo}.
+        Available options are ${_algoNames.join(', ')}.
+        Defaulting to ${_algoNames[0]}.`);
+      index = 0;
+    }
+  }
+  const name = _algoNames[index % _algoNames.length]; // allow for wrapping if algo was a number
+  return distortionAlgorithms[name];
+};
+
+export const getDistortion = (distort, postgain, algorithm) => {
+  return getWorklet(getAudioContext(), 'distort-processor', { distort, postgain }, { processorOptions: { 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
@@ -391,7 +549,7 @@ export const getFrequencyFromValue = (value, defaultNote = 36) => {
  if (!freq && typeof note === 'number') {
    freq = midiToFreq(note); // + 48);
  }
-
+  freq *= Math.pow(2, octave);
  return Number(freq);
 };

@@ -11,4 +11,5 @@ export * from './synth.mjs';
 export * from './zzfx.mjs';
 export * from './logger.mjs';
 export * from './dspworklet.mjs';
+export * from './audioContext.mjs';
 export * from './wavetable.mjs';
@@ -1,5 +1,5 @@
 import { drywet } from './helpers.mjs';
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';

 let noiseCache = {};

@@ -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,6 +1,6 @@
 {
  "name": "superdough",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "simple web audio synth and sampler intended for live coding. inspired by superdirt and webdirt.",
  "main": "index.mjs",
  "type": "module",
@@ -37,5 +37,8 @@
  },
  "dependencies": {
    "nanostores": "^0.11.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -104,6 +104,8 @@ var applyGradualLowpass = function (input, lpFreqStart, lpFreqEnd, lpFreqEndAt,
  player.start();
  context.oncomplete = function (event) {
    callback(event.renderedBuffer);
+    filter.disconnect();
+    player.disconnect();
  };
  context.startRendering();

@@ -1,5 +1,6 @@
-import { noteToMidi, valueToMidi, getSoundIndex, getCommonSampleInfo } from './util.mjs';
-import { getAudioContext, registerSound, registerWaveTable } from './index.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 { logger } from './logger.mjs';

@@ -120,13 +121,18 @@ function githubPath(base, subpath = '') {
  if (!base.startsWith('github:')) {
    throw new Error('expected "github:" at the start of pseudoUrl');
  }
-  let [_, path] = base.split('github:');
+  let path = base.slice('github:'.length);
  path = path.endsWith('/') ? path.slice(0, -1) : path;
-  if (path.split('/').length === 2) {
-    // assume main as default branch if none set
-    path += '/main';
-  }
-  return `https://raw.githubusercontent.com/${path}/${subpath}`;
+
+  let components = path.split('/');
+  let user = components[0];
+  let repo = components.length >= 2 ? components[1] : 'samples';
+  let branch = components.length >= 3 ? components[2] : 'main';
+  let other = components.slice(3);
+  other.push(subpath ? subpath : '');
+  other = other.join('/');
+
+  return `https://raw.githubusercontent.com/${user}/${repo}/${branch}/${other}`;
 }

 export const processSampleMap = (sampleMap, fn, baseUrl = sampleMap._base || '') => {
@@ -205,7 +211,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;
@@ -7,12 +7,13 @@ This program is free software: you can redistribute it and/or modify it under th
 import './feedbackdelay.mjs';
 import './reverb.mjs';
 import './vowel.mjs';
-import { nanFallback, _mod, cycleToSeconds } from './util.mjs';
+import { nanFallback, _mod, cycleToSeconds, pickAndRename } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
-import { createFilter, gainNode, getCompressor, getLfo, getWorklet, effectSend } from './helpers.mjs';
+import { createFilter, gainNode, getCompressor, getDistortion, getLfo, getWorklet, effectSend } from './helpers.mjs';
 import { map } from 'nanostores';
 import { logger } from './logger.mjs';
 import { loadBuffer } from './sampler.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import { SuperdoughAudioController } from './superdoughoutput.mjs';

 export const DEFAULT_MAX_POLYPHONY = 128;
@@ -145,15 +146,11 @@ let defaultDefaultValues = {
  gain: 0.8,
  postgain: 1,
  density: '.03',
-  ftype: '12db',
-  fanchor: 0,
-  resonance: 1,
-  hresonance: 1,
-  bandq: 1,
  channels: [1, 2],
  phaserdepth: 0.75,
  shapevol: 1,
  distortvol: 1,
+  distorttype: 0,
  delay: 0,
  byteBeatExpression: '0',
  delayfeedback: 0.5,
@@ -200,25 +197,6 @@ export function setVersionDefaults(version) {

 export const resetLoadedSounds = () => soundMap.set({});

-let audioContext;
-
-export const setDefaultAudioContext = () => {
-  audioContext = new AudioContext({ latencyHint: 'playback' });
-  return audioContext;
-};
-
-export const getAudioContext = () => {
-  if (!audioContext) {
-    return setDefaultAudioContext();
-  }
-
-  return audioContext;
-};
-
-export function getAudioContextCurrentTime() {
-  return getAudioContext().currentTime;
-}
-
 let externalWorklets = [];
 export function registerWorklet(url) {
  externalWorklets.push(url);
@@ -285,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();
      });
@@ -432,32 +410,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    djf,
    // filters
    fanchor = getDefaultValue('fanchor'),
-    drive = 0.69,
    release = 0,
-    // low pass
-    cutoff,
-    lpenv,
-    lpattack,
-    lpdecay,
-    lpsustain,
-    lprelease,
-    resonance = getDefaultValue('resonance'),
-    // high pass
-    hpenv,
-    hcutoff,
-    hpattack,
-    hpdecay,
-    hpsustain,
-    hprelease,
-    hresonance = getDefaultValue('hresonance'),
-    // band pass
-    bpenv,
-    bandf,
-    bpattack,
-    bpdecay,
-    bpsustain,
-    bprelease,
-    bandq = getDefaultValue('bandq'),

    //phaser
    phaserrate: phaser,
@@ -473,6 +426,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
    shapevol = getDefaultValue('shapevol'),
    distort,
    distortvol = getDefaultValue('distortvol'),
+    distorttype = getDefaultValue('distorttype'),
    pan,
    vowel,
    delay = getDefaultValue('delay'),
@@ -527,7 +481,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  // oldest audio nodes will be destroyed if maximum polyphony is exceeded
  for (let i = 0; i <= activeSoundSources.size - maxPolyphony; i++) {
    const ch = activeSoundSources.entries().next();
-    const source = ch.value[1];
+    const source = ch.value[1].deref();
    const chainID = ch.value[0];
    const endTime = t + 0.25;
    source?.node?.gain?.linearRampToValueAtTime(0, endTime);
@@ -559,7 +513,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)

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

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

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

-  if (bandf !== undefined) {
-    let bp = () =>
-      createFilter(ac, 'bandpass', bandf, bandq, bpattack, bpdecay, bpsustain, bprelease, bpenv, t, end, fanchor);
+  if (value.bandf !== undefined) {
+    const bpMap = {
+      frequency: 'bandf',
+      q: 'bandq',
+      attack: 'bpattack',
+      decay: 'bpdecay',
+      sustain: 'bpsustain',
+      release: 'bprelease',
+      env: 'bpenv',
+      anchor: 'fanchor',
+      model: 'ftype',
+      drive: 'drive',
+      rate: 'bprate',
+      sync: 'bpsync',
+      depth: 'bpdepth',
+      depthfrequency: 'bpdepthfrequency',
+      shape: 'bpshape',
+      dcoffset: 'bpdc',
+      skew: 'bpskew',
+    };
+    const bpParams = pickAndRename(value, bpMap);
+    bpParams.type = 'bandpass';
+    let bp = () => createFilter(ac, t, end, bpParams, cps, cycle);
    chain.push(bp());
    if (ftype === '24db') {
      chain.push(bp());
@@ -647,7 +634,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
  coarse !== undefined && chain.push(getWorklet(ac, 'coarse-processor', { coarse }));
  crush !== undefined && chain.push(getWorklet(ac, 'crush-processor', { crush }));
  shape !== undefined && chain.push(getWorklet(ac, 'shape-processor', { shape, postgain: shapevol }));
-  distort !== undefined && chain.push(getWorklet(ac, 'distort-processor', { distort, postgain: distortvol }));
+  distort !== undefined && chain.push(getDistortion(distort, distortvol, distorttype));

  if (tremolosync != null) {
    tremolo = cps * tremolosync;
@@ -681,6 +668,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);
  }

@@ -708,7 +696,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) {
@@ -724,7 +713,8 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
      roomIR = await loadBuffer(url, ac, ir, 0);
    }
    orbitBus.getReverb(roomsize, roomfade, roomlp, roomdim, roomIR, irspeed, irbegin);
-    orbitBus.sendReverb(post, room);
+    const send = orbitBus.sendReverb(post, room);
+    audioNodes.push(send);
  }

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

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

  duck(t, onsettime = 0, attacktime = 0.1, depth = 1) {
@@ -1,5 +1,6 @@
 import { clamp } from './util.mjs';
-import { registerSound, getAudioContext, soundMap } from './superdough.mjs';
+import { registerSound, soundMap } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import {
  applyFM,
  destroyAudioWorkletNode,
@@ -14,9 +15,10 @@ import {
  noises,
  webAudioTimeout,
 } from './helpers.mjs';
+import { logger } from './logger.mjs';
 import { getNoiseMix, getNoiseOscillator } from './noise.mjs';

-const waveforms = ['triangle', 'square', 'sawtooth', 'sine'];
+const waveforms = ['triangle', 'square', 'sawtooth', 'sine', 'user'];
 const waveformAliases = [
  ['tri', 'triangle'],
  ['sqr', 'square'],
@@ -46,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);
@@ -413,9 +413,13 @@ export function registerSynthSounds() {
  waveformAliases.forEach(([alias, actual]) => soundMap.set({ ...soundMap.get(), [alias]: soundMap.get()[actual] }));
 }

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

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

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

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

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

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

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

@@ -472,6 +492,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) => {
@@ -16,13 +16,17 @@ export const tokenizeNote = (note) => {
 const chromas = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
 const accs = { '#': 1, b: -1, s: 1, f: -1 };

+export const getAccidentalsOffset = (accidentals) => {
+  return accidentals?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+};
+
 export const noteToMidi = (note, defaultOctave = 3) => {
  const [pc, acc, oct = defaultOctave] = tokenizeNote(note);
  if (!pc) {
    throw new Error('not a note: "' + note + '"');
  }
  const chroma = chromas[pc.toLowerCase()];
-  const offset = acc?.split('').reduce((o, char) => o + accs[char], 0) || 0;
+  const offset = getAccidentalsOffset(acc);
  return (Number(oct) + 1) * 12 + chroma + offset;
 };
 export const midiToFreq = (n) => {
@@ -105,3 +109,18 @@ export function getCommonSampleInfo(hapValue, bank) {
  const label = `${s}:${index}`;
  return { transpose, url, index, midi, label };
 }
+
+/** Selects entries from `source` and renames them via `map` */
+export const pickAndRename = (source, map) => {
+  return Object.fromEntries(Object.entries(map).map(([newKey, oldKey]) => [newKey, source[oldKey]]));
+};
+
+export const getBaseURL = (url) => {
+  try {
+    // For real URLs
+    return new URL('.', new URL(url)).href.replace(/\/$/, ''); // removes trailing slash
+  } catch {
+    // For pseudo URLS
+    return url.split('/').slice(0, -1).join('/');
+  }
+};
@@ -45,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,6 +1,7 @@
 import { getAudioContext, registerSound } from './index.mjs';
-import { getCommonSampleInfo } from './util.mjs';
+import { getBaseURL, getCommonSampleInfo } from './util.mjs';
 import {
+  applyFM,
  applyParameterModulators,
  destroyAudioWorkletNode,
  getADSRValues,
@@ -189,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;
@@ -199,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}"`);
@@ -230,12 +232,12 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
      begin: t,
      end: envEnd,
      frequency,
-      detune: value.detune,
+      freqspread: value.detune,
      position: value.wt,
      warp: value.warp,
      warpMode: warpmode,
      voices: Math.max(value.unison ?? 1, 1),
-      spread: value.spread,
+      panspread: value.spread,
      phaserand: (value.wtphaserand ?? value.unison > 1) ? 1 : 0,
    },
    { outputChannelCount: [2] },
@@ -308,6 +310,7 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
    },
  );
  const vibratoOscillator = getVibratoOscillator(source.parameters.get('detune'), value, t);
+  const fm = applyFM(source.parameters.get('frequency'), value, t);
  const envGain = ac.createGain();
  const node = source.connect(envGain);
  getParamADSR(node.gain, attack, decay, sustain, release, 0, 0.3, t, holdEnd, 'linear');
@@ -318,6 +321,7 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
    () => {
      destroyAudioWorkletNode(source);
      vibratoOscillator?.stop();
+      fm?.stop();
      node.disconnect();
      wtPosModulators?.disconnect();
      wtWarpModulators?.disconnect();
@@ -4,52 +4,59 @@

 import OLAProcessor from './ola-processor';
 import FFT from './fft.js';
+import { getDistortionAlgorithm } from './helpers.mjs';
+
+const blockSize = 128;
+const PI = Math.PI;
+const TWO_PI = 2 * PI;
+const INVSR = 1 / sampleRate;

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

-const getUnisonDetune = (unison, detune, voiceIndex) => {
-  if (unison < 2) {
-    return 0;
-  }
-  return lerp(-detune * 0.5, detune * 0.5, voiceIndex / (unison - 1));
+// Fast integer ops for non-negative values
+const ffloor = (x) => x | 0;
+const fround = (x) => ffloor(x + 0.5);
+const fceil = (x) => ffloor(x + 1);
+const ffrac = (x) => x - ffloor(x);
+
+const fast_tanh = (x) => {
+  const x2 = x ** 2;
+  return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
 };
+
+// Optimized per-voice detuner which precomputes constants
+const getDetuner = (unison, detune) => {
+  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);
 };

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

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

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

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

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

    const k = Math.min(8, resonance * 0.13);
@@ -430,9 +426,10 @@ class DistortProcessor extends AudioWorkletProcessor {
    ];
  }

-  constructor() {
+  constructor({ processorOptions }) {
    super();
    this.started = false;
+    this.algorithm = getDistortionAlgorithm(processorOptions.algorithm);
  }

  process(inputs, outputs, parameters) {
@@ -444,13 +441,12 @@ class DistortProcessor extends AudioWorkletProcessor {
      return false;
    }
    this.started = hasInput;
-
-    const shape = Math.expm1(parameters.distort[0]);
-    const postgain = Math.max(0.001, Math.min(1, parameters.postgain[0]));
-
    for (let n = 0; n < blockSize; n++) {
-      for (let i = 0; i < input.length; i++) {
-        output[i][n] = (((1 + shape) * input[i][n]) / (1 + shape * Math.abs(input[i][n]))) * postgain;
+      const postgain = clamp(pv(parameters.postgain, n), 0.001, 1);
+      const shape = Math.expm1(pv(parameters.distort, n));
+      for (let ch = 0; ch < input.length; ch++) {
+        const x = input[ch][n];
+        output[ch][n] = postgain * this.algorithm(x, shape);
      }
    }
    return true;
@@ -507,6 +503,7 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
        name: 'voices',
        defaultValue: 5,
        min: 1,
+        automationRate: 'k-rate',
      },
    ];
  }
@@ -518,40 +515,37 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
      // this.port.postMessage({ type: 'onended' });
      return false;
    }
-
    const output = outputs[0];
-
+    const voices = params.voices[0]; // k-rate
    for (let i = 0; i < output[0].length; i++) {
      const detune = pv(params.detune, i);
-      const voices = pv(params.voices, i);
      const freqspread = pv(params.freqspread, i);
      const panspread = pv(params.panspread, i) * 0.5 + 0.5;
-      const gain1 = Math.sqrt(1 - panspread);
-      const gain2 = Math.sqrt(panspread);
+      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++) {
-        const isOdd = (n & 1) == 1;
-        let gainL = gain1;
-        let gainR = gain2;
-        // invert right and left gain
-        if (isOdd) {
-          gainL = gain2;
-          gainR = gain1;
-        }
        // Individual voice detuning
-        const freqVoice = applySemitoneDetuneToFrequency(freq, getUnisonDetune(voices, freqspread, n));
+        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 = mod(freqVoice / sampleRate, 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] = output[0][i] + v * gainL;
-        output[1][i] = output[1][i] + v * gainR;
+        output[0][i] += v * gainL;
+        output[1][i] += v * gainR;

-        this.phase[n] = wrapPhase(this.phase[n] + dt);
+        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;
@@ -563,12 +557,16 @@ registerProcessor('supersaw-oscillator', SuperSawOscillatorProcessor);
 // Phase Vocoder sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
 const BUFFERED_BLOCK_SIZE = 2048;

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

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

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

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

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

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

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

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

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

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

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

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

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

    return true; // keep the audio processing going
@@ -976,6 +951,102 @@ class ByteBeatProcessor extends AudioWorkletProcessor {

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

+class EnvelopeProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: 'begin', defaultValue: 0 },
+      { name: 'end', defaultValue: 0 },
+      { name: 'attack', defaultValue: 0.005, minValue: 0 },
+      { name: 'decay', defaultValue: 0.14, minValue: 0 },
+      { name: 'sustain', defaultValue: 0, minValue: 0, maxValue: 1 },
+      { name: 'release', defaultValue: 0.1, minValue: 0 },
+      { name: 'attackCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
+      { name: 'decayCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
+      { name: 'releaseCurve', defaultValue: 0, minValue: -1, maxValue: 1 },
+      { name: 'peak', defaultValue: 1 },
+      { name: 'retrigger', defaultValue: 1, minValue: 0, maxValue: 1 },
+    ];
+  }
+
+  constructor() {
+    super();
+    this.val = 0;
+    this.segIdx = 0;
+    this.state = 0;
+    this.beginTime = 0;
+    this.endTime = 0;
+    this.attackStart = 0;
+  }
+
+  _warp(phase, curvature, strength = 8) {
+    if (phase === 0 || phase === 1) return phase; // fast exit
+    if (curvature > 0) {
+      // snappier
+      const exp = 1 + strength * curvature;
+      return 1 - Math.pow(1 - phase, exp);
+    } else {
+      // more calm
+      const exp = 1 - strength * curvature;
+      return Math.pow(phase, exp);
+    }
+  }
+
+  _advance(start, target, time, curvature) {
+    if (time === 0 || start === target) {
+      this.val = target;
+    } else {
+      // We compute our progress through this section of the envelope in time
+      // as a `phase` value, which is warped by the curvature, and then used
+      // to compute the value of the envelope at that time
+      const phase = Math.min(1, (currentTime - this.beginTime) / time);
+      const phaseWarped = this._warp(phase, curvature);
+      this.val = start + (target - start) * phaseWarped;
+    }
+  }
+
+  process(_inputs, outputs, params) {
+    const out = outputs[0][0];
+    if (!out) return true;
+    const begin = pv(params.begin, 0);
+    const retrigger = pv(params.retrigger, 0) >= 0.5; // convert to bool
+    if (begin !== this.beginTime && (this.state === 0 || retrigger)) {
+      // triggered
+      this.beginTime = begin;
+      this.state = 1;
+      this.endTime = pv(params.end, 0);
+      this.attackStart = this.val;
+    }
+    const susTime = this.endTime - this.beginTime;
+    for (let i = 0; i < out.length; i++) {
+      const attack = pv(params.attack, i);
+      const decay = pv(params.decay, i);
+      const sustain = pv(params.sustain, i);
+      const release = pv(params.release, i);
+      const aCurve = pv(params.attackCurve, i);
+      const dCurve = pv(params.decayCurve, i);
+      const rCurve = pv(params.releaseCurve, i);
+      const peak = pv(params.peak, i);
+      const states = [
+        { time: Number.POSITIVE_INFINITY, start: 0, target: 0 }, // idle
+        { time: attack, start: this.attackStart, target: 1, curve: aCurve },
+        { time: attack + decay, start: 1, target: sustain, curve: dCurve },
+        { time: susTime, start: sustain, target: sustain },
+        { time: susTime + release, start: sustain, target: 0, curve: rCurve },
+      ];
+      let { time, start, target, curve } = states[this.state];
+      this._advance(start, target, time, curve);
+      while (currentTime - this.beginTime >= time) {
+        this.state = (this.state + 1) % states.length;
+        time = states[this.state].time;
+      }
+      out[i] = this.val * peak;
+    }
+    return true;
+  }
+}
+
+registerProcessor('envelope-processor', EnvelopeProcessor);
+
 export const WarpMode = Object.freeze({
  NONE: 0,
  ASYM: 1,
@@ -1049,14 +1120,15 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
    return [
      { name: 'begin', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
      { name: 'end', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
-      { name: 'frequency', defaultValue: 220, minValue: 0.01, maxValue: 20000 },
-      { name: 'detune', defaultValue: 0.18 },
-      { name: 'position', defaultValue: 0, minValue: 0, maxValue: 1 },
-      { name: 'warp', defaultValue: 0, minValue: 0, maxValue: 1 },
+      { name: 'frequency', defaultValue: 440, min: Number.EPSILON },
+      { name: 'detune', defaultValue: 0 },
+      { 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, minValue: 1, maxValue: 32 },
-      { name: 'spread', defaultValue: 0.7, minValue: 0, maxValue: 1 },
-      { name: 'phaserand', defaultValue: 0, minValue: 0, maxValue: 1 },
+      { name: 'voices', defaultValue: 1, min: 1, automationRate: 'k-rate' },
+      { name: 'panspread', defaultValue: 0.7, min: 0, max: 1 },
+      { name: 'phaserand', defaultValue: 0, min: 0, max: 1 },
    ];
  }

@@ -1065,7 +1137,6 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
    this.frameLen = 0;
    this.numFrames = 0;
    this.phase = [];
-    this.invSR = 1 / sampleRate;

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

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

  _warpPhase(phase, amt, mode) {
@@ -1128,7 +1199,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        return amt < 0.5 ? this._warpPhase(phase, 1 - 2 * amt, 3) : this._warpPhase(phase, 2 * amt - 1, 2);
      }
      case WarpMode.SYNC: {
-        const syncRatio = Math.pow(16, amt * amt);
+        const syncRatio = Math.pow(16, amt ** 2);
        return (phase * syncRatio) % 1;
      }
      case WarpMode.QUANT: {
@@ -1137,8 +1208,8 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      }
      case WarpMode.FOLD: {
        const K = 7;
-        const k = 1 + Math.max(1, Math.round(K * amt));
-        return Math.abs(frac(k * phase) - 0.5) * 2;
+        const k = 1 + Math.max(1, fround(K * amt));
+        return Math.abs(ffrac(k * phase) - 0.5) * 2;
      }
      case WarpMode.PWM: {
        const w = clamp(0.5 + 0.49 * (2 * amt - 1), 0, 1);
@@ -1148,12 +1219,12 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      case WarpMode.ORBIT: {
        const depth = 0.5 * amt;
        const n = 3;
-        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
+        return frac(phase + depth * Math.sin(TWO_PI * n * phase));
      }
      case WarpMode.SPIN: {
        const depth = 0.5 * amt;
        const { n } = this._toBits(amt, 1, 6);
-        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
+        return frac(phase + depth * Math.sin(TWO_PI * n * phase));
      }
      case WarpMode.CHAOS: {
        const r = 3.7 + 0.3 * amt;
@@ -1164,7 +1235,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        const isPrime = (n) => {
          if (n < 2) return false;
          if (n % 2 === 0) return n === 2;
-          for (let d = 3; d * d <= n; d += 2) if (n % d === 0) return false;
+          for (let d = 3; d ** 2 <= n; d += 2) if (n % d === 0) return false;
          return true;
        };
        let { n } = this._toBits(amt, 3);
@@ -1173,18 +1244,12 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      }
      case WarpMode.BINARY: {
        let { b } = this._toBits(amt, 3);
-        b = Math.round(b);
+        b = fround(b);
        const n = 1 << b;
        const idx = ffloor(phase * n);
        const ridx = bitReverse(idx, b);
        return ridx / n;
      }
-      case WarpMode.MODULAR: {
-        const { n } = this._toBits(amt);
-        const depth = 0.5 * amt;
-        const jump = frac(phase * n) / n;
-        return frac(phase + depth * jump);
-      }
      case WarpMode.BROWNIAN: {
        const disp = 0.25 * amt * brownian(64 * phase, 4);
        return frac(phase + disp);
@@ -1207,7 +1272,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      case WarpMode.LOGISTIC: {
        let x = phase;
        const r = 3.6 + 0.4 * amt;
-        const iters = 1 + Math.round(2 * amt);
+        const iters = 1 + fround(2 * amt);
        for (let i = 0; i < iters; i++) x = r * x * (1 - x);
        return clamp(x, 0, 1);
      }
@@ -1220,7 +1285,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        return (y - y0) / (y1 - y0);
      }
      case WarpMode.FRACTAL: {
-        const d = 0.5 * Math.sin(2 * Math.PI * phase) * amt;
+        const d = 0.5 * Math.sin(TWO_PI * phase) * amt;
        return frac(phase + d);
      }
      case WarpMode.FLIP: {
@@ -1234,10 +1299,12 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
  _sampleFrame(frame, phase) {
    const len = frame.length;
    const pos = phase * len;
-    const i = pos | 0;
+    let i = pos | 0;
+    if (i >= len) i = 0; // fast wrap
    const frac = pos - i;
    const a = frame[i];
-    const i1 = i + 1 < len ? i + 1 : 0; // fast wrap
+    let i1 = i + 1;
+    if (i1 >= len) i1 = 0;
    const b = frame[i1];
    return a + (b - a) * frac;
  }
@@ -1265,22 +1332,24 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
      if (outR !== outL) outR.set(outL);
      return true;
    }
+    const voices = parameters.voices[0]; // k-rate
    for (let i = 0; i < outL.length; i++) {
      const detune = pv(parameters.detune, i);
+      const freqspread = pv(parameters.freqspread, i);
      const tablePos = clamp(pv(parameters.position, i), 0, 1);
      const idx = tablePos * (this.numFrames - 1);
      const fIdx = idx | 0;
-      const frac = idx - fIdx;
+      const interpT = idx - fIdx;
      const warpAmount = clamp(pv(parameters.warp, i), 0, 1);
      const warpMode = pv(parameters.warpMode, i);
-      const voices = pv(parameters.voices, i);
      const phaseRand = clamp(pv(parameters.phaserand, i), 0, 1);
-      const spread = voices > 1 ? clamp(pv(parameters.spread, i), 0, 1) : 0;
-      const gain1 = Math.sqrt(0.5 - 0.5 * spread);
-      const gain2 = Math.sqrt(0.5 + 0.5 * spread);
+      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;
@@ -1290,8 +1359,8 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
          gainL = gain2;
          gainR = gain1;
        }
-        const fVoice = applySemitoneDetuneToFrequency(f, getUnisonDetune(voices, detune, n)); // voice detune
-        const dPhase = fVoice * this.invSR;
+        const fVoice = applySemitoneDetuneToFrequency(f, detuner(n)); // voice detune
+        const dPhase = fVoice * INVSR;
        const level = this._chooseMip(dPhase);
        const table = this.tables[level];

@@ -1300,13 +1369,13 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
        const ph = this._warpPhase(this.phase[n], warpAmount, warpMode);
        const s0 = this._sampleFrame(table[fIdx], ph);
        const s1 = this._sampleFrame(table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
-        let s = s0 + (s1 - s0) * frac;
+        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] = wrapPhase(this.phase[n] + dPhase);
+        this.phase[n] = frac(this.phase[n] + dPhase);
      }
    }
    return true;
@@ -1,6 +1,7 @@
 //import { ZZFX } from 'zzfx';
 import { midiToFreq, noteToMidi } from './util.mjs';
-import { registerSound, getAudioContext } from './superdough.mjs';
+import { registerSound } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import { buildSamples } from './zzfx_fork.mjs';

 export const getZZFX = (value, t) => {
@@ -1,4 +1,4 @@
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';

 // https://github.com/KilledByAPixel/ZzFX/blob/master/ZzFX.js#L85C5-L180C6
 // changes: replaced this.volume with 1 + using sampleRate from getAudioContext()
@@ -1,11 +1,12 @@
 // this is dough, the superdough without dependencies
-// @ts-check
+// @ts-nocheck
 // @ts-ignore ignore next line because sampleRate is unknown
 const SAMPLE_RATE = typeof sampleRate !== 'undefined' ? sampleRate : 48000;
 const PI_DIV_SR = Math.PI / SAMPLE_RATE;
 const ISR = 1 / SAMPLE_RATE;

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

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

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

    const r = Math.pow(0.5, (resonance + 0.125) / 0.125);
    const mrc = 1 - r * c;
@@ -1,6 +1,6 @@
 {
  "name": "supradough",
-  "version": "1.2.3",
+  "version": "1.2.4",
  "description": "platform agnostic synth and sampler intended for live coding. a reimplementation of superdough.",
  "main": "index.mjs",
  "type": "module",
@@ -13,7 +13,7 @@
  },
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/tidalcycles/strudel.git"
+    "url": "git+https://codeberg.org/uzu/strudel.git"
  },
  "keywords": [
    "tidalcycles",
@@ -25,13 +25,15 @@
  "author": "Felix Roos <flix91@gmail.com>",
  "license": "AGPL-3.0-or-later",
  "bugs": {
-    "url": "https://github.com/tidalcycles/strudel/issues"
+    "url": "https://codeberg.org/uzu/strudel/issues"
  },
-  "homepage": "https://github.com/tidalcycles/strudel#readme",
+  "homepage": "https://codeberg.org/uzu/strudel#readme",
  "devDependencies": {
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*",
    "wav-encoder": "^1.3.0"
  },
-  "dependencies": {}
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }
@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [bundleAudioWorkletPlugin()],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'index.mjs'),
+      formats: ['es'],
+      fileName: (ext) => ({ es: 'index.mjs' })[ext],
+    },
+    target: 'esnext',
+  },
+});
@@ -25,5 +25,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,9 +1,9 @@
 import './tonal.mjs';
 import './voicings.mjs';
+import './ireal.mjs';

 export * from './tonal.mjs';
 export * from './voicings.mjs';
-
-import './ireal.mjs';
+export * from './ireal.mjs';

 export const packageName = '@strudel/tonal';
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/tonal",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Tonal functions for strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -38,5 +38,8 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -61,13 +61,6 @@ describe('tonal', () => {
          .firstCycleValues.map((h) => h.note),
      ).toEqual(['B2', 'Eb3', 'A2', 'G3', 'F3']);
    });
-    it('produces silence for mixed sharps and flats', () => {
-      expect(
-        n(seq('0b#', '1#b', '2#b#'))
-          .scale('C major')
-          .firstCycleValues.map((h) => h.note),
-      ).toEqual([]);
-    });
    it('snaps notes (upwards) to scale', () => {
      const inputNotes = ['Cb', 'Eb', 'G', 'A#', 'Bb'];
      const expectedNotes = ['B2', 'E3', 'G3', 'B3', 'B3'];
@@ -5,9 +5,17 @@ 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, silence, logger, pure, isNote } from '@strudel/core';
+import {
+  _mod,
+  errorLogger,
+  getAccidentalsOffset,
+  isNote,
+  logger,
+  noteToMidi,
+  register,
+  removeUndefineds,
+} from '@strudel/core';
 import { stepInNamedScale, nearestNumberIndex } from './tonleiter.mjs';
-import { noteToMidi } from '../core/util.mjs';

 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';

@@ -185,17 +193,15 @@ function _convertStepToNumberAndOffset(step) {
    step = String(step);
    // Check to see if the step matches the expected format:
    // - A number (possibly negative)
-    // - Some number of sharps or flats (but not both)
-    const match = /^(-?\d+)(#+|b+)?$/.exec(step);
+    // - Some number of sharps or flats
+    const match = /^(-?\d+)([#bsf]*)$/.exec(step);

    if (!match) {
      throw new Error(`invalid scale step "${step}", expected number or integer with optional # b suffixes`);
    }
    asNumber = Number(match[1]);
-    // These decorations will determine the semitone offset based on the number of
-    // sharps or flats
-    const decorations = match[2] || '';
-    offset = decorations[0] === '#' ? decorations.length : -decorations.length;
+    const accidentals = match[2] || '';
+    offset = getAccidentalsOffset(accidentals);
  }
  return [asNumber, offset];
 }
@@ -226,12 +232,15 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
 * Turns numbers into notes in the scale (zero indexed) or quantizes notes to a scale.
 *
 * When describing notes via numbers, note that negative numbers can be used to wrap backwards
- * in the scale as well as sharps or flats (but not both) to produce notes outside of the scale.
+ * in the scale as well as sharps or flats to produce notes outside of the scale.
 *
 * Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
 *
 * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by semicolon (':') and then a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
 *
+ * The scale name must be written without spaces (because it would be interpreted as a multi-step pattern otherwise).
+ * If your scale name includes spaces, replace them with colons.
+ *
 * The root note defaults to octave 3, if no octave number is given.
 *
 * @name scale
@@ -253,8 +262,9 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
 * .s("piano")
 * @example
 * note("C1*16").transpose(irand(36)).scale('Cb2 major').scaleTranspose(3)
+ * @example
+ * n("[0 0] [1 2] [3 4] [5 6]").scale("C:major:blues")
 */
-
 export const scale = register(
  'scale',
  function (scale, pat) {
@@ -262,44 +272,47 @@ export const scale = register(
    if (Array.isArray(scale)) {
      scale = scale.flat().join(' ');
    }
-    return (
-      pat
-        .fmap((value) => {
-          const isObject = typeof value === 'object';
-          // The case where the note has been defined via `n` or `pure`
-          if (!isObject || (isObject && ('n' in value || 'value' in value))) {
-            const step = isObject ? (value.n ?? value.value) : value;
-            delete value.n; // remove n so it won't cause trouble
-            if (isNote(step)) {
-              // legacy..
-              return pure(step);
+    return pat.withHaps((haps) => {
+      haps = haps.map((hap) => {
+        let hVal = hap.value;
+        const isObject = typeof hVal === 'object';
+        // If hVal is a pure value, place it on `n` so that we interpret it as a scale degree
+        hVal = isObject ? hVal : { n: hVal };
+        const { note, n, value, ...otherValues } = hVal;
+        const noteOrStep = note ?? n ?? value;
+        if (noteOrStep === undefined) {
+          logger(
+            `[tonal] Invalid value format for 'scale'. Value must contain n, note, or value but received keys [${Object.keys(hVal).join(', ')}]`,
+            'error',
+          );
+          return hap; // pass the value through unchanged
+        }
+        let scaleNote;
+        if (isNote(noteOrStep)) {
+          // Note case (quantize to scale)
+          scaleNote = _getNearestScaleNote(scale, noteOrStep);
+          hap.value = { ...otherValues, note: scaleNote };
+        } else {
+          // Step case (convert to note in scale)
+          try {
+            const [number, offset] = _convertStepToNumberAndOffset(noteOrStep);
+            if (otherValues.anchor) {
+              scaleNote = stepInNamedScale(number, scale, otherValues.anchor);
+            } else {
+              scaleNote = scaleStep(number, scale);
            }
-            try {
-              const [number, offset] = _convertStepToNumberAndOffset(step);
-              let note;
-              if (isObject && value.anchor) {
-                note = stepInNamedScale(number, scale, value.anchor);
-              } else {
-                note = scaleStep(number, scale);
-              }
-              if (offset != 0) note = Note.transpose(note, Interval.fromSemitones(offset));
-              value = pure(isObject ? { ...value, note } : note);
-            } catch (err) {
-              logger(`[tonal] ${err.message}`, 'error');
-              return silence;
-            }
-            return value;
+            if (offset != 0) scaleNote = Note.transpose(scaleNote, Interval.fromSemitones(offset));
+          } catch (err) {
+            errorLogger(err, 'tonal');
+            return; // will be removed
          }
-          // The case where the note has been defined via `note`
-          else {
-            const note = _getNearestScaleNote(scale, value.note);
-            return pure(isObject ? { ...value, note } : note);
-          }
-        })
-        .outerJoin()
-        // legacy:
-        .withHap((hap) => hap.setContext({ ...hap.context, scale }))
-    );
+        }
+        hap.value = isObject ? { ...otherValues, note: scaleNote } : scaleNote;
+        // Tag with scale for downsteam scale-aware operations
+        return hap.setContext({ ...hap.context, scale });
+      });
+      return removeUndefineds(haps);
+    });
  },
  true,
  true, // preserve step count
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/transpiler",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Transpiler for strudel user code. Converts syntactically correct but semantically meaningless JS into evaluatable strudel code.",
  "main": "index.mjs",
  "type": "module",
@@ -39,5 +39,8 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -12,5 +12,8 @@
  "type": "module",
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -62,7 +62,7 @@ initStrudel();
 document.getElementById('play').addEventListener('click', 
  () => evaluate('note("c a f e").jux(rev)')
 );
-document.getElementById('play').addEventListener('stop', 
+document.getElementById('stop').addEventListener('click', 
  () => hush()
 );
 ```
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/web",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Easy to setup, opiniated bundle of Strudel for the browser.",
  "module": "web.mjs",
  "publishConfig": {
@@ -43,5 +43,8 @@
    "@rollup/plugin-replace": "^6.0.2",
    "vite": "^6.0.11",
    "vite-plugin-bundle-audioworklet": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/webaudio",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Web Audio helpers for Strudel",
  "main": "index.mjs",
  "type": "module",
@@ -40,5 +40,8 @@
  },
  "devDependencies": {
    "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/xen",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "description": "Xenharmonic API for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -35,5 +35,8 @@
  "devDependencies": {
    "vite": "^6.0.11",
    "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -41,7 +41,6 @@ Tune.prototype.tonicize = function(newTonic) {
 	this.tonic = newTonic
 }

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

 Tune.prototype.note = function(input,octave){
@@ -41,7 +41,7 @@ importers:
        version: 2.2.7
      '@vitest/coverage-v8':
        specifier: 3.0.4
-        version: 3.0.4(vitest@3.0.4)
+        version: 3.0.4(vitest@3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0))
      '@vitest/ui':
        specifier: ^3.0.4
        version: 3.0.4(vitest@3.0.4)
@@ -212,12 +212,21 @@ importers:
      '@strudel/draw':
        specifier: workspace:*
        version: link:../draw
+      '@strudel/tonal':
+        specifier: workspace:*
+        version: link:../tonal
      '@strudel/transpiler':
        specifier: workspace:*
        version: link:../transpiler
+      '@tonaljs/tonal':
+        specifier: ^4.10.0
+        version: 4.10.0
      nanostores:
        specifier: ^0.11.3
        version: 0.11.3
+      superdough:
+        specifier: workspace:*
+        version: link:../superdough
    devDependencies:
      vite:
        specifier: ^6.0.11
@@ -406,9 +415,12 @@ importers:
      '@strudel/core':
        specifier: workspace:*
        version: link:../core
-      osc-js:
-        specifier: ^2.4.1
-        version: 2.4.1
+      osc:
+        specifier: ^2.4.5
+        version: 2.4.5
+      ws:
+        specifier: ^8.18.3
+        version: 8.18.3
    devDependencies:
      pkg:
        specifier: ^5.8.1
@@ -2420,6 +2432,70 @@ packages:
  '@rtsao/scc@1.1.0':
    resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==}

+  '@serialport/binding-mock@10.2.2':
+    resolution: {integrity: sha512-HAFzGhk9OuFMpuor7aT5G1ChPgn5qSsklTFOTUX72Rl6p0xwcSVsRtG/xaGp6bxpN7fI9D/S8THLBWbBgS6ldw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/bindings-cpp@12.0.1':
+    resolution: {integrity: sha512-r2XOwY2dDvbW7dKqSPIk2gzsr6M6Qpe9+/Ngs94fNaNlcTRCV02PfaoDmRgcubpNVVcLATlxSxPTIDw12dbKOg==}
+    engines: {node: '>=16.0.0'}
+
+  '@serialport/bindings-interface@1.2.2':
+    resolution: {integrity: sha512-CJaUd5bLvtM9c5dmO9rPBHPXTa9R2UwpkJ0wdh9JCYcbrPWsKz+ErvR0hBLeo7NPeiFdjFO4sonRljiw4d2XiA==}
+    engines: {node: ^12.22 || ^14.13 || >=16}
+
+  '@serialport/parser-byte-length@12.0.0':
+    resolution: {integrity: sha512-0ei0txFAj+s6FTiCJFBJ1T2hpKkX8Md0Pu6dqMrYoirjPskDLJRgZGLqoy3/lnU1bkvHpnJO+9oJ3PB9v8rNlg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-cctalk@12.0.0':
+    resolution: {integrity: sha512-0PfLzO9t2X5ufKuBO34DQKLXrCCqS9xz2D0pfuaLNeTkyGUBv426zxoMf3rsMRodDOZNbFblu3Ae84MOQXjnZw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-delimiter@11.0.0':
+    resolution: {integrity: sha512-aZLJhlRTjSmEwllLG7S4J8s8ctRAS0cbvCpO87smLvl3e4BgzbVgF6Z6zaJd3Aji2uSiYgfedCdNc4L6W+1E2g==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-delimiter@12.0.0':
+    resolution: {integrity: sha512-gu26tVt5lQoybhorLTPsH2j2LnX3AOP2x/34+DUSTNaUTzu2fBXw+isVjQJpUBFWu6aeQRZw5bJol5X9Gxjblw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-inter-byte-timeout@12.0.0':
+    resolution: {integrity: sha512-GnCh8K0NAESfhCuXAt+FfBRz1Cf9CzIgXfp7SdMgXwrtuUnCC/yuRTUFWRvuzhYKoAo1TL0hhUo77SFHUH1T/w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-packet-length@12.0.0':
+    resolution: {integrity: sha512-p1hiCRqvGHHLCN/8ZiPUY/G0zrxd7gtZs251n+cfNTn+87rwcdUeu9Dps3Aadx30/sOGGFL6brIRGK4l/t7MuQ==}
+    engines: {node: '>=8.6.0'}
+
+  '@serialport/parser-readline@11.0.0':
+    resolution: {integrity: sha512-rRAivhRkT3YO28WjmmG4FQX6L+KMb5/ikhyylRfzWPw0nSXy97+u07peS9CbHqaNvJkMhH1locp2H36aGMOEIA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-readline@12.0.0':
+    resolution: {integrity: sha512-O7cywCWC8PiOMvo/gglEBfAkLjp/SENEML46BXDykfKP5mTPM46XMaX1L0waWU6DXJpBgjaL7+yX6VriVPbN4w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-ready@12.0.0':
+    resolution: {integrity: sha512-ygDwj3O4SDpZlbrRUraoXIoIqb8sM7aMKryGjYTIF0JRnKeB1ys8+wIp0RFMdFbO62YriUDextHB5Um5cKFSWg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-regex@12.0.0':
+    resolution: {integrity: sha512-dCAVh4P/pZrLcPv9NJ2mvPRBg64L5jXuiRxIlyxxdZGH4WubwXVXY/kBTihQmiAMPxbT3yshSX8f2+feqWsxqA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-slip-encoder@12.0.0':
+    resolution: {integrity: sha512-0APxDGR9YvJXTRfY+uRGhzOhTpU5akSH183RUcwzN7QXh8/1jwFsFLCu0grmAUfi+fItCkR+Xr1TcNJLR13VNA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/parser-spacepacket@12.0.0':
+    resolution: {integrity: sha512-dozONxhPC/78pntuxpz/NOtVps8qIc/UZzdc/LuPvVsqCoJXiRxOg6ZtCP/W58iibJDKPZPAWPGYeZt9DJxI+Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/stream@12.0.0':
+    resolution: {integrity: sha512-9On64rhzuqKdOQyiYLYv2lQOh3TZU/D3+IWCR5gk0alPel2nwpp4YwDEGiUBfrQZEdQ6xww0PWkzqth4wqwX3Q==}
+    engines: {node: '>=12.0.0'}
+
  '@shikijs/core@1.29.1':
    resolution: {integrity: sha512-Mo1gGGkuOYjDu5H8YwzmOuly9vNr8KDVkqj9xiKhhhFS8jisAtDSEWB9hzqRHLVQgFdA310e8XRJcW4tYhRB2A==}

@@ -3672,6 +3748,15 @@ packages:
      supports-color:
        optional: true

+  debug@4.3.4:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
  debug@4.4.0:
    resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
    engines: {node: '>=6.0'}
@@ -5281,6 +5366,9 @@ packages:
    resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
    engines: {node: '>=10'}

+  long@4.0.0:
+    resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==}
+
  longest-streak@3.1.0:
    resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}

@@ -5664,6 +5752,9 @@ packages:
  ms@2.0.0:
    resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}

+  ms@2.1.2:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
  ms@2.1.3:
    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}

@@ -5722,6 +5813,9 @@ packages:
    resolution: {integrity: sha512-z8iYzQGBu35ZkTQ9mtR8RqugJZ9RCLn8fv3d7LsgDBzOijGQP3RdKTX4LA7LXw03ZhU5z0l4xfhIMgSES31+cg==}
    engines: {node: '>=10'}

+  node-addon-api@7.0.0:
+    resolution: {integrity: sha512-vgbBJTS4m5/KkE16t5Ly0WW9hz46swAstv0hYYwMtbG7AznRhNyfLRe8HZAiWIpcHzoO7HxhLuBQj9rJ/Ho0ZA==}
+
  node-addon-api@8.3.0:
    resolution: {integrity: sha512-8VOpLHFrOQlAH+qA0ZzuGRlALRA6/LVh8QJldbrC4DY0hXoMP0l4Acq8TzFC018HztWiRqyCEj2aTWY2UvnJUg==}
    engines: {node: ^18 || ^20 || >= 21}
@@ -5760,6 +5854,10 @@ packages:
    resolution: {integrity: sha512-yqkmYrMbK1wPrfz7mgeYvA4tBperLg9FQ4S3Sau3nSAkpOA0x0zC8nQ1siBwozy1f4SE8vq2n1WKv99r+PCa1Q==}
    engines: {node: '>= 0.6.0'}

+  node-gyp-build@4.6.0:
+    resolution: {integrity: sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==}
+    hasBin: true
+
  node-gyp-build@4.8.4:
    resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
    hasBin: true
@@ -5918,8 +6016,8 @@ packages:
    resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==}
    engines: {node: '>=0.10.0'}

-  osc-js@2.4.1:
-    resolution: {integrity: sha512-QlSeRKJclL47FNvO1MUCAAp9frmCF9zcYbnf6R9HpcklAst8ZyX3ISsk1v/Vghr/5GmXn0bhVjFXF9h+hfnl4Q==}
+  osc@2.4.5:
+    resolution: {integrity: sha512-Nc4/qcl+vA/CMxiKS1xrYgzjfnyB3W94gZnrkn3eTzihlndbEml6+wj1YQNKBI4r+qrw3obCcEoU7SVH/OxpxA==}

  own-keys@1.0.1:
    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
@@ -6680,6 +6778,10 @@ packages:
  serialize-javascript@4.0.0:
    resolution: {integrity: sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==}

+  serialport@12.0.0:
+    resolution: {integrity: sha512-AmH3D9hHPFmnF/oq/rvigfiAouAKyK/TjnrkwZRYSFZxNggJxwvbAbfYrLeuvq7ktUdhuHdVdSjj852Z55R+uA==}
+    engines: {node: '>=16.0.0'}
+
  set-blocking@2.0.0:
    resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}

@@ -6767,6 +6869,9 @@ packages:
    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
    engines: {node: '>=8'}

+  slip@1.0.2:
+    resolution: {integrity: sha512-XrcHe3NAcyD3wO+O4I13RcS4/3AF+S9RvGNj9JhJeS02HyImwD2E3QWLrmn9hBfL+fB6yapagwxRkeyYzhk98g==}
+
  smart-buffer@4.2.0:
    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
@@ -7642,6 +7747,9 @@ packages:
    resolution: {integrity: sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==}
    engines: {node: '>=18'}

+  wolfy87-eventemitter@5.2.9:
+    resolution: {integrity: sha512-P+6vtWyuDw+MB01X7UeF8TaHBvbCovf4HPEMF/SV7BdDc1SMTiBy13SRD71lQh4ExFTG1d/WNzDGDCyOKSMblw==}
+
  word-wrap@1.2.5:
    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
    engines: {node: '>=0.10.0'}
@@ -7764,6 +7872,18 @@ packages:
      utf-8-validate:
        optional: true

+  ws@8.18.3:
+    resolution: {integrity: sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
  xmlcreate@2.0.4:
    resolution: {integrity: sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==}

@@ -9760,6 +9880,76 @@ snapshots:

  '@rtsao/scc@1.1.0': {}

+  '@serialport/binding-mock@10.2.2':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.4.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@serialport/bindings-cpp@12.0.1':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      '@serialport/parser-readline': 11.0.0
+      debug: 4.3.4
+      node-addon-api: 7.0.0
+      node-gyp-build: 4.6.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@serialport/bindings-interface@1.2.2':
+    optional: true
+
+  '@serialport/parser-byte-length@12.0.0':
+    optional: true
+
+  '@serialport/parser-cctalk@12.0.0':
+    optional: true
+
+  '@serialport/parser-delimiter@11.0.0':
+    optional: true
+
+  '@serialport/parser-delimiter@12.0.0':
+    optional: true
+
+  '@serialport/parser-inter-byte-timeout@12.0.0':
+    optional: true
+
+  '@serialport/parser-packet-length@12.0.0':
+    optional: true
+
+  '@serialport/parser-readline@11.0.0':
+    dependencies:
+      '@serialport/parser-delimiter': 11.0.0
+    optional: true
+
+  '@serialport/parser-readline@12.0.0':
+    dependencies:
+      '@serialport/parser-delimiter': 12.0.0
+    optional: true
+
+  '@serialport/parser-ready@12.0.0':
+    optional: true
+
+  '@serialport/parser-regex@12.0.0':
+    optional: true
+
+  '@serialport/parser-slip-encoder@12.0.0':
+    optional: true
+
+  '@serialport/parser-spacepacket@12.0.0':
+    optional: true
+
+  '@serialport/stream@12.0.0':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
  '@shikijs/core@1.29.1':
    dependencies:
      '@shikijs/engine-javascript': 1.29.1
@@ -10364,7 +10554,7 @@ snapshots:
    transitivePeerDependencies:
      - supports-color

-  '@vitest/coverage-v8@3.0.4(vitest@3.0.4)':
+  '@vitest/coverage-v8@3.0.4(vitest@3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0))':
    dependencies:
      '@ampproject/remapping': 2.3.0
      '@bcoe/v8-coverage': 1.0.2
@@ -11272,6 +11462,11 @@ snapshots:
    dependencies:
      ms: 2.1.3

+  debug@4.3.4:
+    dependencies:
+      ms: 2.1.2
+    optional: true
+
  debug@4.4.0:
    dependencies:
      ms: 2.1.3
@@ -13141,6 +13336,8 @@ snapshots:
      chalk: 4.1.2
      is-unicode-supported: 0.1.0

+  long@4.0.0: {}
+
  longest-streak@3.1.0: {}

  loupe@3.1.2: {}
@@ -13818,6 +14015,9 @@ snapshots:

  ms@2.0.0: {}

+  ms@2.1.2:
+    optional: true
+
  ms@2.1.3: {}

  multimatch@5.0.0:
@@ -13867,6 +14067,9 @@ snapshots:
    dependencies:
      semver: 7.6.3

+  node-addon-api@7.0.0:
+    optional: true
+
  node-addon-api@8.3.0: {}

  node-domexception@1.0.0: {}
@@ -13893,6 +14096,9 @@ snapshots:

  node-getopt@0.3.2: {}

+  node-gyp-build@4.6.0:
+    optional: true
+
  node-gyp-build@4.8.4: {}

  node-gyp@10.3.1:
@@ -14144,11 +14350,17 @@ snapshots:

  os-tmpdir@1.0.2: {}

-  osc-js@2.4.1:
+  osc@2.4.5:
    dependencies:
+      long: 4.0.0
+      slip: 1.0.2
+      wolfy87-eventemitter: 5.2.9
      ws: 8.18.0
+    optionalDependencies:
+      serialport: 12.0.0
    transitivePeerDependencies:
      - bufferutil
+      - supports-color
      - utf-8-validate

  own-keys@1.0.1:
@@ -15043,6 +15255,26 @@ snapshots:
    dependencies:
      randombytes: 2.1.0

+  serialport@12.0.0:
+    dependencies:
+      '@serialport/binding-mock': 10.2.2
+      '@serialport/bindings-cpp': 12.0.1
+      '@serialport/parser-byte-length': 12.0.0
+      '@serialport/parser-cctalk': 12.0.0
+      '@serialport/parser-delimiter': 12.0.0
+      '@serialport/parser-inter-byte-timeout': 12.0.0
+      '@serialport/parser-packet-length': 12.0.0
+      '@serialport/parser-readline': 12.0.0
+      '@serialport/parser-ready': 12.0.0
+      '@serialport/parser-regex': 12.0.0
+      '@serialport/parser-slip-encoder': 12.0.0
+      '@serialport/parser-spacepacket': 12.0.0
+      '@serialport/stream': 12.0.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
  set-blocking@2.0.0: {}

  set-function-length@1.2.2:
@@ -15185,6 +15417,8 @@ snapshots:

  slash@3.0.0: {}

+  slip@1.0.2: {}
+
  smart-buffer@4.2.0: {}

  socks-proxy-agent@8.0.5:
@@ -16094,6 +16328,8 @@ snapshots:
    dependencies:
      string-width: 7.2.0

+  wolfy87-eventemitter@5.2.9: {}
+
  word-wrap@1.2.5: {}

  wordwrap@0.0.3: {}
@@ -16293,6 +16529,8 @@ snapshots:

  ws@8.18.0: {}

+  ws@8.18.3: {}
+
  xmlcreate@2.0.4: {}

  xtend@4.0.2: {}
@@ -4,11 +4,25 @@ import { describe, it } from 'vitest';

 const tuneKeys = Object.keys(tunes);

+// Node 24 tightened Number→string rounding; clamp decimals so snapshots stay stable across engines.
+const roundFloatStrings = (input, precision = 12) => {
+  // if matches a decimal number ex: 12.34, -0.5, 0.123, 99.0, 1.932093850293
+  const regex = /-?\d+\.\d+/g;
+  return input.replace(regex, (match) => {
+    // converts the literal to a number, performs round to nearest (ties to even)
+    // at the requested precision, and returns the rounded decimal string
+    const rounded = Number(match).toFixed(precision);
+    // trims trailing zeros (and a dangling dot) after rounding, so the displayed string looks tidy
+    return rounded.replace(/\.?0+$/, '').replace(/\.$/, '');
+  });
+};
+
 describe('renders tunes', () => {
  tuneKeys.forEach((key) => {
    it(`tune: ${key}`, async ({ expect }) => {
      const haps = await queryCode(tunes[key], testCycles[key] || 1);
-      expect(haps).toMatchSnapshot();
+      const normalized = haps.map((hap) => roundFloatStrings(hap));
+      expect(normalized).toMatchSnapshot();
    });
  });
 });
@@ -1,5 +1,9 @@
 {
+  "name": "dbpatch",
  "dependencies": {
    "csv": "^6.3.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -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);
+  });
+
+/*
+
+  */
@@ -75,5 +75,8 @@
    "sharp": "^0.33.5",
    "workbox-window": "^7.3.0",
    "vite-plugin-bundle-audioworklet": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
  }
 }
@@ -60,6 +60,23 @@ Strudel makes heavy use of chained functions. Here is a more sophisticated examp
 .room(0.5)`}
 />

+## Write your own chained function
+
+You can write your own chained function using `register`. Here's the above chain but registered as a reusable, chained function.
+
+<MiniRepl
+  client:idle
+  tune={`const effectChain = register('effectChain', (pat) => pat
+    .s("sawtooth")
+    .cutoff(500)
+    //.delay(0.5)
+    .room(0.5)
+  )
+note("a3 c#4 e4 a4").effectChain()`}
+/>
+
+Try adding `.rev()` after `effectChain()` to hear further effects added.
+
 # Comments

 The `//` in the example above is a line comment, resulting in the `delay` function being ignored.
@@ -63,7 +63,7 @@ You can also create custom aliases for existing sounds using the `soundAlias` fu

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

@@ -381,7 +381,7 @@ Sampler effects are functions that can be used to change the behaviour of sample

 ### scrub

-<JsDoc client:idle name="Pattern.scrub" h={0} />{' '}
+<JsDoc client:idle name="Pattern.scrub" h={0} />

 ### speed

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

 ### Additive Synthesis

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

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

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

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

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

 ## Vibrato

@@ -157,7 +223,7 @@ It has 20 parameters in total, here is a snippet that uses all:
  .pitchJump(0) // +/- pitch change after pitchJumpTime
  .pitchJumpTime(0) // >0 time after pitchJump is applied
  .lfo(0) // >0 resets slide + pitchJump + sets tremolo speed
-  .tremolo(0) // 0-1 lfo volume modulation amount
+  .tremolo(0.5) // 0-1 lfo volume modulation amount
  //.duration(.2) // overwrite strudel event duration
  //.gain(1) // change volume
  ._scope() // vizualise waveform (not zzfx related)
@@ -32,7 +32,7 @@ There are 3 quick ways to embed strudel in your website:

 ### Inside an iframe

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

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

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

 ## Via npm

--- a/Show More
+++ b/Show More