better defaults

Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1774

.forgejo/workflows/deploy-warm-beta.yml

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

.forgejo/workflows/deploy.yml

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

.gitignore

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

.nvmrc

@@ -0,0 +1 @@
+22

README.md

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

examples/codemirror-repl/package.json

@@ -20,5 +20,8 @@
     "@strudel/tonal": "workspace:*",
     "@strudel/transpiler": "workspace:*",
     "@strudel/webaudio": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

examples/headless-repl/package.json

@@ -14,5 +14,8 @@
   },
   "dependencies": {
     "@strudel/web": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

examples/minimal-repl/package.json

@@ -18,5 +18,8 @@
     "@strudel/transpiler": "workspace:*",
     "@strudel/webaudio": "workspace:*",
     "@strudel/tonal": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

examples/superdough/package.json

@@ -13,5 +13,8 @@
   },
   "devDependencies": {
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

examples/tidal-repl/package.json

@@ -32,5 +32,8 @@
   },
   "devDependencies": {
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

package.json

@@ -73,5 +73,8 @@
     "prettier": "^3.4.2",
     "vitest": "^3.0.4",
     "vite-plugin-bundle-audioworklet": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
-}
+}

packages/codemirror/autocomplete.mjs

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

packages/codemirror/codemirror.mjs

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

packages/codemirror/keybindings.mjs

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

packages/codemirror/package.json

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

packages/core/controls.mjs

@@ -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']);
 
 /**
@@ -2072,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');
@@ -2320,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);

packages/core/euclid.mjs

@@ -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);
 });

packages/core/package.json

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

packages/core/pattern.mjs

@@ -2574,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'],
@@ -2998,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*
  *
@@ -3606,3 +3624,66 @@ for (const name of distAlgoNames) {
     return this.distort(argsPat);
   };
 }
+
+/**
+ * Turns a list of patterns into a single pattern which outputs list-values
+ *
+ * @name parray
+ * @returns Pattern
+ */
+export const parray = (pats) => {
+  const pack = (...xs) => xs;
+  let acc = pure(curry(pack, null, pats.length));
+  for (const p of pats) acc = acc.appBoth(reify(p));
+  return acc;
+};
+
+const _ensureListPattern = (list) => {
+  if (Array.isArray(list)) {
+    return parray(list);
+  }
+  return reify(list);
+};
+
+/**
+ * Scale the magnitude of the harmonics of one of the core synths ('sine', 'tri', 'saw', ..)
+ *
+ * Can also be used to create a new synth via `s('user').partials(...)`
+ *
+ * @name partials
+ * @param {number[] | Pattern} magnitudes List of [0, 1] magnitudes for partials. 0th entry is the fundamental harmonic (i.e. DC offset is skipped)
+ * @example
+ * s("user").seg(16).n(irand(8)).scale("A:major")
+ *   .partials([1, 0, 1, 0, 0, 1])
+ * @example
+ * s("saw").seg(8).n(irand(12)).scale("G#:minor")
+ *   .partials(binaryL(irand(256).add("1")))
+ */
+Pattern.prototype.partials = function (list) {
+  return this.withValue((v) => (l) => ({ ...v, partials: l })).appLeft(_ensureListPattern(list));
+};
+
+// Also create a top-level function
+export const partials = (list) => {
+  return _ensureListPattern(list).as('partials');
+};
+
+/**
+ * Rotates the harmonics of one of the core synths ('sine', 'tri', 'saw', 'user', ..) by a list of phases
+ *
+ * @name phases
+ * @param {number[] | Pattern} phases List of [0, 1) phases for partials. 0th entry is the fundamental phase (i.e. DC offset is skipped)
+ * @example
+ * // Phase cancellation
+ * s("saw").seg(8).n(irand(12)).scale("G#1:minor")
+ *   .partials(partials([1, 1, 1]))
+ *   .superimpose(x => x.phases([0.5, 0.5, 0.5]))
+ */
+Pattern.prototype.phases = function (list) {
+  return this.withValue((v) => (l) => ({ ...v, phases: l })).appLeft(_ensureListPattern(list));
+};
+
+// Also create a top-level function
+export const phases = (list) => {
+  return _ensureListPattern(list).as('phases');
+};

packages/core/repl.mjs

@@ -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,8 +238,8 @@ 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);
         }
       }
 

packages/core/signal.mjs

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

packages/core/test/euclid.test.js

@@ -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]);
   });
 });
 

packages/core/util.mjs

@@ -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) => {

packages/csound/package.json

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

packages/desktopbridge/package.json

@@ -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"
+  }
 }

packages/draw/draw.mjs

@@ -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 });

packages/draw/package.json

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

packages/embed/package.json

@@ -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"
+  }
 }

packages/gamepad/README.md

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

packages/gamepad/docs/gamepad.mdx

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

packages/gamepad/gamepad.mjs

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

packages/gamepad/package.json

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

packages/hs2js/package.json

@@ -34,5 +34,8 @@
   "devDependencies": {
     "tree-sitter-haskell": "^0.23.1",
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/hydra/package.json

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

packages/midi/midi.mjs

@@ -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);
         }
       }
     }

packages/midi/package.json

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

packages/mini/package.json

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

packages/mondo/mondo.mjs

@@ -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;
       }),

packages/mondo/package.json

@@ -33,5 +33,8 @@
   "devDependencies": {
     "vite": "^6.0.11",
     "vitest": "^3.0.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/mondo/test/mondo.test.mjs

@@ -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))'));

packages/mondough/mondough.mjs

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

packages/mondough/package.json

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

packages/motion/package.json

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

packages/mqtt/package.json

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

packages/osc/osc.mjs

@@ -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));
 }
 
 /**

packages/osc/package.json

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

packages/osc/server.js

@@ -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');
+  });
+});

packages/reference/package.json

@@ -33,5 +33,8 @@
   "homepage": "https://codeberg.org/uzu/strudel#readme",
   "devDependencies": {
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/repl/package.json

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

packages/sampler/package.json

@@ -15,5 +15,8 @@
   "type": "module",
   "dependencies": {
     "cowsay": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/sampler/sample-server.mjs

@@ -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();

packages/serial/package.json

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

packages/soundfonts/package.json

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

packages/superdough/README.md

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

packages/superdough/helpers.mjs

@@ -154,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;
@@ -170,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;
 }
 
@@ -241,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'];
@@ -276,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) {
@@ -324,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;
@@ -378,6 +434,11 @@ export function applyFM(param, value, begin) {
       modulator.connect(envGain);
       envGain.connect(param);
     }
+    fmmod.osc.onended = () => {
+      envGain.disconnect();
+      modulator.disconnect();
+      fmmod.osc.disconnect();
+    };
   }
   return { stop };
 }
@@ -479,7 +540,7 @@ export const getDistortion = (distort, postgain, algorithm) => {
 };
 
 export const getFrequencyFromValue = (value, defaultNote = 36) => {
-  let { note, freq } = value;
+  let { note, freq, octave = 0 } = value;
   note = note || defaultNote;
   if (typeof note === 'string') {
     note = noteToMidi(note); // e.g. c3 => 48
@@ -488,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);
 };
 

packages/superdough/noise.mjs

@@ -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),
   };
 }

packages/superdough/package.json

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

packages/superdough/reverbGen.mjs

@@ -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();
 

packages/superdough/sampler.mjs

@@ -1,4 +1,4 @@
-import { getCommonSampleInfoFromBank } from './util.mjs';
+import { getBaseURL, getCommonSampleInfo } from './util.mjs';
 import { registerSound, registerWaveTable } from './index.mjs';
 import { getAudioContext } from './audioContext.mjs';
 import { getADSRValues, getParamADSR, getPitchEnvelope, getVibratoOscillator } from './helpers.mjs';
@@ -23,34 +23,35 @@ function humanFileSize(bytes, si) {
   return bytes.toFixed(1) + ' ' + units[u];
 }
 
+export function getSampleInfo(hapValue, bank) {
+  const { speed = 1.0 } = hapValue;
+  const { transpose, url, index, midi, label } = getCommonSampleInfo(hapValue, bank);
+  let playbackRate = Math.abs(speed) * Math.pow(2, transpose / 12);
+  return { transpose, url, index, midi, label, playbackRate };
+}
 
-export const getSampleBuffer = async (label, sampleUrl, resolveUrl) => {
+// takes hapValue and returns buffer + playbackRate.
+export const getSampleBuffer = async (hapValue, bank, resolveUrl) => {
+  let { url: sampleUrl, label, playbackRate } = getSampleInfo(hapValue, bank);
   if (resolveUrl) {
     sampleUrl = await resolveUrl(sampleUrl);
   }
   const ac = getAudioContext();
   const buffer = await loadBuffer(sampleUrl, ac, label);
-  return buffer
-};
 
-function getBufferPlaybackRate(hapValue, buffer, transpose) {
-  const { speed = 1.0 } = hapValue;
-  let playbackRate = Math.abs(speed) * Math.pow(2, transpose / 12);
   if (hapValue.unit === 'c') {
     playbackRate = playbackRate * buffer.duration;
   }
-  return playbackRate;
-}
-
-
+  return { buffer, playbackRate };
+};
 
 // creates playback ready AudioBufferSourceNode from hapValue
-export function getSampleBufferSource(hapValue, buffer,transpose) {
+export const getSampleBufferSource = async (hapValue, bank, resolveUrl) => {
+  let { buffer, playbackRate } = await getSampleBuffer(hapValue, bank, resolveUrl);
   if (hapValue.speed < 0) {
     // should this be cached?
     buffer = reverseBuffer(buffer);
   }
-  const playbackRate = getBufferPlaybackRate(hapValue, buffer, transpose)
   const ac = getAudioContext();
   const bufferSource = ac.createBufferSource();
   bufferSource.buffer = buffer;
@@ -128,9 +129,7 @@ function githubPath(base, subpath = '') {
   let repo = components.length >= 2 ? components[1] : 'samples';
   let branch = components.length >= 3 ? components[2] : 'main';
   let other = components.slice(3);
-  if (subpath) {
-    other.push(subpath);
-  }
+  other.push(subpath ? subpath : '');
   other = other.join('/');
 
   return `https://raw.githubusercontent.com/${user}/${repo}/${branch}/${other}`;
@@ -212,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;
@@ -263,7 +262,7 @@ export const samples = async (sampleMap, baseUrl = sampleMap._base || '', option
 
 const cutGroups = [];
 
-export async function onTriggerSample(t, value, onended, bufferSrc) {
+export async function onTriggerSample(t, value, onended, bank, resolveUrl) {
   let {
     s,
     nudge = 0, // TODO: is this in seconds?
@@ -285,7 +284,7 @@ export async function onTriggerSample(t, value, onended, bufferSrc) {
   // destructure adsr here, because the default should be different for synths and samples
   let [attack, decay, sustain, release] = getADSRValues([value.attack, value.decay, value.sustain, value.release]);
 
-  const { bufferSource, sliceDuration, offset } = bufferSrc
+  const { bufferSource, sliceDuration, offset } = await getSampleBufferSource(value, bank, resolveUrl);
 
   // asny stuff above took too long?
   if (ac.currentTime > t) {
@@ -347,21 +346,14 @@ export async function onTriggerSample(t, value, onended, bufferSrc) {
   return handle;
 }
 
-async function getBufferSrcFromBank(hapValue, bank, resolveUrl = undefined) {
-  const { transpose, url, label } = getCommonSampleInfoFromBank(hapValue, bank)
-  let buffer = await getSampleBuffer(label,url, resolveUrl);
-  return getSampleBufferSource(hapValue, buffer, transpose)
-}
-
 function registerSample(key, bank, params) {
-  registerSound(key, async (t, hapValue, onended) => onTriggerSample(t, hapValue, onended, await getBufferSrcFromBank(hapValue, bank, undefined)), {
+  registerSound(key, (t, hapValue, onended) => onTriggerSample(t, hapValue, onended, bank), {
     type: 'sample',
     samples: bank,
     ...params,
   });
 }
 
-
 export function registerSampleSource(key, bank, params) {
   const isWavetable = key.startsWith('wt_');
   if (isWavetable) {

packages/superdough/superdough.mjs

@@ -7,7 +7,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import './feedbackdelay.mjs';
 import './reverb.mjs';
 import './vowel.mjs';
-import { nanFallback, _mod, cycleToSeconds } from './util.mjs';
+import { nanFallback, _mod, cycleToSeconds, pickAndRename } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
 import { createFilter, gainNode, getCompressor, getDistortion, getLfo, getWorklet, effectSend } from './helpers.mjs';
 import { map } from 'nanostores';
@@ -146,11 +146,6 @@ 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,
@@ -415,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,
@@ -511,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);
@@ -543,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?`);
@@ -565,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());
@@ -630,6 +633,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
   // effects
   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(getDistortion(distort, distortvol, distorttype));
 
   if (tremolosync != null) {
@@ -664,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);
   }
 
@@ -691,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) {
@@ -707,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) {

packages/superdough/superdoughoutput.mjs

@@ -78,14 +78,14 @@ 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) {
+  duck(t, onsettime = 0, attacktime = 0.16, depth = 0.8) {
     const onset = onsettime;
     const attack = Math.max(attacktime, 0.002);
     const gainParam = this.output.gain;
@@ -178,7 +178,7 @@ export class SuperdoughAudioController {
     this.output.reset();
   }
 
-  duck(targetOrbits, t, onsettime = 0, attacktime = 0.1, depth = 1) {
+  duck(targetOrbits, t, onsettime = 0, attacktime = 0.16, depth = 0.8) {
     const targetArr = [targetOrbits].flat();
     const onsetArr = [onsettime].flat();
     const attackArr = [attacktime].flat();

packages/superdough/synth.mjs

@@ -15,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'],
@@ -47,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);
@@ -414,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();
 
@@ -424,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);
@@ -446,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);
 
@@ -473,6 +492,13 @@ export function getOscillator(s, t, value) {
     noiseMix = getNoiseMix(o, noise, t);
   }
 
+  o.onended = () => {
+    o.disconnect();
+    noiseMix?.node.disconnect();
+    onended();
+  };
+  o.start(t);
+
   return {
     node: noiseMix?.node || o,
     stop: (time) => {

packages/superdough/util.mjs

@@ -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) => {
@@ -80,13 +84,12 @@ export function secondsToCycle(t, cps) {
 // deduces relevant info for sample loading from hap.value and sample definition
 // it encapsulates the core sampler logic into a pure and synchronous function
 // hapValue: Hap.value, bank: sample bank definition for sound "s" (values in strudel.json format)
-export function getCommonSampleInfoFromBank(hapValue, bank) {
+export function getCommonSampleInfo(hapValue, bank) {
   const { s, n = 0 } = hapValue;
   let midi = valueToMidi(hapValue, 36);
+  let transpose = midi - 36; // C3 is middle C;
   let url;
   let index = 0;
-  let {transpose, label} = getCommonSampleInfo(hapValue)
-
   if (Array.isArray(bank)) {
     index = getSoundIndex(n, bank.length);
     url = bank[index];
@@ -103,20 +106,21 @@ export function getCommonSampleInfoFromBank(hapValue, bank) {
     index = getSoundIndex(n, bank[closest].length);
     url = bank[closest][index];
   }
-  label = `${s}:${index}`;
-  return { transpose, url, label };
+  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 function getCommonSampleInfo(hapValue) {
-  const { s, n = 0 } = hapValue;
-  let midi = valueToMidi(hapValue, 36);
-  let transpose = midi - 36; // C3 is middle C;
-  const label = `${s}:${n}`;
-  return { transpose, label };
-}
-
-
-
-
-
+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('/');
+  }
+};

packages/superdough/wavetable.mjs

@@ -1,5 +1,5 @@
 import { getAudioContext, registerSound } from './index.mjs';
-import { getCommonSampleInfoFromBank } from './util.mjs';
+import { getBaseURL, getCommonSampleInfo } from './util.mjs';
 import {
   applyFM,
   applyParameterModulators,
@@ -190,6 +190,7 @@ export const tables = async (url, frameLen, json, options = {}) => {
   if (url.startsWith('local:')) {
     url = `http://localhost:5432`;
   }
+  const base = getBaseURL(url);
   if (typeof fetch !== 'function') {
     // not a browser
     return;
@@ -200,7 +201,7 @@ export const tables = async (url, frameLen, json, options = {}) => {
   }
   return fetch(url)
     .then((res) => res.json())
-    .then((json) => _processTables(json, url, frameLen, options))
+    .then((json) => _processTables(json, base, frameLen, options))
     .catch((error) => {
       console.error(error);
       throw new Error(`error loading "${url}"`);
@@ -216,7 +217,7 @@ export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
     warpmode = Warpmode[warpmode.toUpperCase()] ?? Warpmode.NONE;
   }
   const frequency = getFrequencyFromValue(value);
-  const { url, label } = getCommonSampleInfoFromBank(value, tables);
+  const { url, label } = getCommonSampleInfo(value, tables);
   const payload = await getPayload(url, label, frameLen);
   let holdEnd = t + duration;
   if (clip !== undefined) {

packages/superdough/worklets.mjs

@@ -6,51 +6,57 @@ 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;
@@ -66,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;
@@ -100,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 {
@@ -165,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;
@@ -293,8 +293,8 @@ class TwoPoleFilter {
     // Out of bound values can produce NaNs
     resonance = clamp(resonance, 0, 1);
     cutoff = clamp(cutoff, 0, sampleRate / 2 - 1);
-    const c = clamp(2 * Math.sin(cutoff * (_PI / 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
@@ -353,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() {
@@ -395,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);
@@ -508,6 +503,7 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
         name: 'voices',
         defaultValue: 5,
         min: 1,
+        automationRate: 'k-rate',
       },
     ];
   }
@@ -519,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;
@@ -564,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 {
@@ -587,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();
@@ -604,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;
@@ -660,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;
@@ -674,7 +659,6 @@ class PhaseVocoderProcessor extends OLAProcessor {
         i++;
         continue;
       }
-
       this.peakIndexes[this.nbPeaks] = i;
       this.nbPeaks++;
       i += 2;
@@ -685,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;
       }
@@ -745,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
@@ -806,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
@@ -822,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
@@ -852,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));
   },
 };
@@ -877,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);
@@ -910,7 +883,7 @@ class ByteBeatProcessor extends AudioWorkletProcessor {
 
       this.func = getByteBeatFunc(codeText);
     };
-    this.initialOffset = null;
+    this.initialOffset = 0;
     this.t = null;
     this.func = null;
   }
@@ -957,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
@@ -977,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,
@@ -1056,7 +1126,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
       { name: 'position', defaultValue: 0, min: 0, max: 1 },
       { name: 'warp', defaultValue: 0, min: 0, max: 1 },
       { name: 'warpMode', defaultValue: 0 },
-      { name: 'voices', defaultValue: 1, min: 1 },
+      { 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 },
     ];
@@ -1067,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 || {};
@@ -1104,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) {
@@ -1130,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: {
@@ -1139,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);
@@ -1150,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;
@@ -1166,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);
@@ -1175,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);
@@ -1209,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);
       }
@@ -1222,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: {
@@ -1269,16 +1332,16 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
       if (outR !== outL) outR.set(outL);
       return true;
     }
+    const voices = parameters.voices[0]; // k-rate
     for (let i = 0; i < outL.length; i++) {
       const detune = pv(parameters.detune, i);
       const freqspread = pv(parameters.freqspread, i);
       const tablePos = clamp(pv(parameters.position, i), 0, 1);
       const idx = tablePos * (this.numFrames - 1);
       const fIdx = idx | 0;
-      const 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 panspread = voices > 1 ? clamp(pv(parameters.panspread, i), 0, 1) : 0;
       const gain1 = Math.sqrt(0.5 - 0.5 * panspread);
@@ -1286,6 +1349,7 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
       let f = pv(parameters.frequency, i);
       f = applySemitoneDetuneToFrequency(f, detune / 100); // overall detune
       const normalizer = 1 / Math.sqrt(voices);
+      const detuner = getDetuner(voices, freqspread);
       for (let n = 0; n < voices; n++) {
         const isOdd = (n & 1) == 1;
         let gainL = gain1;
@@ -1295,8 +1359,8 @@ class WavetableOscillatorProcessor extends AudioWorkletProcessor {
           gainL = gain2;
           gainR = gain1;
         }
-        const fVoice = applySemitoneDetuneToFrequency(f, getUnisonDetune(voices, freqspread, 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];
 
@@ -1305,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;

packages/supradough/dough.mjs

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

packages/supradough/package.json

@@ -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"
+  }
 }

packages/supradough/vite.config.js

@@ -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',
+  },
+});

packages/tidal/package.json

@@ -25,5 +25,8 @@
   },
   "devDependencies": {
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/tonal/index.mjs

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

packages/tonal/package.json

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

packages/tonal/test/tonal.test.mjs

@@ -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'];

packages/tonal/tonal.mjs

@@ -5,9 +5,8 @@ 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 { register, _mod, logger, isNote, noteToMidi, removeUndefineds, getAccidentalsOffset } 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 +184,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 +223,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 +253,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 +263,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) {
+            logger(`[tonal] ${err.message}`, 'error');
+            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

packages/transpiler/package.json

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

packages/vite-plugin-bundle-audioworklet/package.json

@@ -12,5 +12,8 @@
   "type": "module",
   "devDependencies": {
     "vite": "^6.0.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

packages/web/README.md

@@ -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()
 );
 ```

packages/web/package.json

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

packages/webaudio/package.json

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

packages/xen/package.json

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

packages/xen/tunejs.js

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

pnpm-lock.yaml

@@ -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: {}

test/tunes.test.mjs

@@ -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();
     });
   });
 });

tools/dbpatch/package.json

@@ -1,5 +1,8 @@
 {
   "dependencies": {
     "csv": "^6.3.11"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

website/package.json

@@ -75,5 +75,8 @@
     "sharp": "^0.33.5",
     "workbox-window": "^7.3.0",
     "vite-plugin-bundle-audioworklet": "workspace:*"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

website/src/pages/learn/samples.mdx

@@ -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")`}
 />
 

website/src/pages/learn/synths.mdx

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

website/src/pages/technical-manual/project-start.mdx

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

website/src/pages/technical-manual/repl.mdx

@@ -117,6 +117,10 @@ Here's an example AST for `c3 [e3 g3]`
 
 which translates to `seq(c3, seq(e3, g3))`
 
+## Vim Keybindings
+
+See the separate page on Vim shortcuts for a quick reference: [/technical-manual/vim](/technical-manual/vim)
+
 ## Scheduling Events
 
 After an instance of `Pattern` is obtained from the user code,

website/src/pages/technical-manual/vim.mdx

@@ -0,0 +1,37 @@
+---
+title: Vim Shortcuts
+layout: ../../layouts/MainLayout.astro
+---
+
+# Vim Shortcuts in the REPL
+
+When the REPL editor (CodeMirror) is configured to use Vim keybindings, the following commands are available:
+
+- :w — Evaluate the current code
+
+  - Triggers the same evaluation as Ctrl+Enter / Alt+Enter
+  - You'll see messages in the Console panel such as:
+    - [vim] :w — evaluating code
+    - [repl] evaluate via event
+    - [eval] code updated
+
+- :q — Stop/pause playback
+
+  - Triggers the same stop action as Alt+.
+  - Useful to quickly stop scheduling without leaving Vim mode
+
+- gc — Toggle line comments for the current selection(s)
+
+  - Works in normal and visual mode
+  - If there's a selection, all selected lines are toggled
+
+Notes
+
+- Behavior respects the current language mode in the editor for comment syntax.
+- If multiple REPL editors are open, commands target the active editor. The implementation dispatches custom events handled by the editor.
+- If you don't see the Console panel, open the right panel in the REPL UI.
+
+Troubleshooting
+
+- If :w logs but evaluation doesn't apply, ensure Vim keybindings are active and try again. You can also use Ctrl+Enter as a fallback.
+- For :q / gc, ensure focus is inside the editor. If an error occurs, reload the page to reset editor state and try again.

website/src/repl/components/button/action-button.jsx

@@ -8,3 +8,34 @@ export function ActionButton({ children, label, labelIsHidden, className, ...but
     </button>
   );
 }
+
+export function SpecialActionButton(props) {
+  const { className, ...buttonProps } = props;
+
+  return (
+    <ActionButton
+      {...buttonProps}
+      className={cx('bg-background p-2 max-w-[300px] rounded-md hover:opacity-50', className)}
+    />
+  );
+}
+
+export function ActionInput({ label, className, ...props }) {
+  return (
+    <label className={cx('inline-flex items-center cursor-pointer', className)}>
+      <input {...props} className="sr-only peer" />
+
+      <span className="inline-flex items-center peer-hover:opacity-50">{label}</span>
+    </label>
+  );
+}
+
+export function SpecialActionInput({ className, ...props }) {
+  return (
+    <ActionInput
+      {...props}
+      className={className}
+      label={<span className="bg-background p-2 max-w-[300px] rounded-md">{props.label}</span>}
+    />
+  );
+}

website/src/repl/components/panel/ImportPrebakeScriptButton.jsx

@@ -0,0 +1,29 @@
+import { errorLogger } from '@strudel/core';
+import { useSettings, storePrebakeScript } from '../../../settings.mjs';
+import { SpecialActionInput } from '../button/action-button';
+
+async function importScript(script) {
+  const reader = new FileReader();
+  reader.readAsText(script);
+
+  reader.onload = () => {
+    const text = reader.result;
+    storePrebakeScript(text);
+  };
+
+  reader.onerror = () => {
+    errorLogger(new Error('failed to import prebake script'), 'importScript');
+  };
+}
+export function ImportPrebakeScriptButton() {
+  const settings = useSettings();
+
+  return (
+    <SpecialActionInput
+      type="file"
+      label="import prebake script"
+      accept=".strudel"
+      onChange={(e) => importScript(e.target.files[0])}
+    />
+  );
+}

website/src/repl/components/panel/PatternsTab.jsx

@@ -79,13 +79,11 @@ const updateCodeWindow = (context, patternData, reset = false) => {
   context.handleUpdate(patternData, reset);
 };
 
-const autoResetPatternOnChange = !isUdels();
-
 function UserPatterns({ context }) {
   const activePattern = useActivePattern();
   const viewingPatternStore = useViewingPatternData();
   const viewingPatternData = parseJSON(viewingPatternStore);
-  const { userPatterns, patternFilter } = useSettings();
+  const { userPatterns, patternFilter, patternAutoStart } = useSettings();
   const viewingPatternID = viewingPatternData?.id;
   return (
     <div className="flex flex-col gap-2 flex-grow overflow-hidden h-full pb-2 ">
@@ -135,13 +133,13 @@ function UserPatterns({ context }) {
       <div className="overflow-auto h-full bg-background p-2 rounded-md">
         {/* {patternFilter === patternFilterName.user && ( */}
         <PatternButtons
-          onClick={(id) =>
-            updateCodeWindow(
-              context,
-              { ...userPatterns[id], collection: userPattern.collection },
-              autoResetPatternOnChange,
-            )
-          }
+          onClick={(id) => {
+            updateCodeWindow(context, { ...userPatterns[id], collection: userPattern.collection }, patternAutoStart);
+
+            if (context.started && activePattern === id) {
+              context.handleEvaluate();
+            }
+          }}
           patterns={userPatterns}
           started={context.started}
           activePattern={activePattern}
@@ -188,17 +186,14 @@ function FeaturedPatterns({ context }) {
   const examplePatterns = useExamplePatterns();
   const collections = examplePatterns.collections;
   const patterns = collections.get(patternFilterName.featured);
+  const { patternAutoStart } = useSettings();
   return (
     <PatternPageWithPagination
       patterns={patterns}
       context={context}
       initialPage={featuredPageNum}
       patternOnClick={(id) => {
-        updateCodeWindow(
-          context,
-          { ...patterns[id], collection: patternFilterName.featured },
-          autoResetPatternOnChange,
-        );
+        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.featured }, patternAutoStart);
       }}
       paginationOnChange={async (pageNum) => {
         await loadAndSetFeaturedPatterns(pageNum - 1);
@@ -213,13 +208,14 @@ function LatestPatterns({ context }) {
   const examplePatterns = useExamplePatterns();
   const collections = examplePatterns.collections;
   const patterns = collections.get(patternFilterName.public);
+  const { patternAutoStart } = useSettings();
   return (
     <PatternPageWithPagination
       patterns={patterns}
       context={context}
       initialPage={latestPageNum}
       patternOnClick={(id) => {
-        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.public }, autoResetPatternOnChange);
+        updateCodeWindow(context, { ...patterns[id], collection: patternFilterName.public }, patternAutoStart);
       }}
       paginationOnChange={async (pageNum) => {
         await loadAndSetPublicPatterns(pageNum - 1);

website/src/repl/components/panel/SettingsTab.jsx

@@ -7,6 +7,8 @@ import { AudioDeviceSelector } from './AudioDeviceSelector.jsx';
 import { AudioEngineTargetSelector } from './AudioEngineTargetSelector.jsx';
 import { confirmDialog } from '../../util.mjs';
 import { DEFAULT_MAX_POLYPHONY, setMaxPolyphony, setMultiChannelOrbits } from '@strudel/webaudio';
+import { ActionButton, SpecialActionButton } from '../button/action-button.jsx';
+import { ImportPrebakeScriptButton } from './ImportPrebakeScriptButton.jsx';
 
 function Checkbox({ label, value, onChange, disabled = false }) {
   return (
@@ -112,6 +114,8 @@ export function SettingsTab({ started }) {
     multiChannelOrbits,
     isTabIndentationEnabled,
     isMultiCursorEnabled,
+    patternAutoStart,
+    includePrebakeScriptInShare,
   } = useSettings();
   const shouldAlwaysSync = isUdels();
   const canChangeAudioDevice = AudioContext.prototype.setSinkId != null;
@@ -203,6 +207,15 @@ export function SettingsTab({ started }) {
           />
         </FormItem>
       </div>
+      <FormItem label="Prebake">
+        <ImportPrebakeScriptButton />
+        <Checkbox
+          label="Include prebake script in share"
+          onChange={(cbEvent) => settingsMap.setKey('includePrebakeScriptInShare', cbEvent.target.checked)}
+          value={includePrebakeScriptInShare}
+        />
+      </FormItem>
+
       <FormItem label="Keybindings">
         <ButtonGroup
           value={keybindings}
@@ -304,11 +317,15 @@ export function SettingsTab({ started }) {
           onChange={(cbEvent) => settingsMap.setKey('isCSSAnimationDisabled', cbEvent.target.checked)}
           value={isCSSAnimationDisabled}
         />
+        <Checkbox
+          label="Auto-start pattern on pattern change"
+          onChange={(cbEvent) => settingsMap.setKey('patternAutoStart', cbEvent.target.checked)}
+          value={patternAutoStart}
+        />
       </FormItem>
       <FormItem label="Zen Mode">Try clicking the logo in the top left!</FormItem>
       <FormItem label="Reset Settings">
-        <button
-          className="bg-background p-2 max-w-[300px] rounded-md hover:opacity-50"
+        <SpecialActionButton
           onClick={() => {
             confirmDialog('Sure?').then((r) => {
               if (r) {
@@ -319,7 +336,7 @@ export function SettingsTab({ started }) {
           }}
         >
           restore default settings
-        </button>
+        </SpecialActionButton>
       </FormItem>
     </div>
   );

website/src/repl/components/panel/SoundsTab.jsx

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

website/src/repl/idbutils.mjs

@@ -1,8 +1,6 @@
-import { getSampleBufferSource, onTriggerSample, registerSampleSource } from '@strudel/webaudio';
+import { registerSampleSource } from '@strudel/webaudio';
 import { isAudioFile } from './files.mjs';
-import { getSoundIndex, logger } from '@strudel/core';
-import { registerSound } from '@strudel/webaudio';
-import { getCommonSampleInfo } from '../../../packages/superdough/util.mjs';
+import { logger } from '@strudel/core';
 
 //utilites for writing and reading to the indexdb
 
@@ -27,15 +25,6 @@ function clearAllIDB() {
 
 export function clearIDB(dbName) {
   return window.indexedDB.deleteDatabase(dbName);
-}
-
-
-function registerSampleFromIdb(key, bank, params) {
-
-  
-
-
-
 }
 
 // queries the DB, and registers the sounds so they can be played
@@ -63,76 +52,31 @@ export function registerSamplesFromDB(config = userSamplesDBConfig, onComplete =
             if (!isAudioFile(title)) {
               return;
             }
-
             const splitRelativePath = soundFile.id.split('/');
             let parentDirectory =
               //fallback to file name before period and seperator if no parent directory
               splitRelativePath[splitRelativePath.length - 2] ?? soundFile.id.split(/\W+/)[0] ?? 'user';
-            
-              // const blob = soundFile.blob;       
-            
+            const blob = soundFile.blob;
+
+            return blobToDataUrl(blob).then((soundPath) => {
               const titlePathMap = sounds.get(parentDirectory) ?? new Map();
 
-              titlePathMap.set(title, soundFile.id);
+              titlePathMap.set(title, soundPath);
+
               sounds.set(parentDirectory, titlePathMap);
-
-
-
-              
-            // return blobToDataUrl(blob).then((soundPath) => {
-            //   const titlePathMap = sounds.get(parentDirectory) ?? new Map();
-
-            //   titlePathMap.set(title, soundPath);
-
-            //   sounds.set(parentDirectory, titlePathMap);
-            //   return;
-            // });
+              return;
+            });
           }),
       )
         .then(() => {
           sounds.forEach((titlePathMap, key) => {
-            const bank = Array.from(titlePathMap.keys())
+            const value = Array.from(titlePathMap.keys())
               .sort((a, b) => {
                 return a.localeCompare(b);
               })
               .map((title) => titlePathMap.get(title));
 
-              
-
-
-              registerSound(key, async (t, hapValue, onended) => {
-                const { s, n = 0 } = hapValue;
-                const index = getSoundIndex(n, bank.length);
-                 let {transpose, label} = getCommonSampleInfo(hapValue)
-                const  storeKey = bank[index];
-
-                openDB(config, (objectStore) => { 
-                  const getRequest = objectStore.get(storeKey);
-                  getRequest.onsuccess = async (event) => { 
-                    const result = event.target.result;
-                    let buffer = result?.blob.arrayBuffer ? await result.blob.arrayBuffer() : null;
-                    console.info(buffer)
-                    if (buffer) {
-                      const bufferSource = getSampleBufferSource(hapValue,buffer,transpose)
-                      onTriggerSample(t, hapValue, onended, bufferSource)
-                    } else {
-                      logger(`Could not load sample for ${storeKey}`, 'error');
-                    }
-                  };
-                })
-               
-                // const buffer =   objectStore.getKey(key)
-                // const bufferSource = getSampleBufferSource(hapValue,buffer,transpose)
-                 
-                //  onTriggerSample(t, hapValue, onended, await getBufferSrcFromBank(hapValue, bank, undefined))
-              
-               }, {
-                 type: 'sample',
-                 samples: bank,
-                 
-               });
-
-            // registerSampleSource(key, value, { prebake: false });
+            registerSampleSource(key, value, { prebake: false });
           });
 
           logger('imported sounds registered!', 'success');
@@ -148,11 +92,7 @@ export function registerSamplesFromDB(config = userSamplesDBConfig, onComplete =
 
 async function blobToDataUrl(blob) {
   return new Promise((resolve) => {
-    var reader = new FileReader();
-    reader.onload = function (event) {
-      resolve(event.target.result);
-    };
-    reader.readAsDataURL(blob);
+    resolve(URL.createObjectURL(blob));
   });
 }
 

website/src/repl/prebake.mjs

@@ -3,9 +3,12 @@ import { aliasBank, registerSynthSounds, registerZZFXSounds, samples } from '@st
 import { registerSamplesFromDB } from './idbutils.mjs';
 import './piano.mjs';
 import './files.mjs';
+import { settingsMap } from '@src/settings.mjs';
+import { evaluate } from '@strudel/transpiler';
 
 const { BASE_URL } = import.meta.env;
 const baseNoTrailing = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL;
+const baseCDN = 'https://strudel.b-cdn.net';
 
 export async function prebake() {
   // https://archive.org/details/SalamanderGrandPianoV3
@@ -19,23 +22,23 @@ export async function prebake() {
     // => getting "window is not defined", as soon as "@strudel/soundfonts" is imported statically
     // seems to be a problem with soundfont2
     import('@strudel/soundfonts').then(({ registerSoundfonts }) => registerSoundfonts()),
-    samples(`${baseNoTrailing}/piano.json`, undefined, { prebake: true }),
+    samples(`${baseCDN}/piano.json`, `${baseCDN}/piano/`, { prebake: true }),
     // https://github.com/sgossner/VCSL/
     // https://api.github.com/repositories/126427031/contents/
     // LICENSE: CC0 general-purpose
-    samples(`${baseNoTrailing}/vcsl.json`, 'github:sgossner/VCSL/master/', { prebake: true }),
-    samples(`${baseNoTrailing}/tidal-drum-machines.json`, 'github:ritchse/tidal-drum-machines/main/machines/', {
+    samples(`${baseCDN}/vcsl.json`, `${baseCDN}/VCSL/`, { prebake: true }),
+    samples(`${baseCDN}/tidal-drum-machines.json`, `${baseCDN}/tidal-drum-machines/machines/`, {
       prebake: true,
       tag: 'drum-machines',
     }),
-    samples(`${baseNoTrailing}/uzu-drumkit.json`, undefined, {
+    samples(`${baseCDN}/uzu-drumkit.json`, `${baseCDN}/uzu-drumkit/`, {
       prebake: true,
       tag: 'drum-machines',
     }),
-    samples(`${baseNoTrailing}/uzu-wavetables.json`, undefined, {
+    samples(`${baseCDN}/uzu-wavetables.json`, `${baseCDN}/uzu-wavetables/`, {
       prebake: true,
     }),
-    samples(`${baseNoTrailing}/mridangam.json`, undefined, { prebake: true, tag: 'drum-machines' }),
+    samples(`${baseCDN}/mridangam.json`, `${baseCDN}/mrid/`, { prebake: true, tag: 'drum-machines' }),
     samples(
       {
         casio: ['casio/high.wav', 'casio/low.wav', 'casio/noise.wav'],
@@ -145,14 +148,14 @@ export async function prebake() {
           'num/20.wav',
         ],
       },
-      'github:tidalcycles/dirt-samples',
+      `${baseCDN}/Dirt-Samples/`,
       {
         prebake: true,
       },
     ),
   ]);
 
-  aliasBank(`${baseNoTrailing}/tidal-drum-machines-alias.json`);
+  aliasBank(`${baseCDN}/tidal-drum-machines-alias.json`);
 }
 
 const maxPan = noteToMidi('C8');

website/src/repl/useReplContext.jsx

@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import { code2hash, getPerformanceTimeSeconds, logger, silence } from '@strudel/core';
 import { getDrawContext } from '@strudel/draw';
-import { transpiler } from '@strudel/transpiler';
+import { evaluate, transpiler } from '@strudel/transpiler';
 import {
   getAudioContextCurrentTime,
   webaudioOutput,
@@ -63,11 +63,10 @@ async function getModule(name) {
 const initialCode = `// LOADING`;
 
 export function useReplContext() {
-  const { isSyncEnabled, audioEngineTarget } = useSettings();
+  const { isSyncEnabled, audioEngineTarget, prebakeScript, includePrebakeScriptInShare } = useSettings();
   const shouldUseWebaudio = audioEngineTarget !== audioEngineTargets.osc;
   const defaultOutput = shouldUseWebaudio ? webaudioOutput : superdirtOutput;
   const getTime = shouldUseWebaudio ? getAudioContextCurrentTime : getPerformanceTimeSeconds;
-
   const init = useCallback(() => {
     const drawTime = [-2, 2];
     const drawContext = getDrawContext();
@@ -84,7 +83,12 @@ export function useReplContext() {
       pattern: silence,
       drawTime,
       drawContext,
-      prebake: async () => Promise.all([modulesLoading, presets]),
+      prebake: async () =>
+        Promise.all([modulesLoading, presets]).then(() => {
+          if (prebakeScript?.length) {
+            return evaluate(prebakeScript ?? '');
+          }
+        }),
       onUpdateState: (state) => {
         setReplState({ ...state });
       },
@@ -214,7 +218,13 @@ export function useReplContext() {
     editorRef.current.repl.evaluate(code);
   };
 
-  const handleShare = async () => shareCode(replState.code);
+  const handleShare = async () => {
+    let code = replState.code;
+    if (includePrebakeScriptInShare) {
+      code = prebakeScript + '\n' + code;
+    }
+    shareCode(code);
+  };
   const context = {
     started,
     pending,

website/src/repl/util.mjs

@@ -1,11 +1,10 @@
-import { evalScope, hash2code, logger } from '@strudel/core';
+import { code2hash, evalScope, hash2code, logger } from '@strudel/core';
 import { settingPatterns } from '../settings.mjs';
 import { setVersionDefaults } from '@strudel/webaudio';
 import { getMetadata } from '../metadata_parser';
 import { isTauri } from '../tauri.mjs';
 import './Repl.css';
 import { createClient } from '@supabase/supabase-js';
-import { nanoid } from 'nanoid';
 import { writeText } from '@tauri-apps/plugin-clipboard-manager';
 import { $featuredPatterns /* , loadDBPatterns */ } from '@src/user_pattern_utils.mjs';
 
@@ -109,9 +108,8 @@ export function confirmDialog(msg) {
   });
 }
 
-let lastShared;
-
 //RIP due to SPAM
+// let lastShared;
 // export async function shareCode(codeToShare) {
 //   // const codeToShare = activeCode || code;
 //   if (lastShared === codeToShare) {
@@ -146,9 +144,10 @@ let lastShared;
 //   });
 // }
 
-export async function shareCode() {
+export async function shareCode(codeToShare) {
   try {
-    const shareUrl = window.location.href;
+    const hash = '#' + code2hash(codeToShare);
+    const shareUrl = window.location.origin + window.location.pathname + hash;
     if (isTauri()) {
       await writeText(shareUrl);
     } else {