Merge branch 'cycler' into textbox

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

.forgejo/workflows/test.yml

@@ -1,6 +1,6 @@
 name: Strudel tests
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
@@ -19,7 +19,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
-          cache: 'pnpm'
+          cache: "pnpm"
       - run: pnpm install
       - run: pnpm run format-check
       - run: pnpm run lint

Dockerfile

@@ -0,0 +1,21 @@
+FROM node:24
+
+WORKDIR /app
+
+RUN npm install pnpm --global
+
+COPY pnpm-workspace.yaml ./
+COPY package.json pnpm-lock.yaml ./
+COPY packages/ ./packages/
+COPY examples/ ./examples/
+RUN mkdir -p website/public
+COPY website/package.json ./website/
+
+RUN pnpm install
+
+
+COPY . .
+
+EXPOSE 4321
+
+CMD ["pnpm", "dev"]

README.md

@@ -3,8 +3,6 @@
 Live coding patterns on the web
 https://strudel.cc/
 
-Development is moving to https://codeberg.org/uzu/strudel
-
 - Try it here: <https://strudel.cc>
 - Docs: <https://strudel.cc/learn>
 - Technical Blog Post: <https://loophole-letters.vercel.app/strudel>
@@ -47,3 +45,5 @@ There is a #strudel channel on the TidalCycles discord: <https://discord.com/inv
 You can also ask questions and find related discussions on the tidal club forum: <https://club.tidalcycles.org/>
 
 The discord and forum is shared with the haskell (tidal) and python (vortex) siblings of this project.
+
+We also have a mastodon account: <a rel="me" href="https://social.toplap.org/@strudel">social.toplap.org/@strudel</a>

eslint.config.mjs

@@ -42,6 +42,7 @@ export default [
       '**/hydra.mjs',
       '**/jsdoc-synonyms.js',
       'packages/hs2js/src/hs2js.mjs',
+      'packages/supradough/dough-export.mjs',
       '**/samples',
     ],
   },
@@ -83,4 +84,14 @@ export default [
       ],
     },
   },
+  {
+    // Properties provided by AudioWorkletGlobalScope
+    files: ['packages/superdough/worklets.mjs'],
+    languageOptions: {
+      globals: {
+        currentTime: 'readonly',
+        sampleRate: 'readonly',
+      },
+    },
+  },
 ];

packages/codemirror/autocomplete.mjs

@@ -1,68 +1,122 @@
 import jsdoc from '../../doc.json';
-// import { javascriptLanguage } from '@codemirror/lang-javascript';
 import { autocompletion } from '@codemirror/autocomplete';
 import { h } from './html';
 
-function plaintext(str) {
+const escapeHtml = (str) => {
   const div = document.createElement('div');
   div.innerText = str;
   return div.innerHTML;
-}
+};
 
-const getDocLabel = (doc) => doc.name || doc.longname;
-const getInnerText = (html) => {
-  var div = document.createElement('div');
+const stripHtml = (html) => {
+  const div = document.createElement('div');
   div.innerHTML = html;
   return div.textContent || div.innerText || '';
 };
 
-export function Autocomplete({ doc, label }) {
-  return h`<div class="prose dark:prose-invert max-h-[400px] overflow-auto p-2">
-<h1 class="pt-0 mt-0">${label || getDocLabel(doc)}</h1>
-${doc.description}
-<ul>
-  ${doc.params?.map(
-    ({ name, type, description }) =>
-      `<li>${name} : ${type.names?.join(' | ')} ${description ? ` - ${getInnerText(description)}` : ''}</li>`,
-  )}
-</ul>
-<div>
-  ${doc.examples?.map((example) => `<div><pre>${plaintext(example)}</pre></div>`)}
-</div>
-</div>`[0];
-  /*
-<pre
-className="cursor-pointer"
-onMouseDown={(e) => {
-  console.log('ola!');
-  navigator.clipboard.writeText(example);
-  e.stopPropagation();
-}}
->
-{example}
-</pre>
-*/
-}
+const getDocLabel = (doc) => doc.name || doc.longname;
 
-const jsdocCompletions = jsdoc.docs
-  .filter(
-    (doc) =>
-      getDocLabel(doc) &&
-      !getDocLabel(doc).startsWith('_') &&
-      !['package'].includes(doc.kind) &&
-      !['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag)),
-  )
-  // https://codemirror.net/docs/ref/#autocomplete.Completion
-  .map((doc) /*: Completion */ => ({
-    label: getDocLabel(doc),
-    // detail: 'xxx', // An optional short piece of information to show (with a different style) after the label.
-    info: () => Autocomplete({ doc }),
-    type: 'function', // https://codemirror.net/docs/ref/#autocomplete.Completion.type
-  }));
+const buildParamsList = (params) =>
+  params?.length
+    ? `
+    <div class="autocomplete-info-params-section">
+      <h4 class="autocomplete-info-section-title">Parameters</h4>
+      <ul class="autocomplete-info-params-list">
+        ${params
+          .map(
+            ({ name, type, description }) => `
+          <li class="autocomplete-info-param-item">
+            <span class="autocomplete-info-param-name">${name}</span>
+            <span class="autocomplete-info-param-type">${type.names?.join(' | ')}</span>
+            ${description ? `<div class="autocomplete-info-param-desc">${stripHtml(description)}</div>` : ''}
+          </li>
+        `,
+          )
+          .join('')}
+      </ul>
+    </div>
+  `
+    : '';
+
+const buildExamples = (examples) =>
+  examples?.length
+    ? `
+    <div class="autocomplete-info-examples-section">
+      <h4 class="autocomplete-info-section-title">Examples</h4>
+      ${examples
+        .map(
+          (example) => `
+        <pre class="autocomplete-info-example-code">${escapeHtml(example)}</pre>
+      `,
+        )
+        .join('')}
+    </div>
+  `
+    : '';
+
+export const Autocomplete = (doc) =>
+  h`
+  <div class="autocomplete-info-container">
+    <div class="autocomplete-info-tooltip">
+      <h3 class="autocomplete-info-function-name">${getDocLabel(doc)}</h3>
+      ${doc.synonyms_text ? `<div class="autocomplete-info-function-synonyms">Synonyms: ${doc.synonyms_text}</div>` : ''}
+      ${doc.description ? `<div class="autocomplete-info-function-description">${doc.description}</div>` : ''}
+      ${buildParamsList(doc.params)}
+      ${buildExamples(doc.examples)}
+    </div>
+  </div>
+`[0];
+
+const isValidDoc = (doc) => {
+  const label = getDocLabel(doc);
+  return label && !label.startsWith('_') && !['package'].includes(doc.kind);
+};
+
+const hasExcludedTags = (doc) =>
+  ['superdirtOnly', 'noAutocomplete'].some((tag) => doc.tags?.find((t) => t.originalTitle === tag));
+
+export const getSynonymDoc = (doc, synonym) => {
+  const synonyms = doc.synonyms || [];
+  const docLabel = getDocLabel(doc);
+  // Swap `doc.name` in for `s` in the list of synonyms
+  const synonymsWithDoc = [docLabel, ...synonyms].filter((x) => x && x !== synonym);
+  return {
+    ...doc,
+    name: synonym,
+    longname: synonym,
+    synonyms: synonymsWithDoc,
+    synonyms_text: synonymsWithDoc.join(', '),
+  };
+};
+
+const jsdocCompletions = (() => {
+  const seen = new Set(); // avoid repetition
+  const completions = [];
+  for (const doc of jsdoc.docs) {
+    if (!isValidDoc(doc) || hasExcludedTags(doc)) continue;
+    const docLabel = getDocLabel(doc);
+    // Remove duplicates
+    const synonyms = doc.synonyms || [];
+    let labels = [docLabel, ...synonyms];
+    for (const label of labels) {
+      // https://codemirror.net/docs/ref/#autocomplete.Completion
+      if (label && !seen.has(label)) {
+        seen.add(label);
+        completions.push({
+          label,
+          info: () => Autocomplete(getSynonymDoc(doc, label)),
+          type: 'function', // https://codemirror.net/docs/ref/#autocomplete.Completion.type
+        });
+      }
+    }
+  }
+  return completions;
+})();
+
+export const strudelAutocomplete = (context) => {
+  const word = context.matchBefore(/\w*/);
+  if (word.from === word.to && !context.explicit) return null;
 
-export const strudelAutocomplete = (context /* : CompletionContext */) => {
-  let word = context.matchBefore(/\w*/);
-  if (word.from == word.to && !context.explicit) return null;
   return {
     from: word.from,
     options: jsdocCompletions,
@@ -74,11 +128,5 @@ export const strudelAutocomplete = (context /* : CompletionContext */) => {
   };
 };
 
-export function isAutoCompletionEnabled(on) {
-  return on
-    ? [
-        autocompletion({ override: [strudelAutocomplete] }),
-        //javascriptLanguage.data.of({ autocomplete: strudelAutocomplete }),
-      ]
-    : []; // autocompletion({ override: [] })
-}
+export const isAutoCompletionEnabled = (enabled) =>
+  enabled ? [autocompletion({ override: [strudelAutocomplete], closeOnBlur: false })] : [];

packages/codemirror/basicSetup.mjs

@@ -0,0 +1,63 @@
+import {
+  keymap,
+  highlightSpecialChars,
+  drawSelection,
+  highlightActiveLine,
+  dropCursor,
+  rectangularSelection,
+  crosshairCursor,
+  lineNumbers,
+  highlightActiveLineGutter,
+} from '@codemirror/view';
+import {
+  defaultHighlightStyle,
+  syntaxHighlighting,
+  bracketMatching,
+  foldGutter,
+  foldKeymap,
+} from '@codemirror/language';
+import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
+import { searchKeymap, highlightSelectionMatches } from '@codemirror/search';
+import { completionKeymap, closeBracketsKeymap } from '@codemirror/autocomplete';
+
+// Taken + slightly modified from https://github.com/codemirror/basic-setup/blob/main/src/codemirror.ts
+
+export const basicSetup = (() => [
+  //   lineNumbers(),
+  //   highlightActiveLineGutter(),
+  highlightSpecialChars(),
+  history(),
+  // foldGutter(),
+  // drawSelection(),
+  dropCursor(),
+  // EditorState.allowMultipleSelections.of(true),
+  // indentOnInput(),
+  // syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+  // autocompletion(),
+  rectangularSelection(),
+  crosshairCursor(),
+  // highlightActiveLine(),
+  // highlightSelectionMatches(),
+  keymap.of([
+    ...closeBracketsKeymap,
+    ...defaultKeymap,
+    // ...searchKeymap,
+    ...historyKeymap,
+    // ...foldKeymap,
+    // ...completionKeymap,
+  ]),
+])();
+
+/// A minimal set of extensions to create a functional editor. Only
+/// includes [the default keymap](#commands.defaultKeymap), [undo
+/// history](#commands.history), [special character
+/// highlighting](#view.highlightSpecialChars), [custom selection
+/// drawing](#view.drawSelection), and [default highlight
+/// style](#language.defaultHighlightStyle).
+export const minimalSetup = (() => [
+  highlightSpecialChars(),
+  history(),
+  drawSelection(),
+  syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+  keymap.of([...defaultKeymap, ...historyKeymap]),
+])();

packages/codemirror/codemirror.mjs

@@ -1,8 +1,8 @@
 import { closeBrackets } from '@codemirror/autocomplete';
 export { toggleComment, toggleBlockComment, toggleLineComment, toggleBlockCommentByLine } from '@codemirror/commands';
 // import { search, highlightSelectionMatches } from '@codemirror/search';
-import { history, indentWithTab } from '@codemirror/commands';
-import { javascript } from '@codemirror/lang-javascript';
+import { indentWithTab } from '@codemirror/commands';
+import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
 import { defaultHighlightStyle, syntaxHighlighting, bracketMatching } from '@codemirror/language';
 import { Compartment, EditorState, Prec } from '@codemirror/state';
 import {
@@ -24,6 +24,7 @@ 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';
 
 const extensions = {
   isLineWrappingEnabled: (on) => (on ? EditorView.lineWrapping : []),
@@ -85,13 +86,17 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
       /* search(),
       highlightSelectionMatches(), */
       ...initialSettings,
+      basicSetup,
       mondo ? [] : javascript(),
+      javascriptLanguage.data.of({
+        closeBrackets: { brackets: ['(', '[', '{', "'", '"', '<'] },
+        bracketMatching: { brackets: ['(', '[', '{', "'", '"', '<'] },
+      }),
       sliderPlugin,
       widgetPlugin,
       // indentOnInput(), // works without. already brought with javascript extension?
       // bracketMatching(), // does not do anything
       syntaxHighlighting(defaultHighlightStyle),
-      history(),
       EditorView.updateListener.of((v) => onChange(v)),
       drawSelection({ cursorBlinkRate: 0 }),
       Prec.highest(

packages/codemirror/html.mjs

@@ -1,6 +1,7 @@
-const parser = typeof DOMParser !== 'undefined' ? new DOMParser() : null;
 export let html = (string) => {
-  return parser?.parseFromString(string, 'text/html').querySelectorAll('*');
+  const template = document.createElement('template');
+  template.innerHTML = string.trim();
+  return template.content.childNodes;
 };
 let parseChunk = (chunk) => {
   if (Array.isArray(chunk)) return chunk.flat().join('');

packages/codemirror/keybindings.mjs

@@ -3,8 +3,9 @@ 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 } from './vim_test.mjs';
 import { vscodeKeymap } from '@replit/codemirror-vscode-keymap';
-import { defaultKeymap, historyKeymap } from '@codemirror/commands';
+import { defaultKeymap } from '@codemirror/commands';
 
 const vscodePlugin = ViewPlugin.fromClass(
   class {
@@ -27,5 +28,5 @@ const keymaps = {
 
 export function keybindings(name) {
   const active = keymaps[name];
-  return [active ? active() : [], keymap.of(historyKeymap)];
+  return [active ? Prec.high(active()) : []];
 }

packages/codemirror/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/codemirror",
-  "version": "1.2.2",
+  "version": "1.2.5",
   "description": "Codemirror Extensions for Strudel",
   "main": "index.mjs",
   "publishConfig": {
@@ -42,7 +42,7 @@
     "@lezer/highlight": "^1.2.1",
     "@nanostores/persistent": "^0.10.2",
     "@replit/codemirror-emacs": "^6.1.0",
-    "@replit/codemirror-vim": "^6.2.1",
+    "@replit/codemirror-vim": "^6.3.0",
     "@replit/codemirror-vscode-keymap": "^6.0.2",
     "@strudel/core": "workspace:*",
     "@strudel/draw": "workspace:*",

packages/codemirror/tooltip.mjs

@@ -1,6 +1,6 @@
 import { hoverTooltip } from '@codemirror/view';
 import jsdoc from '../../doc.json';
-import { Autocomplete } from './autocomplete.mjs';
+import { Autocomplete, getSynonymDoc } from './autocomplete.mjs';
 
 const getDocLabel = (doc) => doc.name || doc.longname;
 
@@ -52,10 +52,11 @@ export const strudelTooltip = hoverTooltip(
     let entry = jsdoc.docs.filter((doc) => getDocLabel(doc) === word)[0];
     if (!entry) {
       // Try for synonyms
-      entry = jsdoc.docs.filter((doc) => doc.synonyms && doc.synonyms.includes(word))[0];
-      if (!entry) {
+      const doc = jsdoc.docs.filter((doc) => doc.synonyms && doc.synonyms.includes(word))[0];
+      if (!doc) {
         return null;
       }
+      entry = getSynonymDoc(doc, word);
     }
 
     return {
@@ -66,7 +67,7 @@ export const strudelTooltip = hoverTooltip(
       create(view) {
         let dom = document.createElement('div');
         dom.className = 'strudel-tooltip';
-        const ac = Autocomplete({ doc: entry, label: word });
+        const ac = Autocomplete(entry);
         dom.appendChild(ac);
         return { dom };
       },

packages/codemirror/widget.mjs

@@ -140,3 +140,9 @@ registerWidget('_spectrum', (id, options = {}, pat) => {
   const ctx = getCanvasWidget(id, options).getContext('2d');
   return pat.spectrum({ ...options, ctx, id });
 });
+
+registerWidget('_textbox', (id, options = {}, pat) => {
+  options = { width: 500, height: 30, ...options };
+  const ctx = getCanvasWidget(id, options).getContext('2d');
+  return pat.textbox({ ...options, ctx, id });
+});

packages/core/bench/pattern.bench.mjs

@@ -1,11 +1,11 @@
 import { describe, bench } from 'vitest';
 
-import { calculateTactus, sequence, stack } from '../index.mjs';
+import { calculateSteps, sequence, stack } from '../index.mjs';
 
 const pat64 = sequence(...Array(64).keys());
 
 describe('steps', () => {
-  calculateTactus(true);
+  calculateSteps(true);
   bench(
     '+tactus',
     () => {
@@ -14,7 +14,7 @@ describe('steps', () => {
     { time: 1000 },
   );
 
-  calculateTactus(false);
+  calculateSteps(false);
   bench(
     '-tactus',
     () => {
@@ -25,7 +25,7 @@ describe('steps', () => {
 });
 
 describe('stack', () => {
-  calculateTactus(true);
+  calculateSteps(true);
   bench(
     '+tactus',
     () => {
@@ -34,7 +34,7 @@ describe('stack', () => {
     { time: 1000 },
   );
 
-  calculateTactus(false);
+  calculateSteps(false);
   bench(
     '-tactus',
     () => {
@@ -43,4 +43,4 @@ describe('stack', () => {
     { time: 1000 },
   );
 });
-calculateTactus(true);
+calculateSteps(true);

packages/core/clockworker.js

@@ -12,6 +12,8 @@ function getTime() {
 let num_cycles_at_cps_change = 0;
 let num_ticks_since_cps_change = 0;
 let num_seconds_at_cps_change = 0;
+let max_cycle = null;
+
 let cps = 0.5;
 // {id: {started: boolean}}
 const clients = new Map();
@@ -39,6 +41,7 @@ const sendTick = (phase, duration, tick, time) => {
     cps,
     time,
     cycle,
+    max_cycle,
   });
   num_ticks_since_cps_change++;
 };
@@ -60,9 +63,10 @@ const stopClock = async (id) => {
 
   const otherClientStarted = Array.from(clients.values()).some((c) => c.started);
   //dont stop the clock if other instances are running...
-  if (!started || otherClientStarted) {
-    return;
-  }
+  // actually do stop it
+  // if (!started || otherClientStarted) {
+  //   return;
+  // }
 
   clock.stop();
   setCycle(0);
@@ -74,6 +78,10 @@ const setCycle = (cycle) => {
   num_cycles_at_cps_change = cycle;
 };
 
+const setMaxCycle = (cycle) => {
+  max_cycle = cycle;
+};
+
 const processMessage = (message) => {
   const { type, payload } = message;
 
@@ -92,6 +100,10 @@ const processMessage = (message) => {
       setCycle(payload.cycle);
       break;
     }
+    case 'setmaxcycle': {
+      setMaxCycle(payload.maxcycle);
+      break;
+    }
     case 'toggle': {
       if (payload.started) {
         startClock(message.id);

packages/core/controls.mjs

@@ -87,10 +87,244 @@ export function registerControl(names, ...aliases) {
  */
 export const { s, sound } = registerControl(['s', 'n', 'gain'], 'sound');
 
+/**
+ * Position in the wavetable of the wavetable oscillator
+ *
+ * @name wt
+ * @param {number | Pattern} position Position in the wavetable from 0 to 1
+ * @synonyms wavetablePosition
+ * @example
+ * s("squelch").bank("wt_digital").seg(8).note("F1").wt("0 0.25 0.5 0.75 1")
+ */
+export const { wt, wavetablePosition } = registerControl('wt', 'wavetablePosition');
+
+/**
+ * Amount of envelope applied wavetable oscillator's position envelope
+ *
+ * @name wtenv
+ * @param {number | Pattern} amount between 0 and 1
+ */
+export const { wtenv } = registerControl('wtenv');
+/**
+ * Attack time of the wavetable oscillator's position envelope
+ *
+ * @name wtattack
+ * @synonyms wtatt
+ * @param {number | Pattern} time attack time in seconds
+ */
+export const { wtattack, wtatt } = registerControl('wtattack', 'wtatt');
+
+/**
+ * Decay time of the wavetable oscillator's position envelope
+ *
+ * @name wtdecay
+ * @synonyms wtdec
+ * @param {number | Pattern} time decay time in seconds
+ */
+export const { wtdecay, wtdec } = registerControl('wtdecay', 'wtdec');
+
+/**
+ * Sustain time of the wavetable oscillator's position envelope
+ *
+ * @name wtsustain
+ * @synonyms wtsus
+ * @param {number | Pattern} gain sustain level (0 to 1)
+ */
+export const { wtsustain, wtsus } = registerControl('wtsustain', 'wtsus');
+
+/**
+ * Release time of the wavetable oscillator's position envelope
+ *
+ * @name wtrelease
+ * @synonyms wtrel
+ * @param {number | Pattern} time release time in seconds
+ */
+export const { wtrelease, wtrel } = registerControl('wtrelease', 'wtrel');
+
+/**
+ * Rate of the LFO for the wavetable oscillator's position
+ *
+ * @name wtrate
+ * @param {number | Pattern} rate rate in hertz
+ */
+export const { wtrate } = registerControl('wtrate');
+/**
+ * cycle synced rate of the LFO for the wavetable oscillator's position
+ *
+ * @name wtsync
+ * @param {number | Pattern} rate rate in cycles
+ */
+export const { wtsync } = registerControl('wtsync');
+
+/**
+ * Depth of the LFO for the wavetable oscillator's position
+ *
+ * @name wtdepth
+ * @param {number | Pattern} depth depth of modulation
+ */
+export const { wtdepth } = registerControl('wtdepth');
+
+/**
+ * Shape of the LFO for the wavetable oscillator's position
+ *
+ * @name wtshape
+ * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
+ */
+export const { wtshape } = registerControl('wtshape');
+
+/**
+ * DC offset of the LFO for the wavetable oscillator's position
+ *
+ * @name wtdc
+ * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
+ */
+export const { wtdc } = registerControl('wtdc');
+
+/**
+ * Skew of the LFO for the wavetable oscillator's position
+ *
+ * @name wtskew
+ * @param {number | Pattern} skew How much to bend the LFO shape
+ */
+export const { wtskew } = registerControl('wtskew');
+
+/**
+ * Amount of warp (alteration of the waveform) to apply to the wavetable oscillator
+ *
+ * @name warp
+ * @param {number | Pattern} amount Warp of the wavetable from 0 to 1
+ * @synonyms wavetableWarp
+ * @example
+ * s("basique").bank("wt_digital").seg(8).note("F1").warp("0 0.25 0.5 0.75 1")
+ *   .warpmode("spin")
+ */
+export const { warp, wavetableWarp } = registerControl('warp', 'wavetableWarp');
+
+/**
+ * Attack time of the wavetable oscillator's warp envelope
+ *
+ * @name warpattack
+ * @synonyms warpatt
+ * @param {number | Pattern} time attack time in seconds
+ */
+export const { warpattack, warpatt } = registerControl('warpattack', 'warpatt');
+
+/**
+ * Decay time of the wavetable oscillator's warp envelope
+ *
+ * @name warpdecay
+ * @synonyms warpdec
+ * @param {number | Pattern} time decay time in seconds
+ */
+export const { warpdecay, warpdec } = registerControl('warpdecay', 'warpdec');
+
+/**
+ * Sustain time of the wavetable oscillator's warp envelope
+ *
+ * @name warpsustain
+ * @synonyms warpsus
+ * @param {number | Pattern} gain sustain level (0 to 1)
+ */
+export const { warpsustain, warpsus } = registerControl('warpsustain', 'warpsus');
+
+/**
+ * Release time of the wavetable oscillator's warp envelope
+ *
+ * @name warprelease
+ * @synonyms warprel
+ * @param {number | Pattern} time release time in seconds
+ */
+export const { warprelease, warprel } = registerControl('warprelease', 'warprel');
+
+/**
+ * Rate of the LFO for the wavetable oscillator's warp
+ *
+ * @name warprate
+ * @param {number | Pattern} rate rate in hertz
+ */
+export const { warprate } = registerControl('warprate');
+
+/**
+ * Depth of the LFO for the wavetable oscillator's warp
+ *
+ * @name warpdepth
+ * @param {number | Pattern} depth depth of modulation
+ */
+export const { warpdepth } = registerControl('warpdepth');
+
+/**
+ * Shape of the LFO for the wavetable oscillator's warp
+ *
+ * @name warpshape
+ * @param {number | Pattern} shape Shape of the lfo (0, 1, 2, ..)
+ */
+export const { warpshape } = registerControl('warpshape');
+
+/**
+ * DC offset of the LFO for the wavetable oscillator's warp
+ *
+ * @name warpdc
+ * @param {number | Pattern} dcoffset dc offset. set to 0 for unipolar
+ */
+export const { warpdc } = registerControl('warpdc');
+
+/**
+ * Skew of the LFO for the wavetable oscillator's warp
+ *
+ * @name warpskew
+ * @param {number | Pattern} skew How much to bend the LFO shape
+ */
+export const { warpskew } = registerControl('warpskew');
+
+/**
+ * Type of warp (alteration of the waveform) to apply to the wavetable oscillator.
+ *
+ * The current options are: none, asym, bendp, bendm, bendmp, sync, quant, fold, pwm, orbit,
+ * spin, chaos, primes, binary, brownian, reciprocal, wormhole, logistic, sigmoid, fractal, flip
+ *
+ * @name warpmode
+ * @param {number | string | Pattern} mode Warp mode
+ * @synonyms wavetableWarpMode
+ * @example
+ * s("morgana").bank("wt_digital").seg(8).note("F1").warp("0 0.25 0.5 0.75 1")
+ *   .warpmode("<asym bendp spin logistic sync wormhole brownian>*2")
+ *
+ */
+export const { warpmode, wavetableWarpMode } = registerControl('warpmode', 'wavetableWarpMode');
+
+/**
+ * Amount of randomness of the initial phase of the wavetable oscillator.
+ *
+ * @name wtphaserand
+ * @param {number | Pattern} amount Randomness of the initial phase. Between 0 (not random) and 1 (fully random)
+ * @synonyms wavetablePhaseRand
+ * @example
+ * s("basique").bank("wt_digital").seg(16).wtphaserand("<0 1>")
+ *
+ */
+export const { wtphaserand, wavetablePhaseRand } = registerControl('wtphaserand', 'wavetablePhaseRand');
+
+/**
+ * Amount of envelope applied wavetable oscillator's position envelope
+ *
+ * @name warpenv
+ * @param {number | Pattern} amount between 0 and 1
+ */
+export const { warpenv } = registerControl('warpenv');
+
+/**
+ * cycle synced rate of the LFO for the wavetable warp position
+ *
+ * @name warpsync
+ * @param {number | Pattern} rate rate in cycles
+ */
+export const { warpsync } = registerControl('warpsync');
+
 /**
  * Define a custom webaudio node to use as a sound source.
  *
  * @name source
+ * @synonyms src
  * @param {function} getSource
  * @synonyms src
  *
@@ -113,7 +347,7 @@ export const { n } = registerControl('n');
  *
  * - a letter (a-g or A-G)
  * - optional accidentals (b or #)
- * - optional octave number (0-9). Defaults to 3
+ * - optional (possibly negative) octave number (0-9). Defaults to 3
  *
  * Examples of valid note names: `c`, `bb`, `Bb`, `f#`, `c3`, `A4`, `Eb2`, `c#5`
  *
@@ -126,6 +360,8 @@ export const { n } = registerControl('n');
  * note("c4 a4 f4 e4")
  * @example
  * note("60 69 65 64")
+ * @example
+ * note("fbb1 a#0 cbbb-1 e##-2").sound("saw")
  */
 export const { note } = registerControl(['note', 'n']);
 
@@ -141,8 +377,8 @@ export const { note } = registerControl(['note', 'n']);
  */
 export const { accelerate } = registerControl('accelerate');
 /**
- *
  * Sets the velocity from 0 to 1. Is multiplied together with gain.
+ *
  * @name velocity
  * @example
  * s("hh*8")
@@ -252,6 +488,20 @@ export const { fmenv } = registerControl('fmenv');
  *
  */
 export const { fmattack } = registerControl('fmattack');
+
+/**
+ * Waveform of the fm modulator
+ *
+ * @name fmwave
+ * @param {number | Pattern} wave waveform
+ * @example
+ * n("0 1 2 3".fast(4)).scale("d:minor").s("sine").fmwave("<sine square sawtooth crackle>").fm(4).fmh(2.01)
+ * @example
+ * n("0 1 2 3".fast(4)).chord("<Dm Am F G>").voicing().s("sawtooth").fmwave("brown").fm(.6)
+ *
+ */
+export const { fmwave } = registerControl('fmwave');
+
 /**
  * Decay time for the FM envelope: seconds until the sustain level is reached after the attack phase.
  *
@@ -295,6 +545,17 @@ export const { fmvelocity } = registerControl('fmvelocity');
  */
 export const { bank } = registerControl('bank');
 
+/**
+ * mix control for the chorus effect
+ *
+ * @name chorus
+ * @param {string | Pattern} chorus mix amount between 0 and 1
+ * @example
+ * note("d d a# a").s("sawtooth").chorus(.5)
+ *
+ */
+export const { chorus } = registerControl('chorus');
+
 // analyser node send amount 0 - 1 (used by scope)
 export const { analyze } = registerControl('analyze');
 // fftSize of analyser
@@ -306,6 +567,7 @@ export const { fft } = registerControl('fft');
  *
  * @name decay
  * @param {number | Pattern} time decay time in seconds
+ * @synonyms dec
  * @example
  * note("c3 e3 f3 g3").decay("<.1 .2 .3 .4>").sustain(0)
  *
@@ -362,7 +624,7 @@ export const { bandf, bpf, bp } = registerControl(['bandf', 'bandq', 'bpenv'], '
 // ['bpq'],
 export const { bandq, bpq } = registerControl('bandq', 'bpq');
 /**
- * a pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to cut off the first quarter from each sample.
+ * A pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to cut off the first quarter from each sample.
  *
  * @memberof Pattern
  * @name begin
@@ -423,7 +685,7 @@ export const { loopBegin, loopb } = registerControl('loopBegin', 'loopb');
  */
 export const { loopEnd, loope } = registerControl('loopEnd', 'loope');
 /**
- * bit crusher effect.
+ * Bit crusher effect.
  *
  * @name crush
  * @param {number | Pattern} depth between 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).
@@ -434,7 +696,7 @@ export const { loopEnd, loope } = registerControl('loopEnd', 'loope');
 // ['clhatdecay'],
 export const { crush } = registerControl('crush');
 /**
- * fake-resampling for lowering the sample rate. Caution: This effect seems to only work in chromium based browsers
+ * Fake-resampling for lowering the sample rate. Caution: This effect seems to only work in chromium based browsers
  *
  * @name coarse
  * @param {number | Pattern} factor 1 for original 2 for half, 3 for a third and so on.
@@ -445,7 +707,7 @@ export const { crush } = registerControl('crush');
 export const { coarse } = registerControl('coarse');
 
 /**
- * modulate the amplitude of a sound with a continuous waveform
+ * Modulate the amplitude of a sound with a continuous waveform
  *
  * @name tremolo
  * @synonyms trem
@@ -457,7 +719,7 @@ export const { coarse } = registerControl('coarse');
 export const { tremolo } = registerControl(['tremolo', 'tremolodepth', 'tremoloskew', 'tremolophase'], 'trem');
 
 /**
- * modulate the amplitude of a sound with a continuous waveform
+ * Modulate the amplitude of a sound with a continuous waveform
  *
  * @name tremolosync
  * @synonyms tremsync
@@ -472,7 +734,7 @@ export const { tremolosync } = registerControl(
 );
 
 /**
- * depth of amplitude modulation
+ * Depth of amplitude modulation
  *
  * @name tremolodepth
  * @synonyms tremdepth
@@ -483,7 +745,7 @@ export const { tremolosync } = registerControl(
  */
 export const { tremolodepth } = registerControl('tremolodepth', 'tremdepth');
 /**
- * alter the shape of the modulation waveform
+ * Alter the shape of the modulation waveform
  *
  * @name tremoloskew
  * @synonyms tremskew
@@ -495,7 +757,7 @@ export const { tremolodepth } = registerControl('tremolodepth', 'tremdepth');
 export const { tremoloskew } = registerControl('tremoloskew', 'tremskew');
 
 /**
- * alter the phase of the modulation waveform
+ * Alter the phase of the modulation waveform
  *
  * @name tremolophase
  * @synonyms tremphase
@@ -507,9 +769,10 @@ export const { tremoloskew } = registerControl('tremoloskew', 'tremskew');
 export const { tremolophase } = registerControl('tremolophase', 'tremphase');
 
 /**
- * shape of amplitude modulation
+ * Shape of amplitude modulation
  *
  * @name tremoloshape
+ * @synonyms tremshape
  * @param {number | Pattern} shape tri | square | sine | saw | ramp
  * @example
  * note("{f g c d}%16").tremsync(4).tremoloshape("<sine tri square>").s("sawtooth")
@@ -517,7 +780,7 @@ export const { tremolophase } = registerControl('tremolophase', 'tremphase');
  */
 export const { tremoloshape } = registerControl('tremoloshape', 'tremshape');
 /**
- * filter overdrive for supported filter types
+ * Filter overdrive for supported filter types
  *
  * @name drive
  * @param {number | Pattern} amount
@@ -525,32 +788,94 @@ export const { tremoloshape } = registerControl('tremoloshape', 'tremshape');
  * note("{f g g c d a a#}%16".sub(17)).s("supersaw").lpenv(8).lpf(150).lpq(.8).ftype('ladder').drive("<.5 4>")
  *
  */
-
-// TODO: SUPRADOUGH implement post orbit "pump" sidechain effect
-// /**
-//  * modulate the amplitude of an orbit to create a "sidechain" like effect
-//  *
-//  * @name pump
-//  * @param {number | Pattern} speed modulation speed in cycles
-//  * @example
-//  * note("{f g c d}%16").s("sawtooth").pump(".25:.75")
-//  *
-//  */
-// export const { pump } = registerControl(['pump', 'pumpdepth']);
-
-// /**
-//  * modulate the amplitude of an orbit to create a "sidechain" like effect
-//  *
-//  * @name pumpdepth
-//  * @param {number | Pattern} depth depth of modulation from 0 to 1
-//  * @example
-//  * note("{f g c d}%16").s("sawtooth").pump(".25").depth("<.25 .5 .75 1>")
-//  *
-//  */
-// export const { pumpdepth } = registerControl('pumpdepth');
-
 export const { drive } = registerControl('drive');
 
+/**
+ * Modulate the amplitude of an orbit to create a "sidechain" like effect.
+ *
+ * Can be applied to multiple orbits with the ':' mininotation, e.g. `duckorbit("2:3")`
+ *
+ * @name duckorbit
+ * @synonyms duck
+ * @param {number | Pattern} orbit target orbit
+ * @example
+ * $: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
+ * $: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth(1)
+ * @example
+ * $: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
+ * $: s("hh*16").orbit(3)
+ * $: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:3").duckattack(0.2).duckdepth(1)
+ *
+ */
+export const { duck } = registerControl('duckorbit', 'duck');
+
+/**
+ * The amount of ducking applied to target orbit
+ *
+ * Can vary across orbits with the ':' mininotation, e.g. `duckdepth("0.3:0.1")`.
+ * Note: this requires first applying the effect to multiple orbits with e.g. `duckorbit("2:3")`.
+ *
+ * @name duckdepth
+ * @param {number | Pattern} depth depth of modulation from 0 to 1
+ * @example
+ * stack( n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2), s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth("<1 .9 .6 0>"))
+ * @example
+ * $: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
+ * $: s("hh*16").orbit(3)
+ * $: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:3").duckattack(0.2).duckdepth("1:0.5")
+ *
+ */
+export const { duckdepth } = registerControl('duckdepth');
+
+/**
+ * The time required for the ducked signal(s) to reach their lowest volume.
+ * Can be used to prevent clicking or for creative rhythmic effects.
+ *
+ * Can vary across orbits with the ':' mininotation, e.g. `duckonset("0:0.003")`.
+ * Note: this requires first applying the effect to multiple orbits with e.g. `duckorbit("2:3")`.
+ *
+ * @name duckonset
+ * @synonyms duckons
+ *
+ * @param {number | Pattern} time The onset time in seconds
+ * @example
+ * // Clicks
+ * sound: freq("63.2388").s("sine").orbit(2).gain(4)
+ * duckerWithClick: s("bd*4").duckorbit(2).duckattack(0.3).duckonset(0).postgain(0)
+ * @example
+ * // No clicks
+ * sound: freq("63.2388").s("sine").orbit(2).gain(4)
+ * duckerWithoutClick: s("bd*4").duckorbit(2).duckattack(0.3).duckonset(0.01).postgain(0)
+ * @example
+ * // Rhythmic
+ * noise: s("pink").distort("2:1").orbit(4) // used rhythmically with 0.3 onset below
+ * hhat: s("hh*16").orbit(7)
+ * ducker: s("bd*4").bank("tr909").duckorbit("4:7").duckonset("0.3:0.003").duckattack(0.25)
+ *
+ */
+export const { duckonset } = registerControl('duckonset', 'duckons');
+
+/**
+ * The time required for the ducked signal(s) to return to their normal volume.
+ *
+ * Can vary across orbits with the ':' mininotation, e.g. `duckonset("0:0.003")`.
+ * Note: this requires first applying the effect to multiple orbits with e.g. `duckorbit("2:3")`.
+ *
+ * @name duckattack
+ * @synonyms duckatt
+ *
+ * @param {number | Pattern} time The attack time in seconds
+ * @example
+ * sound: n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2)
+ * ducker: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack("<0.2 0 0.4>").duckdepth(1)
+ * @example
+ * moreduck: n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2)
+ * lessduck: s("hh*16").orbit(5)
+ * ducker: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:5").duckattack("0.4:0.1")
+ *
+ */
+export const { duckattack } = registerControl('duckattack', 'duckatt');
+
 /**
  * Create byte beats with custom expressions
  *
@@ -591,7 +916,7 @@ export const { byteBeatStartTime, bbst } = registerControl('byteBeatStartTime',
 export const { channels, ch } = registerControl('channels', 'ch');
 
 /**
- * controls the pulsewidth of the pulse oscillator
+ * Controls the pulsewidth of the pulse oscillator
  *
  * @name pw
  * @param {number | Pattern} pulsewidth
@@ -603,7 +928,7 @@ export const { channels, ch } = registerControl('channels', 'ch');
 export const { pw } = registerControl(['pw', 'pwrate', 'pwsweep']);
 
 /**
- * controls the lfo rate for the pulsewidth of the pulse oscillator
+ * Controls the lfo rate for the pulsewidth of the pulse oscillator
  *
  * @name pwrate
  * @param {number | Pattern} rate
@@ -615,7 +940,7 @@ export const { pw } = registerControl(['pw', 'pwrate', 'pwsweep']);
 export const { pwrate } = registerControl('pwrate');
 
 /**
- * controls the lfo sweep for the pulsewidth of the pulse oscillator
+ * Controls the lfo sweep for the pulsewidth of the pulse oscillator
  *
  * @name pwsweep
  * @param {number | Pattern} sweep
@@ -656,7 +981,7 @@ export const { phaserrate, ph, phaser } = registerControl(
 export const { phasersweep, phs } = registerControl('phasersweep', 'phs');
 
 /**
- *  The center frequency of the phaser in HZ. Defaults to 1000
+ * The center frequency of the phaser in HZ. Defaults to 1000
  *
  * @name phasercenter
  * @synonyms phc
@@ -673,7 +998,7 @@ export const { phasercenter, phc } = registerControl('phasercenter', 'phc');
  * The amount the signal is affected by the phaser effect. Defaults to 0.75
  *
  * @name phaserdepth
- * @synonyms phd
+ * @synonyms phd, phasdp
  * @param {number | Pattern} depth number between 0 and 1
  * @example
  * n(run(8)).scale("D:pentatonic").s("sawtooth").release(0.5)
@@ -684,7 +1009,7 @@ export const { phasercenter, phc } = registerControl('phasercenter', 'phc');
 export const { phaserdepth, phd, phasdp } = registerControl('phaserdepth', 'phd', 'phasdp');
 
 /**
- * choose the channel the pattern is sent to in superdirt
+ * Choose the channel the pattern is sent to in superdirt
  *
  * @name channel
  * @param {number | Pattern} channel channel number
@@ -1036,7 +1361,7 @@ export const { resonance, lpq } = registerControl('resonance', 'lpq');
  * @name djf
  * @param {number | Pattern} cutoff below 0.5 is low pass filter, above is high pass filter
  * @example
- * n("0 3 7 [10,24]").s('superzow').octave(3).djf("<.5 .25 .5 .75>").osc()
+ * n(irand(16).seg(8)).scale("d:phrygian").s("supersaw").djf("<.5 .3 .2 .75>")
  *
  */
 export const { djf } = registerControl('djf');
@@ -1070,14 +1395,27 @@ export const { delay } = registerControl(['delay', 'delaytime', 'delayfeedback']
  *
  */
 export const { delayfeedback, delayfb, dfb } = registerControl('delayfeedback', 'delayfb', 'dfb');
+
+/**
+ * Sets the level of the signal that is fed back into the delay.
+ * Caution: Values >= 1 will result in a signal that gets louder and louder! Don't do it
+ *
+ * @name delayfeedback
+ * @param {number | Pattern} feedback between 0 and 1
+ * @synonyms delayfb, dfb
+ * @example
+ * s("bd").delay(.25).delayfeedback("<.25 .5 .75 1>")
+ *
+ */
+export const { delayspeed } = registerControl('delayspeed');
 /**
  * Sets the time of the delay effect.
  *
- * @name delaytime
- * @param {number | Pattern} seconds between 0 and Infinity
+ * @name delayspeed
+ * @param {number | Pattern} delayspeed controls the pitch of the delay feedback
  * @synonyms delayt, dt
  * @example
- * s("bd bd").delay(.25).delaytime("<.125 .25 .5 1>")
+ * note("d d a# a".fast(2)).s("sawtooth").delay(.8).delaytime(1/2).delayspeed("<2 .5 -1 -2>")
  *
  */
 export const { delaytime, delayt, dt } = registerControl('delaytime', 'delayt', 'dt');
@@ -1155,6 +1493,7 @@ export const { dry } = registerControl('dry');
  * Used when using `begin`/`end` or `chop`/`striate` and friends, to change the fade out time of the 'grain' envelope.
  *
  * @name fadeTime
+ * @synonyms fadeOutTime
  * @param {number | Pattern} time between 0 and 1
  * @example
  * s("oh*4").end(.1).fadeTime("<0 .2 .4 .8>").osc()
@@ -1489,6 +1828,29 @@ export const { roomfade, rfade } = registerControl('roomfade', 'rfade');
  *
  */
 export const { ir, iresponse } = registerControl(['ir', 'i'], 'iresponse');
+
+/**
+ * Sets speed of the sample for the impulse response.
+ * @name irspeed
+ * @param {string | Pattern} speed
+ * @example
+ * samples('github:switchangel/pad')
+ * $: s("brk/2").fit().scrub(irand(16).div(16).seg(8)).ir("swpad:4").room(.2).irspeed("<2 1 .5>/2").irbegin(.5).roomsize(.5)
+ *
+ */
+export const { irspeed } = registerControl('irspeed');
+
+/**
+ * Sets the beginning of the IR response sample
+ * @name irbegin
+ * @param {string | Pattern} begin between 0 and 1
+ * @synonyms ir
+ * @example
+ * samples('github:switchangel/pad')
+ * $: s("brk/2").fit().scrub(irand(16).div(16).seg(8)).ir("swpad:4").room(.65).irspeed("-2").irbegin("<0 .5 .75>/2").roomsize(.6)
+ *
+ */
+export const { irbegin } = registerControl('irbegin');
 /**
  * Sets the room size of the reverb, see `room`.
  * When this property is changed, the reverb will be recaculated, so only change this sparsely..
@@ -1525,19 +1887,52 @@ export const { roomsize, size, sz, rsize } = registerControl('roomsize', 'size',
 export const { shape } = registerControl(['shape', 'shapevol']);
 /**
  * Wave shaping distortion. CAUTION: it can get loud.
- * Second option in optional array syntax (ex: ".9:.5") applies a postgain to the output.
+ * Second option in optional array syntax (ex: ".9:.5") applies a postgain to the output. Third option sets the waveshaping type.
  * Most useful values are usually between 0 and 10 (depending on source gain). If you are feeling adventurous, you can turn it up to 11 and beyond ;)
  *
  * @name distort
  * @synonyms dist
- * @param {number | Pattern} distortion
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ * @param {number | string | Pattern} type type of distortion to apply
  * @example
  * s("bd sd [~ bd] sd,hh*8").distort("<0 2 3 10:.5>")
  * @example
  * note("d1!8").s("sine").penv(36).pdecay(.12).decay(.23).distort("8:.4")
+ * @example
+ * s("bd:4*4").bank("tr808").distort("3:0.5:diode")
  *
  */
-export const { distort, dist } = registerControl(['distort', 'distortvol'], 'dist');
+export const { distort, dist } = registerControl(['distort', 'distortvol', 'distorttype'], 'dist');
+
+/**
+ * Postgain for waveshaping distortion.
+ *
+ * @name distortvol
+ * @synonyms distvol
+ * @param {number | Pattern} volume linear postgain of the distortion
+ * @example
+ * s("bd*4").bank("tr909").distort(2).distortvol(0.8)
+ */
+export const { distortvol } = registerControl('distortvol', 'distvol');
+
+/**
+ * Type of waveshaping distortion to apply.
+ *
+ * @name distorttype
+ * @synonyms disttype
+ * @param {number | string | Pattern} type type of distortion to apply
+ * @example
+ * s("bd*4").bank("tr909").distort(2).distorttype("<0 1 2>")
+ *
+ * @example
+ * s("sine").note("F1*2").release(1)
+ *   .penv(24).pdecay(0.05)
+ *   .distort(rand.range(1, 8))
+ *   .distorttype("<fold chebyshev scurve diode asym sinefold>")
+ */
+export const { distorttype } = registerControl('distorttype', 'disttype');
+
 /**
  * Dynamics Compressor. The params are `compressor("threshold:ratio:knee:attack:release")`
  * More info [here](https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode?retiredLocale=de#instance_properties)

packages/core/cyclist.mjs

@@ -14,7 +14,7 @@ export class Cyclist {
     onToggle,
     onError,
     getTime,
-    latency = 0.1,
+    latency = 0.03,
     setInterval,
     clearInterval,
     beforeStart,
@@ -57,7 +57,7 @@ export class Cyclist {
           }
 
           // query the pattern for events
-          const haps = this.pattern.queryArc(begin, end, { _cps: this.cps });
+          const haps = this.pattern.queryArc(begin, end, { _cps: this.cps, cyclist: 'cyclist' });
 
           haps.forEach((hap) => {
             if (hap.hasOnset()) {

packages/core/euclid.mjs

@@ -10,7 +10,7 @@ https://rohandrape.net/?t=hmt
 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 { timeCat, register, silence } from './pattern.mjs';
+import { timeCat, register, silence, stack, pure, _morph } from './pattern.mjs';
 import { rotate, flatten, splitAt, zipWith } from './util.mjs';
 import Fraction, { lcm } from './fraction.mjs';
 
@@ -196,3 +196,26 @@ export const euclidLegato = register(['euclidLegato'], function (pulses, steps,
 export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, steps, rotation, pat) {
   return _euclidLegato(pulses, steps, rotation, pat);
 });
+
+/**
+ * A 'euclid' variant with an additional parameter that morphs the resulting
+ * rhythm from 0 (no morphing) to 1 (completely 'even'). For example
+ * `sound("bd").euclidish(3,8,0)` would be the same as
+ * `sound("bd").euclid(3,8)`, and `sound("bd").euclidish(3,8,1)` would be the
+ * same as `sound("bd bd bd")`. `sound("bd").euclidish(3,8,0.5)` would have a
+ * groove somewhere between.
+ * Inspired by the work of Malcom Braff.
+ * @name euclidish
+ * @synonyms eish
+ * @memberof Pattern
+ * @param {number} pulses the number of onsets
+ * @param {number} steps the number of steps to fill
+ * @param {number} groove exists between the extremes of 0 (straight euclidian) and 1 (straight pulse)
+ * @example
+ * sound("hh").euclidish(7,12,sine.slow(8))
+ * .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);
+  return pat.struct(morphed).setSteps(steps);
+});

packages/core/fraction.mjs

@@ -126,6 +126,8 @@ export const lcm = (...fractions) => {
   );
 };
 
+export const isFraction = (x) => x instanceof Fraction;
+
 fraction._original = Fraction;
 
 export default fraction;

packages/core/hap.mjs

@@ -4,6 +4,7 @@ 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 Fraction from './fraction.mjs';
+import { stringifyValues } from './util.mjs';
 
 export class Hap {
   /*
@@ -148,13 +149,7 @@ export class Hap {
   }
 
   showWhole(compact = false) {
-    return `${this.whole == undefined ? '~' : this.whole.show()}: ${
-      typeof this.value === 'object'
-        ? compact
-          ? JSON.stringify(this.value).slice(1, -1).replaceAll('"', '').replaceAll(',', ' ')
-          : JSON.stringify(this.value)
-        : this.value
-    }`;
+    return `${this.whole == undefined ? '~' : this.whole.show()}: ${stringifyValues(this.value, compact)}`;
   }
 
   combineContext(b) {

packages/core/logger.mjs

@@ -5,8 +5,9 @@ let debounce = 1000,
   lastTime;
 
 export function errorLogger(e, origin = 'cyclist') {
-  //TODO: add some kind of debug flag that enables this  while in dev mode
-  // console.error(e)
+  if (process.env.NODE_ENV === 'development') {
+    console.error(e);
+  }
   logger(`[${origin}] error: ${e.message}`);
 }
 
@@ -17,7 +18,7 @@ export function logger(message, type, data = {}) {
   }
   lastMessage = message;
   lastTime = t;
-  console.log(`%c${message}`, 'background-color: black;color:white;border-radius:15px');
+  console.log(`${t} %c${message}`, 'background-color: black;color:white;border-radius:15px');
   if (typeof document !== 'undefined' && typeof CustomEvent !== 'undefined') {
     document.dispatchEvent(
       new CustomEvent(logKey, {

packages/core/neocyclist.mjs

@@ -1,6 +1,6 @@
 /*
 neocyclist.mjs - event scheduler like cyclist, except recieves clock pulses from clockworker in order to sync across multiple instances.
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/neocyclist.mjs>
+Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/neocyclist.mjs>
 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/>.
 */
 
@@ -11,6 +11,7 @@ export class NeoCyclist {
   constructor({ onTrigger, onToggle, getTime }) {
     this.started = false;
     this.cps = 0.5;
+    this.lastTick = 0; // absolute time when last tick (clock callback) happened
     this.getTime = getTime; // get absolute time
     this.time_at_last_tick_message = 0;
     // the clock of the worker and the audio context clock can drift apart over time
@@ -19,16 +20,18 @@ export class NeoCyclist {
     // in order to schedule events consistently.
     this.collator = new ClockCollator({ getTargetClockTime: getTime });
     this.onToggle = onToggle;
-    this.latency = 0.1; // fixed trigger time offset
+    this.latency = -0.1; // fixed trigger time offset
     this.cycle = 0;
+    this.maxcycle = null;
     this.id = Math.round(Date.now() * Math.random());
     this.worker = new SharedWorker(new URL('./clockworker.js', import.meta.url));
     this.worker.port.start();
     this.channel = new BroadcastChannel('strudeltick');
     const tickCallback = (payload) => {
-      const { cps, begin, end, cycle, time } = payload;
+      const { cps, begin, end, cycle, maxcycle, time } = payload;
       this.cps = cps;
       this.cycle = cycle;
+      this.maxcycle = maxcycle;
       const currentTime = this.collator.calculateOffset(time) + time;
       processHaps(begin, end, currentTime);
       this.time_at_last_tick_message = currentTime;
@@ -38,8 +41,7 @@ export class NeoCyclist {
       if (this.started === false) {
         return;
       }
-
-      const haps = this.pattern.queryArc(begin, end, { _cps: this.cps });
+      const haps = this.pattern.queryArc(begin, end, { _cps: this.cps, cyclist: 'neocyclist' });
       haps.forEach((hap) => {
         if (hap.hasOnset()) {
           const timeUntilTrigger = cycleToSeconds(hap.whole.begin - this.cycle, this.cps);

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/core",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Port of Tidal Cycles to JavaScript",
   "main": "index.mjs",
   "type": "module",

packages/core/pattern.mjs

@@ -5,7 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import TimeSpan from './timespan.mjs';
-import Fraction, { lcm } from './fraction.mjs';
+import Fraction, { isFraction, lcm } from './fraction.mjs';
 import Hap from './hap.mjs';
 import State from './state.mjs';
 import { unionWithObj } from './value.mjs';
@@ -21,6 +21,8 @@ import {
   numeralArgs,
   parseNumeral,
   pairs,
+  zipWith,
+  stringifyValues,
 } from './util.mjs';
 import drawLine from './drawLine.mjs';
 import { logger } from './logger.mjs';
@@ -96,10 +98,7 @@ export class Pattern {
 
   // runs func on query state
   withState(func) {
-    return this.withHaps((haps, state) => {
-      func(state);
-      return haps;
-    });
+    return new Pattern((state) => this.query(func(state)));
   }
 
   /**
@@ -852,14 +851,29 @@ export class Pattern {
     );
   }
 
-  log(func = (_, hap) => `[hap] ${hap.showWhole(true)}`, getData = (_, hap) => ({ hap })) {
+  /**
+   * Writes the content of the current event to the console (visible in the side menu).
+   * @name log
+   * @memberof Pattern
+   * @example
+   * s("bd sd").log()
+   */
+  log(func = (hap) => `[hap] ${hap.showWhole(true)}`, getData = (hap) => ({ hap })) {
     return this.onTrigger((...args) => {
       logger(func(...args), undefined, getData(...args));
     }, false);
   }
 
-  logValues(func = id) {
-    return this.log((_, hap) => func(hap.value));
+  /**
+   * A simplified version of `log` which writes all "values" (various configurable parameters)
+   * within the event to the console (visible in the side menu).
+   * @name logValues
+   * @memberof Pattern
+   * @example
+   * s("bd sd").gain("0.25 0.5 1").n("2 1 0").logValues()
+   */
+  logValues(func = (value) => `[hap] ${stringifyValues(value, true)}`) {
+    return this.log((hap) => func(hap.value));
   }
 
   //////////////////////////////////////////////////////////////////////
@@ -982,7 +996,7 @@ addToPrototype('weaveWith', function (t, ...funcs) {
 // compose matrix functions
 
 function _nonArrayObject(x) {
-  return !Array.isArray(x) && typeof x === 'object';
+  return !Array.isArray(x) && typeof x === 'object' && !isFraction(x);
 }
 function _composeOp(a, b, func) {
   if (_nonArrayObject(a) || _nonArrayObject(b)) {
@@ -1229,7 +1243,8 @@ export const silence = gap(1);
 /* Like silence, but with a 'steps' (relative duration) of 0 */
 export const nothing = gap(0);
 
-/** A discrete value that repeats once per cycle.
+/**
+ * A discrete value that repeats once per cycle.
  *
  * @returns {Pattern}
  * @example
@@ -1282,13 +1297,14 @@ export function sequenceP(pats) {
   return result;
 }
 
-/** The given items are played at the same time at the same length.
+/**
+ * The given items are played at the same time at the same length.
  *
  * @return {Pattern}
  * @synonyms polyrhythm, pr
  * @example
  * stack("g3", "b3", ["e4", "d4"]).note()
- * // "g3,b3,[e4,d4]".note()
+ * // "g3,b3,[e4 d4]".note()
  *
  * @example
  * // As a chained function:
@@ -1365,11 +1381,11 @@ export function stackBy(by, ...pats) {
     .setSteps(steps);
 }
 
-/** Concatenation: combines a list of patterns, switching between them successively, one per cycle:
- *
- * synonyms: `cat`
+/**
+ * Concatenation: combines a list of patterns, switching between them successively, one per cycle.
  *
  * @return {Pattern}
+ * @synonyms cat
  * @example
  * slowcat("e5", "b4", ["d5", "c5"])
  *
@@ -1569,7 +1585,7 @@ export const func = curry((a, b) => reify(b).func(a));
 /**
  * Registers a new pattern method. The method is added to the Pattern class + the standalone function is returned from register.
  *
- * @param {string} name name of the function
+ * @param {string | string[]} name name of the function, or an array of names to be used as synonyms
  * @param {function} func function with 1 or more params, where last is the current pattern
  * @noAutocomplete
  *
@@ -2380,6 +2396,57 @@ export const stut = register('stut', function (times, feedback, time, pat) {
   return pat._echoWith(times, time, (pat, i) => pat.gain(Math.pow(feedback, i)));
 });
 
+export const applyN = register('applyN', function (n, func, p) {
+  let result = p;
+  for (let i = 0; i < n; i++) {
+    result = func(result);
+  }
+  return result;
+});
+
+/**
+ * The plyWith function repeats each event the given number of times, applying the given function to each event.\n
+ * @name plyWith
+ * @synonyms plywith
+ * @param {number} factor how many times to repeat
+ * @param {function} func function to apply, given the pattern
+ * @example
+ * "<0 [2 4]>"
+ * .plyWith(4, (p) => p.add(2))
+ * .scale("C:minor").note()
+ */
+export const plyWith = register(['plyWith', 'plywith'], function (factor, func, pat) {
+  const result = pat
+    .fmap((x) => cat(...listRange(0, factor - 1).map((i) => applyN(i, func, x)))._fast(factor))
+    .squeezeJoin();
+  if (__steps) {
+    result._steps = Fraction(factor).mulmaybe(pat._steps);
+  }
+  return result;
+});
+
+/**
+ * The plyForEach function repeats each event the given number of times, applying the given function to each event.
+ * This version of ply uses the iteration index as an argument to the function, similar to echoWith.
+ * @name plyForEach
+ * @synonyms plyforeach
+ * @param {number} factor how many times to repeat
+ * @param {function} func function to apply, given the pattern and the iteration index
+ * @example
+ * "<0 [2 4]>"
+ * .plyForEach(4, (p,n) => p.add(n*2))
+ * .scale("C:minor").note()
+ */
+export const plyForEach = register(['plyForEach', 'plyforeach'], function (factor, func, pat) {
+  const result = pat
+    .fmap((x) => cat(cat(pure(x), ...listRange(1, factor - 1).map((i) => func(pure(x), i))))._fast(factor))
+    .squeezeJoin();
+  if (__steps) {
+    result._steps = Fraction(factor).mulmaybe(pat._steps);
+  }
+  return result;
+});
+
 /**
  * Divides a pattern into a given number of subdivisions, plays the subdivisions in order, but increments the starting subdivision each cycle. The pattern wraps to the first subdivision after the last subdivision is played.
  * @name iter
@@ -3260,7 +3327,7 @@ export const slice = register(
  * @memberof Pattern
  *  @returns Pattern
  * @example
- * s("bd!8").onTriggerTime((hap) => {console.info(hap)})
+ * s("bd!8").onTriggerTime((hap) => {console.log(hap)})
  */
 Pattern.prototype.onTriggerTime = function (func) {
   return this.onTrigger((hap, currentTime, _cps, targetTime) => {
@@ -3400,3 +3467,142 @@ export const { beat } = register(
   ['beat'],
   __beat((x) => x.innerJoin()),
 );
+
+export const _morph = (from, to, by) => {
+  by = Fraction(by);
+  const dur = Fraction(1).div(from.length);
+  const positions = (list) => {
+    const result = [];
+    for (const [pos, value] of list.entries()) {
+      if (value) {
+        result.push([Fraction(pos).div(list.length), value]);
+      }
+    }
+    return result;
+  };
+  const arcs = zipWith(
+    ([posa, valuea], [posb, valueb]) => {
+      const b = by.mul(posb - posa).add(posa);
+      const e = b.add(dur);
+      return new TimeSpan(b, e);
+    },
+    positions(from),
+    positions(to),
+  );
+  function query(state) {
+    const cycle = state.span.begin.sam();
+    const cycleArc = state.span.cycleArc();
+    const result = [];
+    for (const whole of arcs) {
+      const part = whole.intersection(cycleArc);
+      if (part !== undefined) {
+        result.push(
+          new Hap(
+            whole.withTime((x) => x.add(cycle)),
+            part.withTime((x) => x.add(cycle)),
+            true,
+          ),
+        );
+      }
+    }
+    return result;
+  }
+  return new Pattern(query).splitQueries();
+};
+
+/**
+ * Takes two binary rhythms represented as lists of 1s and 0s, and a number
+ * between 0 and 1 that morphs between them. The two lists should contain the same
+ * number of true values.
+ * @example
+ * sound("hh").struct(morph([1,0,1,0,1,0,1,0], // straight rhythm
+ *                          [1,1,0,1,0,1,0], // wonky rhythm
+ *                          0.25 // creates a slightly wonky rhythm
+ *                         )
+ *                   )
+ * @example
+ * sound("hh").struct(morph("1:0:1:0:1:0:1:0", // straight rhythm
+ *                          "1:1:0:1:0:1:0", // wonky rhythm
+ *                          sine.slow(8) // slowly morph between the rhythms
+ *                         )
+ *                   )
+ */
+export const morph = (frompat, topat, bypat) => {
+  frompat = reify(frompat);
+  topat = reify(topat);
+  bypat = reify(bypat);
+  return frompat.innerBind((from) => topat.innerBind((to) => bypat.innerBind((by) => _morph(from, to, by))));
+};
+
+/**
+ * Soft-clipping distortion
+ *
+ * @name soft
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Hard-clipping distortion
+ *
+ * @name hard
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Cubic polynomial distortion
+ *
+ * @name cubic
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Diode-emulating distortion
+ *
+ * @name diode
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Asymmetrical diode distortion
+ *
+ * @name asym
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Wavefolding distortion
+ *
+ * @name fold
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Wavefolding distortion composed with sinusoid
+ *
+ * @name sinefold
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+/**
+ * Distortion via Chebyshev polynomials
+ *
+ * @name chebyshev
+ * @param {number | Pattern} distortion amount of distortion to apply
+ * @param {number | Pattern} volume linear postgain of the distortion
+ *
+ */
+const distAlgoNames = ['scurve', 'soft', 'hard', 'cubic', 'diode', 'asym', 'fold', 'sinefold', 'chebyshev'];
+for (const name of distAlgoNames) {
+  // Add aliases for distortion algorithms
+  Pattern.prototype[name] = function (args) {
+    const argsPat = reify(args).fmap((v) => (Array.isArray(v) ? [...v, name] : [v, 1, name]));
+    return this.distort(argsPat);
+  };
+}

packages/core/repl.mjs

@@ -74,6 +74,14 @@ export function repl({
     return silence;
   };
 
+  // helper to get a patternified pure value out
+  function unpure(pat) {
+    if (pat._Pattern) {
+      return pat.__pure;
+    }
+    return pat;
+  }
+
   const setPattern = async (pattern, autostart = true) => {
     pattern = editPattern?.(pattern) || pattern;
     await scheduler.setPattern(pattern, autostart);
@@ -85,7 +93,10 @@ export function repl({
   const start = () => scheduler.start();
   const pause = () => scheduler.pause();
   const toggle = () => scheduler.toggle();
-  const setCps = (cps) => scheduler.setCps(cps);
+  const setCps = (cps) => {
+    scheduler.setCps(unpure(cps));
+    return silence;
+  };
 
   /**
    * Changes the global tempo to the given cycles per minute
@@ -97,7 +108,10 @@ export function repl({
    * setcpm(140/4) // =140 bpm in 4/4
    * $: s("bd*4,[- sd]*2").bank('tr707')
    */
-  const setCpm = (cpm) => scheduler.setCps(cpm / 60);
+  const setCpm = (cpm) => {
+    scheduler.setCps(unpure(cpm) / 60);
+    return silence;
+  };
 
   // TODO - not documented as jsdoc examples as the test framework doesn't simulate enough context for `each` and `all`..
 
@@ -200,7 +214,10 @@ export function repl({
       }
       let { pattern, meta } = await _evaluate(code, transpiler, transpilerOptions);
       if (Object.keys(pPatterns).length) {
-        let patterns = Object.values(pPatterns);
+        let patterns = [];
+        for (const [key, value] of Object.entries(pPatterns)) {
+          patterns.push(value.withState((state) => state.setControls({ id: key })));
+        }
         if (eachTransform) {
           // Explicit lambda so only element (not index and array) are passed
           patterns = patterns.map((x) => eachTransform(x));
@@ -214,6 +231,7 @@ export function repl({
           pattern = allTransforms[i](pattern);
         }
       }
+
       if (!isPattern(pattern)) {
         const message = `got "${typeof evaluated}" instead of pattern`;
         throw new Error(message + (typeof evaluated === 'function' ? ', did you forget to call a function?' : '.'));

packages/core/state.mjs

@@ -19,9 +19,9 @@ export class State {
     return this.setSpan(func(this.span));
   }
 
-  // Returns new State with different controls
+  // Returns new State with added controls.
   setControls(controls) {
-    return new State(this.span, controls);
+    return new State(this.span, { ...this.controls, ...controls });
   }
 }
 

packages/core/test/pattern.test.mjs

@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import Fraction from 'fraction.js';
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 
 import {
   TimeSpan,
@@ -55,6 +55,8 @@ import {
   expand,
 } from '../index.mjs';
 
+import { log, logValues } from '../pattern.mjs';
+
 import { steady } from '../signal.mjs';
 
 import { n, s } from '../controls.mjs';
@@ -1306,4 +1308,40 @@ describe('Pattern', () => {
       );
     });
   });
+  describe('log', () => {
+    it('logs to console', () => {
+      const mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const pattern = pure('a').log();
+      const haps = pattern.queryArc(0, 1);
+
+      // Force a trigger
+      haps.forEach((hap) => {
+        hap.context?.onTrigger?.(hap);
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        '%c[hap] 0/1 → 1/1: a',
+        'background-color: black;color:white;border-radius:15px',
+      );
+      mockConsoleLog.mockRestore();
+    });
+  });
+  describe('logValues', () => {
+    it('logs values to console', () => {
+      const mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const pattern = pure('a').note('c#').logValues();
+      const haps = pattern.queryArc(0, 1);
+
+      // Force a trigger
+      haps.forEach((hap) => {
+        hap.context?.onTrigger?.(hap);
+      });
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        '%c[hap] value:a note:c#',
+        'background-color: black;color:white;border-radius:15px',
+      );
+      mockConsoleLog.mockRestore();
+    });
+  });
 });

packages/core/timespan.mjs

@@ -72,7 +72,7 @@ export class TimeSpan {
   }
 
   intersection(other) {
-    // Intersection of two timespans, returns None if they don't intersect.
+    // Intersection of two timespans, returns undefined if they don't intersect.
     const intersect_begin = this.begin.max(other.begin);
     const intersect_end = this.end.min(other.end);
 

packages/core/util.mjs

@@ -8,12 +8,12 @@ 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 isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]?$/.test(name);
 export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
   }
-  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)([0-9]*)$/)?.slice(1) || [];
+  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)(-?[0-9]*)$/)?.slice(1) || [];
   if (!pc) {
     return [];
   }
@@ -487,3 +487,13 @@ export function getCurrentKeyboardState() {
 //   }
 //   return lcm((x * y) / gcd(x, y), ...z);
 // };
+
+// Takes values -- typically derived from events, i.e. `hap`s -- and renders them
+// into a readable format
+export function stringifyValues(value, compact = false) {
+  return typeof value === 'object'
+    ? compact
+      ? JSON.stringify(value).slice(1, -1).replaceAll('"', '').replaceAll(',', ' ')
+      : JSON.stringify(value)
+    : value;
+}

packages/csound/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/csound",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "csound bindings for strudel",
   "main": "index.mjs",
   "type": "module",

packages/draw/index.mjs

@@ -4,3 +4,4 @@ export * from './draw.mjs';
 export * from './pianoroll.mjs';
 export * from './spiral.mjs';
 export * from './pitchwheel.mjs';
+export * from './textbox.mjs';

packages/draw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/draw",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Helpers for drawing with Strudel",
   "main": "index.mjs",
   "type": "module",

packages/draw/textbox.mjs

@@ -0,0 +1,50 @@
+import { getTheme, getDrawContext } from './draw.mjs';
+import { Pattern } from '@strudel/core';
+
+export function textbox({ haps, ctx, id, margin = 10, fontsize = 24 } = {}) {
+  const w = ctx.canvas.width;
+  const h = ctx.canvas.height;
+  ctx.clearRect(0, 0, w, h);
+  const color = getTheme().foreground;
+
+  ctx.strokeStyle = color;
+  ctx.fillStyle = color;
+  ctx.globalAlpha = 1;
+  ctx.textAlign = 'left';
+
+  haps.forEach((hap) => {
+    if (hap.hasOnset()) {
+      const hapColor = hap.value.color || color;
+      ctx.strokeStyle = hapColor;
+      ctx.fillStyle = hapColor;
+      const { velocity = 1, gain = 1 } = hap.value || {};
+      const alpha = velocity * gain;
+      ctx.globalAlpha = alpha;
+      ctx.font = `${fontsize}px sans-serif`;
+      ctx.fillText(hap.value, 0, fontsize);
+    }
+  });
+
+  return;
+}
+
+Pattern.prototype.textbox = function (options = {}) {
+  let { ctx = getDrawContext(), id = 1 } = options;
+  this.draw(
+    (haps, time) => {
+      textbox({
+        ...options,
+        time,
+        ctx,
+        haps: haps.filter((hap) => hap.isActive(time)),
+      });
+    },
+    {
+      lookbehind: 0,
+      lookahead: 0,
+      id,
+    },
+  );
+
+  return this;
+};

packages/embed/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/embed",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Embeddable Web Component to load a Strudel REPL into an iframe",
   "main": "embed.js",
   "type": "module",

packages/gamepad/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/gamepad",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Gamepad Inputs for strudel",
   "main": "index.mjs",
   "type": "module",

packages/hydra/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/hydra",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Hydra integration for strudel",
   "main": "hydra.mjs",
   "type": "module",

packages/midi/midi.mjs

@@ -493,6 +493,9 @@ export async function midin(input) {
         otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
       }`,
     );
+  }
+  // ensure refs for this input are initialized
+  if (!refs[input]) {
     refs[input] = {};
   }
   const cc = (cc) => ref(() => refs[input][cc] || 0);

packages/midi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/midi",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Midi API for strudel",
   "main": "index.mjs",
   "type": "module",

packages/mini/bench/mini.bench.mjs

@@ -1,10 +1,10 @@
 import { describe, bench } from 'vitest';
 
-import { calculateTactus } from '../../core/index.mjs';
+import { calculateSteps } from '../../core/index.mjs';
 import { mini } from '../index.mjs';
 
 describe('mini', () => {
-  calculateTactus(true);
+  calculateSteps(true);
   bench(
     '+tactus',
     () => {
@@ -13,7 +13,7 @@ describe('mini', () => {
     { time: 1000 },
   );
 
-  calculateTactus(false);
+  calculateSteps(false);
   bench(
     '-tactus',
     () => {
@@ -21,5 +21,5 @@ describe('mini', () => {
     },
     { time: 1000 },
   );
-  calculateTactus(true);
+  calculateSteps(true);
 });

packages/mini/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/mini",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Mini notation for strudel",
   "main": "index.mjs",
   "type": "module",

packages/mondo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mondolang",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "a language for functional composition that translates to js",
   "main": "mondo.mjs",
   "type": "module",

packages/mondough/mondough.mjs

@@ -85,7 +85,7 @@ function evaluator(node, scope) {
   let pat;
   if (type === 'plain' && typeof variable !== 'undefined') {
     // some function names are not patternable, so we skip reification here
-    if (['!', 'extend', '@', 'expand', 'square', 'angle'].includes(value)) {
+    if (['!', 'extend', '@', 'expand', 'square', 'angle', 'all', 'setcpm', 'setcps'].includes(value)) {
       return variable;
     }
     pat = reify(variable);
@@ -108,7 +108,7 @@ export function mondo(code, offset = 0) {
   return pat.markcss('color: var(--caret,--foreground);text-decoration:underline');
 }
 
-let getLocations = (code, offset) => runner.parser.get_locations(code, offset);
+export let getLocations = (code, offset) => runner.parser.get_locations(code, offset);
 
 export const mondi = (str, offset) => {
   const code = `[${str}]`;

packages/mondough/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/mondo",
-  "version": "1.1.0",
+  "version": "1.1.4",
   "description": "mondo notation for strudel",
   "main": "mondough.mjs",
   "type": "module",

packages/mondough/vite.config.js

@@ -1,5 +1,5 @@
 import { defineConfig } from 'vite';
-//import { dependencies } from './package.json';
+import { dependencies } from './package.json';
 import { resolve } from 'path';
 
 // https://vitejs.dev/config/
@@ -12,7 +12,7 @@ export default defineConfig({
       fileName: (ext) => ({ es: 'mondough.mjs' })[ext],
     },
     rollupOptions: {
-      // external: [...Object.keys(dependencies)],
+      external: [...Object.keys(dependencies)],
     },
     target: 'esnext',
   },

packages/motion/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/motion",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "DeviceMotion API for strudel",
   "main": "index.mjs",
   "type": "module",

packages/mqtt/mqtt.mjs

@@ -82,7 +82,7 @@ Pattern.prototype.mqtt = function (
     cx.connect(props);
   }
   return this.withHap((hap) => {
-    const onTrigger = (t_deprecate, hap, currentTime, cps, targetTime) => {
+    const onTrigger = (hap, currentTime, cps, targetTime) => {
       let msg_topic = topic;
       if (!cx || !cx.isConnected()) {
         return;

packages/mqtt/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/mqtt",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "MQTT API for strudel",
   "main": "mqtt.mjs",
   "type": "module",

packages/osc/README.md

@@ -4,21 +4,13 @@ OSC output for strudel patterns! Currently only tested with super collider / sup
 
 ## Usage
 
-OSC will only work if you run the REPL locally + the OSC server besides it:
+Assuming you have [node.js](https://nodejs.org/) installed, you can run the osc bridge server via:
 
-From the project root:
-
-```js
-npm run repl
+```sh
+npx @strudel/osc
 ```
 
-and in a seperate shell:
-
-```js
-npm run osc
-```
-
-This should give you
+You should see something like:
 
 ```log
 osc client running on port 57120
@@ -26,14 +18,32 @@ osc server running on port 57121
 websocket server running on port 8080
 ```
 
-Now open Supercollider (with the super dirt startup file)
+### --port
 
-Now open the REPL and type:
+By default it will use port 57120 for the osc client, which is what [superdirt](https://github.com/musikinformatik/SuperDirt) uses. You can change it via the `--port` option:
 
-```js
-s("<bd sd> hh").osc()
+```sh
+npx @strudel/osc --port 7771 # classic dirt
 ```
 
-or just [click here](https://strudel.cc/#cygiPGJkIHNkPiBoaCIpLm9zYygp)...
+### --debug
+
+To log all incoming osc messages, add the `--debug` flag:
+
+```sh
+npx @strudel/osc --debug
+```
+
+## Usage in Strudel
+
+To test it in strudel, you have can use `all(osc)` to send all events through osc:
+
+```js
+$: s("bd*4")
+
+all(osc)
+```
+
+[open in repl](https://strudel.cc/#JDogcygiYmQqNCIpCgphbGwob3NjKQ%3D%3D)
 
 You can read more about [how to use Superdirt with Strudel the Tutorial](https://strudel.cc/learn/input-output/#superdirt-api)

packages/osc/osc.mjs

@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import OSC from 'osc-js';
 
-import { logger, parseNumeral, Pattern, isNote, noteToMidi, ClockCollator } from '@strudel/core';
+import { logger, parseNumeral, register, isNote, noteToMidi, ClockCollator } from '@strudel/core';
 
 let connection; // Promise<OSC>
 function connect() {
@@ -81,6 +81,4 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
  * @memberof Pattern
  * @returns Pattern
  */
-Pattern.prototype.osc = function () {
-  return this.onTrigger(oscTrigger);
-};
+export const osc = register('osc', (pat) => pat.onTrigger(oscTrigger));

packages/osc/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@strudel/osc",
-  "version": "1.2.2",
+  "version": "1.2.10",
   "description": "OSC messaging for strudel",
   "main": "osc.mjs",
+  "bin": "./server.js",
   "type": "module",
   "publishConfig": {
     "main": "dist/index.mjs"

packages/osc/server.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 /*
 server.js - <short description TODO>
 Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/osc/server.js>
@@ -6,6 +8,19 @@ This program is free software: you can redistribute it and/or modify it under th
 
 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];
+  }
+}
+
+let udpClientPort = Number(getArgValue('--port')) || 57120;
+let debug = Number(getArgValue('--debug')) || 0;
+
 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: {
@@ -17,7 +32,7 @@ const config = {
   },
   udpClient: {
     host: 'localhost', // @param {string} Hostname of udp client for messaging
-    port: 57120, // @param {number} Port of udp client for messaging
+    port: udpClientPort, // @param {number} Port of udp client for messaging
   },
   wsServer: {
     host: 'localhost', // @param {string} Hostname of WebSocket server
@@ -27,8 +42,34 @@ const config = {
 
 const osc = new OSC({ plugin: new OSC.BridgePlugin(config) });
 
-osc.open(); // start a WebSocket server on port 8080
+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);
+  }
+});
+
+osc.open();
 
 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');
+}

packages/osc/superdirtoutput.js

@@ -1,10 +1,10 @@
-import { oscTriggerTauri } from '../desktopbridge/oscbridge.mjs';
-import { isTauri } from '../desktopbridge/utils.mjs';
+/* import { oscTriggerTauri } from '../desktopbridge/oscbridge.mjs';
+import { isTauri } from '../desktopbridge/utils.mjs'; */
 import { oscTrigger } from './osc.mjs';
 
-const trigger = isTauri() ? oscTriggerTauri : oscTrigger;
+const trigger = /* isTauri() ? oscTriggerTauri : */ oscTrigger;
 
 export const superdirtOutput = (hap, deadline, hapDuration, cps, targetTime) => {
   const currentTime = performance.now() / 1000;
-  return trigger(null, hap, currentTime, cps, targetTime);
+  return trigger(hap, currentTime, cps, targetTime);
 };

packages/reference/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/reference",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Headless reference of all strudel functions",
   "main": "index.mjs",
   "type": "module",

packages/repl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/repl",
-  "version": "1.2.3",
+  "version": "1.2.6",
   "description": "Strudel REPL as a Web Component",
   "module": "index.mjs",
   "publishConfig": {

packages/repl/prebake.mjs

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

packages/sampler/README.md

@@ -20,3 +20,13 @@ samples('http://localhost:5432')
 LOG=1 npx @strudel/sampler # adds logging
 PORT=5555 npx @strudel/sampler # changes port
 ```
+
+## static json
+
+when running with `--json`, you will simply get the json logged back:
+
+```sh
+npx --yes @strudel/sampler --json > strudel.json
+```
+
+this is useful if you want to create a sample pack from the current folder.

packages/sampler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/sampler",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "",
   "keywords": [
     "tidalcycles",

packages/sampler/sample-server.mjs

@@ -1,22 +1,20 @@
 #!/usr/bin/env node
 
 import cowsay from 'cowsay';
-import { createReadStream, existsSync } from 'fs';
+import { createReadStream, existsSync, writeFileSync } from 'fs';
 import { readdir } from 'fs/promises';
 import http from 'http';
-import { join, sep } from 'path';
+import { join, resolve, sep } from 'path';
+import readline from 'readline';
 import os from 'os';
 
-// eslint-disable-next-line
 const LOG = !!process.env.LOG || false;
+const VALID_AUDIO_EXTENSIONS = ['wav', 'mp3', 'ogg'];
 
-console.log(
-  cowsay.say({
-    text: 'welcome to @strudel/sampler',
-    e: 'oO',
-    T: 'U ',
-  }),
-);
+const isAudioFile = (f) => {
+  const ext = f.split('.').slice(-1)[0].toLowerCase();
+  return VALID_AUDIO_EXTENSIONS.includes(ext);
+};
 
 async function getFilesInDirectory(directory) {
   let files = [];
@@ -29,42 +27,90 @@ async function getFilesInDirectory(directory) {
         continue;
       }
       try {
-        const subFiles = (await getFilesInDirectory(fullPath)).filter((f) =>
-          ['wav', 'mp3', 'ogg'].includes(f.split('.').slice(-1)[0].toLowerCase()),
-        );
+        const subFiles = (await getFilesInDirectory(fullPath)).filter(isAudioFile);
         files = files.concat(subFiles);
         LOG && console.log(`${dirent.name} (${subFiles.length})`);
       } catch (err) {
         LOG && console.warn(`skipped due to error: ${fullPath}`);
       }
     } else {
-      files.push(fullPath);
+      isAudioFile(fullPath) && files.push(fullPath);
     }
   }
   return files;
 }
 
-async function getBanks(directory) {
+async function getBanks(directory, flat = false) {
   let files = await getFilesInDirectory(directory);
   let banks = {};
   directory = directory.split(sep).join('/');
   files = files.map((path) => {
     path = path.split(sep).join('/');
-    const [bank] = path.split('/').slice(-2);
+    const subDir = path.replace(directory, '');
+    const subDirFlat = subDir.replaceAll('/', '_').slice(1); // remove initial underscore
+    const subDirFlatStem = subDirFlat.replace(/\.[^.]+$/, ''); // remove extension
+    let bank = flat ? subDirFlatStem : path.split('/').slice(-2)[0];
     banks[bank] = banks[bank] || [];
-    const relativeUrl = path.replace(directory, '');
-    banks[bank].push(relativeUrl);
-    return relativeUrl;
+    banks[bank].push(subDir);
+    return subDir;
   });
   banks._base = `http://localhost:5432`;
   return { banks, files };
 }
 
-// eslint-disable-next-line
-const directory = process.cwd();
+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];
+  }
+}
+
+function getInput(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(query, (response) => {
+      rl.close();
+      resolve(response);
+    }),
+  );
+}
+
+let directory = getArgValue('--dir') || process.cwd();
+directory = resolve(directory);
+if (args.includes('--json')) {
+  const { banks } = await getBanks(directory, getArgValue('--flat'));
+  const json = JSON.stringify(banks);
+  const outFile = resolve(directory, 'strudel.json');
+  if (existsSync(outFile)) {
+    const answer = await getInput(`Warning: File already exists at ${outFile}. Overwrite? (y/N): `);
+    if (answer.toLowerCase() !== 'y') {
+      console.log('Aborted.');
+      process.exit(0);
+    }
+  }
+  writeFileSync(outFile, json, 'utf8');
+  console.log(`Wrote json to ${outFile}`);
+}
+
+console.log(
+  cowsay.say({
+    text: 'welcome to @strudel/sampler',
+    e: 'oO',
+    T: 'U ',
+  }),
+);
+
 const server = http.createServer(async (req, res) => {
   res.setHeader('Access-Control-Allow-Origin', '*');
-  const { banks, files } = await getBanks(directory);
+  const { banks, files } = await getBanks(directory, getArgValue('--flat'));
   if (req.url === '/') {
     res.setHeader('Content-Type', 'application/json');
     return res.end(JSON.stringify(banks));
@@ -72,7 +118,7 @@ const server = http.createServer(async (req, res) => {
   let subpath = decodeURIComponent(req.url);
   const filePath = join(directory, subpath.split('/').join(sep));
 
-  //console.log('GET:', filePath);
+  // console.log('GET:', filePath);
   const isFound = existsSync(filePath);
   if (!isFound) {
     res.statusCode = 404;

packages/serial/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/serial",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Webserial API for strudel",
   "main": "serial.mjs",
   "type": "module",

packages/soundfonts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/soundfonts",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Soundsfont support for strudel",
   "main": "index.mjs",
   "publishConfig": {

packages/superdough/audioContext.mjs

@@ -0,0 +1,18 @@
+let audioContext;
+
+export const setDefaultAudioContext = () => {
+  audioContext = new AudioContext();
+  return audioContext;
+};
+
+export const getAudioContext = () => {
+  if (!audioContext) {
+    return setDefaultAudioContext();
+  }
+
+  return audioContext;
+};
+
+export function getAudioContextCurrentTime() {
+  return getAudioContext().currentTime;
+}

packages/superdough/dspworklet.mjs

@@ -1,4 +1,4 @@
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 
 let worklet;
 export async function dspWorklet(ac, code) {

packages/superdough/helpers.mjs

@@ -1,5 +1,9 @@
-import { getAudioContext } from './superdough.mjs';
-import { clamp, nanFallback } from './util.mjs';
+import { getAudioContext } from './audioContext.mjs';
+import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';
+import { getNoiseBuffer } from './noise.mjs';
+import { logger } from './logger.mjs';
+
+export const noises = ['pink', 'white', 'brown', 'crackle'];
 
 export function gainNode(value) {
   const node = getAudioContext().createGain();
@@ -7,6 +11,13 @@ export function gainNode(value) {
   return node;
 }
 
+export function effectSend(input, effect, wet) {
+  const send = gainNode(wet);
+  input.connect(send);
+  send.connect(effect);
+  return send;
+}
+
 const getSlope = (y1, y2, x1, x2) => {
   const denom = x2 - x1;
   if (denom === 0) {
@@ -18,7 +29,9 @@ const getSlope = (y1, y2, x1, x2) => {
 export function getWorklet(ac, processor, params, config) {
   const node = new AudioWorkletNode(ac, processor, config);
   Object.entries(params).forEach(([key, value]) => {
-    node.parameters.get(key).value = value;
+    if (value !== undefined) {
+      node.parameters.get(key).value = value;
+    }
   });
   return node;
 }
@@ -85,6 +98,35 @@ export const getParamADSR = (
   param[ramp](min, end + release);
 };
 
+function getModulationShapeInput(val) {
+  if (typeof val === 'number') {
+    return val % 5;
+  }
+  return { tri: 0, triangle: 0, sine: 1, ramp: 2, saw: 3, square: 4 }[val] ?? 0;
+}
+
+export function getLfo(audioContext, begin, end, properties = {}) {
+  const { shape = 0, ...props } = properties;
+  const { dcoffset = -0.5, depth = 1 } = properties;
+  const lfoprops = {
+    frequency: 1,
+    depth,
+    skew: 0.5,
+    phaseoffset: 0,
+    time: begin,
+    begin,
+    end,
+    shape: getModulationShapeInput(shape),
+    dcoffset,
+    min: dcoffset * depth,
+    max: dcoffset * depth + depth,
+    curve: 1,
+    ...props,
+  };
+
+  return getWorklet(audioContext, 'lfo-processor', lfoprops);
+}
+
 export function getCompressor(ac, threshold, ratio, knee, attack, release) {
   const options = {
     threshold: threshold ?? -3,
@@ -112,6 +154,41 @@ 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)];
 };
 
+// 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;
+
+  if (amount == null) {
+    const hasADSRParams = values.some((p) => p != null);
+    amount = hasADSRParams ? defaultAmount : 0;
+  }
+
+  const min = offset ?? 0;
+  const max = amount + min;
+  const diff = Math.abs(max - min);
+  if (diff) {
+    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);
+  }
+
+  return { lfo, disconnect: () => lfo?.disconnect() };
+}
+
 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]);
@@ -171,7 +248,7 @@ let curves = ['linear', 'exponential'];
 export function getPitchEnvelope(param, value, t, holdEnd) {
   // envelope is active when any of these values is set
   const hasEnvelope = value.pattack ?? value.pdecay ?? value.psustain ?? value.prelease ?? value.penv;
-  if (!hasEnvelope) {
+  if (hasEnvelope === undefined) {
     return;
   }
   const penv = nanFallback(value.penv, 1, true);
@@ -206,19 +283,46 @@ export function getVibratoOscillator(param, value, t) {
 // ConstantSource inherits AudioScheduledSourceNode, which has scheduling abilities
 // a bit of a hack, but it works very well :)
 export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
-  const constantNode = audioContext.createConstantSource();
-  constantNode.start(startTime);
-  constantNode.stop(stopTime);
+  const constantNode = new ConstantSourceNode(audioContext);
+
+  // Certain browsers requires audio nodes to be connected in order for their onended events
+  // to fire, so we _mute it_ and then connect it to the destination
+  const zeroGain = gainNode(0);
+  zeroGain.connect(audioContext.destination);
+  constantNode.connect(zeroGain);
+
+  // Schedule the `onComplete` callback to occur at `stopTime`
   constantNode.onended = () => {
+    // Ensure garbage collection
+    try {
+      zeroGain.disconnect();
+    } catch {
+      // pass
+    }
+    try {
+      constantNode.disconnect();
+    } catch {
+      // pass
+    }
     onComplete();
   };
+  constantNode.start(startTime);
+  constantNode.stop(stopTime);
   return constantNode;
 }
 const mod = (freq, range = 1, type = 'sine') => {
   const ctx = getAudioContext();
-  const osc = ctx.createOscillator();
-  osc.type = type;
-  osc.frequency.value = freq;
+  let osc;
+  if (noises.includes(type)) {
+    osc = ctx.createBufferSource();
+    osc.buffer = getNoiseBuffer(type, 2);
+    osc.loop = true;
+  } else {
+    osc = ctx.createOscillator();
+    osc.type = type;
+    osc.frequency.value = freq;
+  }
+
   osc.start();
   const g = new GainNode(ctx, { gain: range });
   osc.connect(g); // -range, range
@@ -253,7 +357,7 @@ export function applyFM(param, value, begin) {
 
     modulator = fmmod.node;
     stop = fmmod.stop;
-    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
+    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].some((v) => v !== undefined)) {
       // no envelope by default
       modulator.connect(param);
     } else {
@@ -277,3 +381,121 @@ export function applyFM(param, value, begin) {
   }
   return { stop };
 }
+
+// Saturation curves
+
+const __squash = (x) => x / (1 + x); // [0, inf) to [0, 1)
+const _mod = (n, m) => ((n % m) + m) % m;
+
+const _scurve = (x, k) => ((1 + k) * x) / (1 + k * Math.abs(x));
+const _soft = (x, k) => Math.tanh(x * (1 + k));
+const _hard = (x, k) => clamp((1 + k) * x, -1, 1);
+
+const _fold = (x, k) => {
+  // Closed form folding for audio rate
+  let y = (1 + 0.5 * k) * x;
+  const window = _mod(y + 1, 4);
+  return 1 - Math.abs(window - 2);
+};
+
+const _sineFold = (x, k) => Math.sin((Math.PI / 2) * _fold(x, k));
+
+const _cubic = (x, k) => {
+  const t = __squash(Math.log1p(k));
+  const cubic = (x - (t / 3) * x * x * x) / (1 - t / 3); // normalized to go from (-1, 1)
+  return _soft(cubic, k);
+};
+
+const _diode = (x, k, asym = false) => {
+  const g = 1 + 2 * k; // gain
+  const t = __squash(Math.log1p(k));
+  const bias = 0.07 * t;
+  const pos = _soft(x + bias, 2 * k);
+  const neg = _soft(asym ? bias : -x + bias, 2 * k);
+  const y = pos - neg;
+  // We divide by the derivative at 0 so that the distortion is roughly
+  // the identity map near 0 => small values are preserved and undistorted
+  const sech = 1 / Math.cosh(g * bias);
+  const sech2 = sech * sech; // derivative of soft (i.e. tanh) is sech^2
+  const denom = Math.max(1e-8, (asym ? 1 : 2) * g * sech2); // g from chain rule; 2 if both pos/neg have x
+  return _soft(y / denom, k);
+};
+
+const _asym = (x, k) => _diode(x, k, true);
+
+const _chebyshev = (x, k) => {
+  const kl = 10 * Math.log1p(k);
+  let tnm1 = 1;
+  let tnm2 = x;
+  let tn;
+  let y = 0;
+  for (let i = 1; i < 64; i++) {
+    if (i < 2) {
+      // Already set inital conditions
+      y += i == 0 ? tnm1 : tnm2;
+      continue;
+    }
+    tn = 2 * x * tnm1 - tnm2; // https://en.wikipedia.org/wiki/Chebyshev_polynomials#Recurrence_definition
+    tnm2 = tnm1;
+    tnm1 = tn;
+    if (i % 2 === 0) {
+      y += Math.min((1.3 * kl) / i, 2) * tn;
+    }
+  }
+  // Soft clip
+  return _soft(y, kl / 20);
+};
+
+export const distortionAlgorithms = {
+  scurve: _scurve,
+  soft: _soft,
+  hard: _hard,
+  cubic: _cubic,
+  diode: _diode,
+  asym: _asym,
+  fold: _fold,
+  sinefold: _sineFold,
+  chebyshev: _chebyshev,
+};
+const _algoNames = Object.freeze(Object.keys(distortionAlgorithms));
+
+export const getDistortionAlgorithm = (algo) => {
+  let index = algo;
+  if (typeof algo === 'string') {
+    index = _algoNames.indexOf(algo);
+    if (index === -1) {
+      logger(`[superdough] Could not find waveshaping algorithm ${algo}.
+        Available options are ${_algoNames.join(', ')}.
+        Defaulting to ${_algoNames[0]}.`);
+      index = 0;
+    }
+  }
+  const name = _algoNames[index % _algoNames.length]; // allow for wrapping if algo was a number
+  return distortionAlgorithms[name];
+};
+
+export const getDistortion = (distort, postgain, algorithm) => {
+  return getWorklet(getAudioContext(), 'distort-processor', { distort, postgain }, { processorOptions: { algorithm } });
+};
+
+export const getFrequencyFromValue = (value, defaultNote = 36) => {
+  let { note, freq } = value;
+  note = note || defaultNote;
+  if (typeof note === 'string') {
+    note = noteToMidi(note); // e.g. c3 => 48
+  }
+  // get frequency
+  if (!freq && typeof note === 'number') {
+    freq = midiToFreq(note); // + 48);
+  }
+
+  return Number(freq);
+};
+
+export const destroyAudioWorkletNode = (node) => {
+  if (node == null) {
+    return;
+  }
+  node.disconnect();
+  node.parameters.get('end')?.setValueAtTime(0, 0);
+};

packages/superdough/index.mjs

@@ -11,3 +11,5 @@ export * from './synth.mjs';
 export * from './zzfx.mjs';
 export * from './logger.mjs';
 export * from './dspworklet.mjs';
+export * from './audioContext.mjs';
+export * from './wavetable.mjs';

packages/superdough/logger.mjs

@@ -1,5 +1,12 @@
 let log = (msg) => console.log(msg);
 
+export function errorLogger(e, origin = 'superdough') {
+  if (process.env.NODE_ENV === 'development') {
+    console.error(e);
+  }
+  logger(`[${origin}] error: ${e.message}`);
+}
+
 export const logger = (...args) => log(...args);
 
 export const setLogger = (fn) => {

packages/superdough/noise.mjs

@@ -1,10 +1,10 @@
 import { drywet } from './helpers.mjs';
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 
 let noiseCache = {};
 
 // lazy generates noise buffers and keeps them forever
-function getNoiseBuffer(type, density) {
+export function getNoiseBuffer(type, density) {
   const ac = getAudioContext();
   if (noiseCache[type]) {
     return noiseCache[type];

packages/superdough/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superdough",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "simple web audio synth and sampler intended for live coding. inspired by superdirt and webdirt.",
   "main": "index.mjs",
   "type": "module",

packages/superdough/reverb.mjs

@@ -1,7 +1,9 @@
 import reverbGen from './reverbGen.mjs';
+import { clamp } from './util.mjs';
 
 if (typeof AudioContext !== 'undefined') {
-  AudioContext.prototype.adjustLength = function (duration, buffer) {
+  AudioContext.prototype.adjustLength = function (duration, buffer, speed = 1, offsetAmount = 0) {
+    const sampleOffset = Math.floor(clamp(offsetAmount, 0, 1) * buffer.length);
     const newLength = buffer.sampleRate * duration;
     const newBuffer = this.createBuffer(buffer.numberOfChannels, buffer.length, buffer.sampleRate);
     for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
@@ -9,22 +11,30 @@ if (typeof AudioContext !== 'undefined') {
       let newData = newBuffer.getChannelData(channel);
 
       for (let i = 0; i < newLength; i++) {
-        newData[i] = oldData[i] || 0;
+        // loop the buffer around to prevent
+        let position = (sampleOffset + i * Math.abs(speed)) % oldData.length;
+        if (speed < 1) {
+          position = position * -1;
+        }
+
+        newData[i] = oldData.at(position) || 0;
       }
     }
     return newBuffer;
   };
 
-  AudioContext.prototype.createReverb = function (duration, fade, lp, dim, ir) {
+  AudioContext.prototype.createReverb = function (duration, fade, lp, dim, ir, irspeed, irbegin) {
     const convolver = this.createConvolver();
-    convolver.generate = (d = 2, fade = 0.1, lp = 15000, dim = 1000, ir) => {
+    convolver.generate = (d = 2, fade = 0.1, lp = 15000, dim = 1000, ir, irspeed, irbegin) => {
       convolver.duration = d;
       convolver.fade = fade;
       convolver.lp = lp;
       convolver.dim = dim;
       convolver.ir = ir;
+      convolver.irspeed = irspeed;
+      convolver.irbegin = irbegin;
       if (ir) {
-        convolver.buffer = this.adjustLength(d, ir);
+        convolver.buffer = this.adjustLength(d, ir, irspeed, irbegin);
       } else {
         reverbGen.generateReverb(
           {
@@ -41,7 +51,7 @@ if (typeof AudioContext !== 'undefined') {
         );
       }
     };
-    convolver.generate(duration, fade, lp, dim, ir);
+    convolver.generate(duration, fade, lp, dim, ir, irspeed, irbegin);
     return convolver;
   };
 }

packages/superdough/sampler.mjs

@@ -1,5 +1,6 @@
-import { noteToMidi, valueToMidi, getSoundIndex } from './util.mjs';
-import { getAudioContext, registerSound } from './index.mjs';
+import { getCommonSampleInfo } from './util.mjs';
+import { registerSound, registerWaveTable } from './index.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import { getADSRValues, getParamADSR, getPitchEnvelope, getVibratoOscillator } from './helpers.mjs';
 import { logger } from './logger.mjs';
 
@@ -22,39 +23,16 @@ function humanFileSize(bytes, si) {
   return bytes.toFixed(1) + ' ' + units[u];
 }
 
-// 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 getSampleInfo(hapValue, bank) {
-  const { s, n = 0, speed = 1.0 } = hapValue;
-  let midi = valueToMidi(hapValue, 36);
-  let transpose = midi - 36; // C3 is middle C;
-  let sampleUrl;
-  let index = 0;
-  if (Array.isArray(bank)) {
-    index = getSoundIndex(n, bank.length);
-    sampleUrl = bank[index];
-  } else {
-    const midiDiff = (noteA) => noteToMidi(noteA) - midi;
-    // object format will expect keys as notes
-    const closest = Object.keys(bank)
-      .filter((k) => !k.startsWith('_'))
-      .reduce(
-        (closest, key, j) => (!closest || Math.abs(midiDiff(key)) < Math.abs(midiDiff(closest)) ? key : closest),
-        null,
-      );
-    transpose = -midiDiff(closest); // semitones to repitch
-    index = getSoundIndex(n, bank[closest].length);
-    sampleUrl = bank[closest][index];
-  }
-  const label = `${s}:${index}`;
+  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, sampleUrl, index, midi, label, playbackRate };
+  return { transpose, url, index, midi, label, playbackRate };
 }
 
 // takes hapValue and returns buffer + playbackRate.
 export const getSampleBuffer = async (hapValue, bank, resolveUrl) => {
-  let { sampleUrl, label, playbackRate } = getSampleInfo(hapValue, bank);
+  let { url: sampleUrl, label, playbackRate } = getSampleInfo(hapValue, bank);
   if (resolveUrl) {
     sampleUrl = await resolveUrl(sampleUrl);
   }
@@ -79,14 +57,14 @@ export const getSampleBufferSource = async (hapValue, bank, resolveUrl) => {
   bufferSource.buffer = buffer;
   bufferSource.playbackRate.value = playbackRate;
 
-  const { s, loopBegin = 0, loopEnd = 1, begin = 0, end = 1 } = hapValue;
+  const { loopBegin = 0, loopEnd = 1, begin = 0, end = 1 } = hapValue;
 
   // "The computation of the offset into the sound is performed using the sound buffer's natural sample rate,
   // rather than the current playback rate, so even if the sound is playing at twice its normal speed,
   // the midway point through a 10-second audio buffer is still 5."
   const offset = begin * bufferSource.buffer.duration;
 
-  const loop = s.startsWith('wt_') ? 1 : hapValue.loop;
+  const loop = hapValue.loop;
   if (loop) {
     bufferSource.loop = true;
     bufferSource.loopStart = loopBegin * bufferSource.buffer.duration - offset;
@@ -196,6 +174,52 @@ function getSamplesPrefixHandler(url) {
   return;
 }
 
+export async function fetchSampleMap(url) {
+  // check if custom prefix handler
+  const handler = getSamplesPrefixHandler(url);
+  if (handler) {
+    return handler(url);
+  }
+  url = resolveSpecialPaths(url);
+  if (url.startsWith('github:')) {
+    url = githubPath(url, 'strudel.json');
+  }
+  if (url.startsWith('local:')) {
+    url = `http://localhost:5432`;
+  }
+  if (url.startsWith('shabda:')) {
+    let [_, path] = url.split('shabda:');
+    url = `https://shabda.ndre.gr/${path}.json?strudel=1`;
+  }
+  if (url.startsWith('shabda/speech')) {
+    let [_, path] = url.split('shabda/speech');
+    path = path.startsWith('/') ? path.substring(1) : path;
+    let [params, words] = path.split(':');
+    let gender = 'f';
+    let language = 'en-GB';
+    if (params) {
+      [language, gender] = params.split('/');
+    }
+    url = `https://shabda.ndre.gr/speech/${words}.json?gender=${gender}&language=${language}&strudel=1'`;
+  }
+  if (typeof fetch !== 'function') {
+    // not a browser
+    return;
+  }
+  const base = url.split('/').slice(0, -1).join('/');
+  if (typeof fetch === 'undefined') {
+    // skip fetch when in node / testing
+    return;
+  }
+  const json = await fetch(url)
+    .then((res) => res.json())
+    .catch((error) => {
+      console.error(error);
+      throw new Error(`error loading "${url}"`);
+    });
+  return [json, json._base || base];
+}
+
 /**
  * Loads a collection of samples to use with `s`
  * @example
@@ -217,61 +241,16 @@ function getSamplesPrefixHandler(url) {
 
 export const samples = async (sampleMap, baseUrl = sampleMap._base || '', options = {}) => {
   if (typeof sampleMap === 'string') {
-    // check if custom prefix handler
-    const handler = getSamplesPrefixHandler(sampleMap);
-    if (handler) {
-      return handler(sampleMap);
-    }
-    sampleMap = resolveSpecialPaths(sampleMap);
-    if (sampleMap.startsWith('github:')) {
-      sampleMap = githubPath(sampleMap, 'strudel.json');
-    }
-    if (sampleMap.startsWith('local:')) {
-      sampleMap = `http://localhost:5432`;
-    }
-    if (sampleMap.startsWith('shabda:')) {
-      let [_, path] = sampleMap.split('shabda:');
-      sampleMap = `https://shabda.ndre.gr/${path}.json?strudel=1`;
-    }
-    if (sampleMap.startsWith('shabda/speech')) {
-      let [_, path] = sampleMap.split('shabda/speech');
-      path = path.startsWith('/') ? path.substring(1) : path;
-      let [params, words] = path.split(':');
-      let gender = 'f';
-      let language = 'en-GB';
-      if (params) {
-        [language, gender] = params.split('/');
-      }
-      sampleMap = `https://shabda.ndre.gr/speech/${words}.json?gender=${gender}&language=${language}&strudel=1'`;
-    }
-    if (typeof fetch !== 'function') {
-      // not a browser
-      return;
-    }
-    const base = sampleMap.split('/').slice(0, -1).join('/');
-    if (typeof fetch === 'undefined') {
-      // skip fetch when in node / testing
-      return;
-    }
-    return fetch(sampleMap)
-      .then((res) => res.json())
-      .then((json) => samples(json, baseUrl || json._base || base, options))
-      .catch((error) => {
-        console.error(error);
-        throw new Error(`error loading "${sampleMap}"`);
-      });
+    const [json, base] = await fetchSampleMap(sampleMap);
+    return samples(json, baseUrl || base, options);
   }
   const { prebake, tag } = options;
+
   processSampleMap(
     sampleMap,
-    (key, bank) =>
-      registerSound(key, (t, hapValue, onended) => onTriggerSample(t, hapValue, onended, bank), {
-        type: 'sample',
-        samples: bank,
-        baseUrl,
-        prebake,
-        tag,
-      }),
+    (key, bank) => {
+      registerSampleSource(key, bank, { baseUrl, prebake, tag });
+    },
     baseUrl,
   );
 };
@@ -361,3 +340,20 @@ export async function onTriggerSample(t, value, onended, bank, resolveUrl) {
 
   return handle;
 }
+
+function registerSample(key, bank, params) {
+  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) {
+    registerWaveTable(key, bank, params);
+  } else {
+    registerSample(key, bank, params);
+  }
+}

packages/superdough/superdough.mjs

@@ -7,12 +7,14 @@ 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 { clamp, nanFallback, _mod, cycleToSeconds, secondsToCycle } from './util.mjs';
+import { nanFallback, _mod, cycleToSeconds } from './util.mjs';
 import workletsUrl from './worklets.mjs?audioworklet';
-import { createFilter, gainNode, getCompressor, getWorklet } from './helpers.mjs';
+import { createFilter, gainNode, getCompressor, getDistortion, getLfo, getWorklet, effectSend } from './helpers.mjs';
 import { map } from 'nanostores';
 import { logger } from './logger.mjs';
 import { loadBuffer } from './sampler.mjs';
+import { getAudioContext } from './audioContext.mjs';
+import { SuperdoughAudioController } from './superdoughoutput.mjs';
 
 export const DEFAULT_MAX_POLYPHONY = 128;
 const DEFAULT_AUDIO_DEVICE_NAME = 'System Standard';
@@ -28,13 +30,6 @@ export function setMultiChannelOrbits(bool) {
   multiChannelOrbits = bool == true;
 }
 
-function getModulationShapeInput(val) {
-  if (typeof val === 'number') {
-    return val % 5;
-  }
-  return { tri: 0, triangle: 0, sine: 1, ramp: 2, saw: 3, square: 4 }[val] ?? 0;
-}
-
 export const soundMap = map();
 
 export function registerSound(key, onTrigger, data = {}) {
@@ -113,6 +108,19 @@ export async function aliasBank(...args) {
   }
 }
 
+/**
+ * Register an alias for a sound.
+ * @param {string} original - The original sound name
+ * @param {string} alias - The alias to use for the sound
+ */
+export function soundAlias(original, alias) {
+  if (getSound(original) == null) {
+    logger('soundAlias: original sound not found');
+    return;
+  }
+  soundMap.setKey(alias, getSound(original));
+}
+
 export function getSound(s) {
   if (typeof s !== 'string') {
     console.warn(`getSound: expected string got "${s}". fall back to triangle`);
@@ -147,6 +155,7 @@ let defaultDefaultValues = {
   phaserdepth: 0.75,
   shapevol: 1,
   distortvol: 1,
+  distorttype: 0,
   delay: 0,
   byteBeatExpression: '0',
   delayfeedback: 0.5,
@@ -193,30 +202,17 @@ export function setVersionDefaults(version) {
 
 export const resetLoadedSounds = () => soundMap.set({});
 
-let audioContext;
-
-export const setDefaultAudioContext = () => {
-  audioContext = new AudioContext();
-  return audioContext;
-};
-
-export const getAudioContext = () => {
-  if (!audioContext) {
-    return setDefaultAudioContext();
-  }
-
-  return audioContext;
-};
-
-export function getAudioContextCurrentTime() {
-  return getAudioContext().currentTime;
+let externalWorklets = [];
+export function registerWorklet(url) {
+  externalWorklets.push(url);
 }
 
 let workletsLoading;
 function loadWorklets() {
   if (!workletsLoading) {
     const audioCtx = getAudioContext();
-    workletsLoading = audioCtx.audioWorklet.addModule(workletsUrl);
+    const allWorkletURLs = externalWorklets.concat([workletsUrl]);
+    workletsLoading = Promise.all(allWorkletURLs.map((workletURL) => audioCtx.audioWorklet.addModule(workletURL)));
   }
 
   return workletsLoading;
@@ -282,103 +278,16 @@ export async function initAudioOnFirstClick(options) {
   return audioReady;
 }
 
-let delays = {};
-const maxfeedback = 0.98;
-
-let channelMerger, destinationGain;
-//update the output channel configuration to match user's audio device
-export function initializeAudioOutput() {
-  const audioContext = getAudioContext();
-  const maxChannelCount = audioContext.destination.maxChannelCount;
-  audioContext.destination.channelCount = maxChannelCount;
-  channelMerger = new ChannelMergerNode(audioContext, { numberOfInputs: audioContext.destination.channelCount });
-  destinationGain = new GainNode(audioContext);
-  channelMerger.connect(destinationGain);
-  destinationGain.connect(audioContext.destination);
+let controller;
+function getSuperdoughAudioController() {
+  if (controller == null) {
+    controller = new SuperdoughAudioController(getAudioContext());
+  }
+  return controller;
 }
-
-// input: AudioNode, channels: ?Array<int>
-export const connectToDestination = (input, channels = [0, 1]) => {
-  const ctx = getAudioContext();
-  if (channelMerger == null) {
-    initializeAudioOutput();
-  }
-  //This upmix can be removed if correct channel counts are set throughout the app,
-  // and then strudel could theoretically support surround sound audio files
-  const stereoMix = new StereoPannerNode(ctx);
-  input.connect(stereoMix);
-
-  const splitter = new ChannelSplitterNode(ctx, {
-    numberOfOutputs: stereoMix.channelCount,
-  });
-  stereoMix.connect(splitter);
-  channels.forEach((ch, i) => {
-    splitter.connect(channelMerger, i % stereoMix.channelCount, ch % ctx.destination.channelCount);
-  });
-};
-
-export const panic = () => {
-  if (destinationGain == null) {
-    return;
-  }
-  destinationGain.gain.linearRampToValueAtTime(0, getAudioContext().currentTime + 0.01);
-  destinationGain = null;
-  channelMerger == null;
-};
-
-function getDelay(orbit, delaytime, delayfeedback, t, channels) {
-  if (delayfeedback > maxfeedback) {
-    //logger(`delayfeedback was clamped to ${maxfeedback} to save your ears`);
-  }
-  delayfeedback = clamp(delayfeedback, 0, 0.98);
-  if (!delays[orbit]) {
-    const ac = getAudioContext();
-    const dly = ac.createFeedbackDelay(1, delaytime, delayfeedback);
-    dly.start?.(t); // for some reason, this throws when audion extension is installed..
-    connectToDestination(dly, channels);
-    delays[orbit] = dly;
-  }
-  delays[orbit].delayTime.value !== delaytime && delays[orbit].delayTime.setValueAtTime(delaytime, t);
-  delays[orbit].feedback.value !== delayfeedback && delays[orbit].feedback.setValueAtTime(delayfeedback, t);
-  return delays[orbit];
-}
-
-export function getLfo(audioContext, begin, end, properties = {}) {
-  const { shape = 0, ...props } = properties;
-  const { dcoffset = -0.5, depth = 1 } = properties;
-  const lfoprops = {
-    frequency: 1,
-    depth,
-    skew: 0.5,
-    phaseoffset: 0,
-    time: begin,
-    begin,
-    end,
-    shape: getModulationShapeInput(shape),
-    dcoffset,
-    min: dcoffset * depth,
-    max: dcoffset * depth + depth,
-    curve: 1,
-    ...props,
-  };
-
-  return getWorklet(audioContext, 'lfo-processor', lfoprops);
-}
-
-export function getSyncedLfo(audioContext, time, end, cps, cycle, properties = {}) {
-  const frequency = cycle / cps;
-
-  return getWorklet(audioContext, 'lfo-processor', {
-    frequency,
-    depth: 1,
-    skew: 0,
-    phaseoffset: 0,
-    time,
-    end,
-    shape: 1,
-    dcoffset: -0.5,
-    ...properties,
-  });
+export function connectToDestination(input, channels) {
+  const controller = getSuperdoughAudioController();
+  controller.output.connectToDestination(input, channels);
 }
 
 function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000, sweep = 2000) {
@@ -412,33 +321,6 @@ function getFilterType(ftype) {
   return typeof ftype === 'number' ? filterTypes[Math.floor(_mod(ftype, filterTypes.length))] : ftype;
 }
 
-let reverbs = {};
-let hasChanged = (now, before) => now !== undefined && now !== before;
-function getReverb(orbit, duration, fade, lp, dim, ir, channels) {
-  // If no reverb has been created for a given orbit, create one
-  if (!reverbs[orbit]) {
-    const ac = getAudioContext();
-    const reverb = ac.createReverb(duration, fade, lp, dim, ir);
-    connectToDestination(reverb, channels);
-    reverbs[orbit] = reverb;
-  }
-  if (
-    hasChanged(duration, reverbs[orbit].duration) ||
-    hasChanged(fade, reverbs[orbit].fade) ||
-    hasChanged(lp, reverbs[orbit].lp) ||
-    hasChanged(dim, reverbs[orbit].dim) ||
-    reverbs[orbit].ir !== ir
-  ) {
-    // only regenerate when something has changed
-    // avoids endless regeneration on things like
-    // stack(s("a"), s("b").rsize(8)).room(.5)
-    // this only works when args may stay undefined until here
-    // setting default values breaks this
-    reverbs[orbit].generate(duration, fade, lp, dim, ir);
-  }
-  return reverbs[orbit];
-}
-
 export let analysers = {},
   analysersData = {};
 
@@ -471,16 +353,8 @@ export function getAnalyzerData(type = 'time', id = 1) {
   return analysersData[id];
 }
 
-function effectSend(input, effect, wet) {
-  const send = gainNode(wet);
-  input.connect(send);
-  send.connect(effect);
-  return send;
-}
-
 export function resetGlobalEffects() {
-  delays = {};
-  reverbs = {};
+  controller?.reset();
   analysers = {};
   analysersData = {};
 }
@@ -495,6 +369,7 @@ function mapChannelNumbers(channels) {
 export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5) => {
   // new: t is always expected to be the absolute target onset time
   const ac = getAudioContext();
+  const audioController = getSuperdoughAudioController();
 
   let { stretch } = value;
   if (stretch != null) {
@@ -533,6 +408,11 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
     gain = getDefaultValue('gain'),
     postgain = getDefaultValue('postgain'),
     density = getDefaultValue('density'),
+    duckorbit,
+    duckonset,
+    duckattack,
+    duckdepth,
+    djf,
     // filters
     fanchor = getDefaultValue('fanchor'),
     drive = 0.69,
@@ -571,10 +451,12 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
     coarse,
 
     crush,
+    dry,
     shape,
     shapevol = getDefaultValue('shapevol'),
     distort,
     distortvol = getDefaultValue('distortvol'),
+    distorttype = getDefaultValue('distorttype'),
     pan,
     vowel,
     delay = getDefaultValue('delay'),
@@ -588,6 +470,8 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
     roomdim,
     roomsize,
     ir,
+    irspeed,
+    irbegin,
     i = getDefaultValue('i'),
     velocity = getDefaultValue('velocity'),
     analyze, // analyser wet
@@ -604,7 +488,12 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
   const orbitChannels = mapChannelNumbers(
     multiChannelOrbits && orbit > 0 ? [orbit * 2 - 1, orbit * 2] : getDefaultValue('channels'),
   );
+
   const channels = value.channels != null ? mapChannelNumbers(value.channels) : orbitChannels;
+  const orbitBus = audioController.getOrbit(orbit, channels);
+  if (duckorbit != null) {
+    audioController.duck(duckorbit, t, duckonset, duckattack, duckdepth);
+  }
 
   gain = applyGainCurve(nanFallback(gain, 1));
   postgain = applyGainCurve(postgain);
@@ -650,7 +539,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
       audioNodes.forEach((n) => n?.disconnect());
       activeSoundSources.delete(chainID);
     };
-    const soundHandle = await onTrigger(t, value, onEnded);
+    const soundHandle = await onTrigger(t, value, onEnded, cps);
 
     if (soundHandle) {
       sourceNode = soundHandle.node;
@@ -741,13 +630,20 @@ 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(getWorklet(ac, 'distort-processor', { distort, postgain: distortvol }));
+  distort !== undefined && chain.push(getDistortion(distort, distortvol, distorttype));
 
   if (tremolosync != null) {
     tremolo = cps * tremolosync;
   }
 
+  if (value.wtPosSynced != null) {
+    value.wtPosRate /= cps;
+  }
+
+  if (value.wtWarpSynced != null) {
+    value.wtWarpRate /= cps;
+  }
+
   if (tremolo !== undefined) {
     // Allow clipping of modulator for more dynamic possiblities, and to prevent speaker overload
     // EX:  a triangle waveform will clip like this /-\ when the depth is above 1
@@ -791,17 +687,13 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
   // last gain
   const post = new GainNode(ac, { gain: postgain });
   chain.push(post);
-  connectToDestination(post, channels);
 
   // delay
-  let delaySend;
   if (delay > 0 && delaytime > 0 && delayfeedback > 0) {
-    const delayNode = getDelay(orbit, delaytime, delayfeedback, t, orbitChannels);
-    delaySend = effectSend(post, delayNode, delay);
-    audioNodes.push(delaySend);
+    orbitBus.getDelay(delaytime, delayfeedback, t);
+    orbitBus.sendDelay(post, delay);
   }
   // reverb
-  let reverbSend;
   if (room > 0) {
     let roomIR;
     if (ir !== undefined) {
@@ -814,18 +706,28 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
       }
       roomIR = await loadBuffer(url, ac, ir, 0);
     }
-    const reverbNode = getReverb(orbit, roomsize, roomfade, roomlp, roomdim, roomIR, orbitChannels);
-    reverbSend = effectSend(post, reverbNode, room);
-    audioNodes.push(reverbSend);
+    orbitBus.getReverb(roomsize, roomfade, roomlp, roomdim, roomIR, irspeed, irbegin);
+    orbitBus.sendReverb(post, room);
+  }
+
+  if (djf != null) {
+    orbitBus.getDjf(djf, t);
   }
 
   // analyser
-  let analyserSend;
   if (analyze) {
     const analyserNode = getAnalyserById(analyze, 2 ** (fft + 5));
-    analyserSend = effectSend(post, analyserNode, 1);
+    const analyserSend = effectSend(post, analyserNode, 1);
     audioNodes.push(analyserSend);
   }
+  if (dry != null) {
+    dry = applyGainCurve(dry);
+    const dryGain = new GainNode(ac, { gain: dry });
+    chain.push(dryGain);
+    orbitBus.connectToOutput(dryGain);
+  } else {
+    orbitBus.connectToOutput(post);
+  }
 
   // connect chain elements together
   chain.slice(1).reduce((last, current) => last.connect(current), chain[0]);

packages/superdough/superdoughoutput.mjs

@@ -0,0 +1,209 @@
+import { effectSend, getWorklet, webAudioTimeout } from './helpers.mjs';
+import { errorLogger } from './logger.mjs';
+import { clamp } from './util.mjs';
+
+let hasChanged = (now, before) => now !== undefined && now !== before;
+
+export class Orbit {
+  reverbNode;
+  delayNode;
+  output;
+  summingNode;
+  djfNode;
+  audioContext;
+  constructor(audioContext) {
+    this.audioContext = audioContext;
+    this.output = new GainNode(audioContext, { gain: 1, channelCount: 2, channelCountMode: 'explicit' });
+    this.summingNode = new GainNode(audioContext, { gain: 1, channelCount: 2, channelCountMode: 'explicit' });
+    this.summingNode.connect(this.output);
+  }
+
+  disconnect() {
+    this.output.disconnect();
+    this.summingNode.disconnect();
+    this.delayNode?.disconnect();
+    this.reverbNode?.disconnect();
+  }
+
+  getDjf(value, t = 0) {
+    if (this.djfNode == null) {
+      this.djfNode = getWorklet(this.audioContext, 'djf-processor', { value });
+      this.summingNode.disconnect();
+      this.summingNode.connect(this.djfNode);
+      this.djfNode.connect(this.output);
+    }
+    const val = this.djfNode.parameters.get('value');
+    val.setValueAtTime(value, t);
+  }
+
+  getDelay(delaytime = 0, feedback = 0.5, t) {
+    const maxfeedback = 0.98;
+    if (feedback > maxfeedback) {
+      //logger(`feedback was clamped to ${maxfeedback} to save your ears`);
+    }
+    feedback = clamp(feedback, 0, 0.98);
+    if (this.delayNode == null) {
+      this.delayNode = this.audioContext.createFeedbackDelay(1, delaytime, feedback);
+      this.delayNode.connect(this.summingNode);
+      this.delayNode.start?.(t); // for some reason, this throws when audion extension is installed..
+    }
+    this.delayNode.delayTime.value !== delaytime && this.delayNode.delayTime.setValueAtTime(delaytime, t);
+    this.delayNode.feedback.value !== feedback && this.delayNode.feedback.setValueAtTime(feedback, t);
+    return this.delayNode;
+  }
+
+  getReverb(duration, fade, lp, dim, ir, irspeed, irbegin) {
+    // If no reverb has been created for a given orbit, create one
+    if (this.reverbNode == null) {
+      this.reverbNode = this.audioContext.createReverb(duration, fade, lp, dim, ir, irspeed, irbegin);
+      this.reverbNode.connect(this.summingNode);
+    }
+
+    if (
+      hasChanged(duration, this.reverbNode.duration) ||
+      hasChanged(fade, this.reverbNode.fade) ||
+      hasChanged(lp, this.reverbNode.lp) ||
+      hasChanged(dim, this.reverbNode.dim) ||
+      hasChanged(irspeed, this.reverbNode.irspeed) ||
+      hasChanged(irbegin, this.reverbNode.irbegin) ||
+      this.reverbNode.ir !== ir
+    ) {
+      // only regenerate when something has changed
+      // avoids endless regeneration on things like
+      // stack(s("a"), s("b").rsize(8)).room(.5)
+      // this only works when args may stay undefined until here
+      // setting default values breaks this
+      this.reverbNode.generate(duration, fade, lp, dim, ir, irspeed, irbegin);
+    }
+    return this.reverbNode;
+  }
+  sendReverb(node, amount) {
+    effectSend(node, this.reverbNode, amount);
+  }
+
+  sendDelay(node, amount) {
+    effectSend(node, this.delayNode, amount);
+  }
+
+  duck(t, onsettime = 0, attacktime = 0.1, depth = 1) {
+    const onset = onsettime;
+    const attack = Math.max(attacktime, 0.002);
+    const gainParam = this.output.gain;
+    webAudioTimeout(
+      this.audioContext,
+      () => {
+        const now = this.audioContext.currentTime;
+
+        // cancelScheduledValues and setValueAtTime together emulate cancelAndHoldAtTime
+        // on browsers which lack that method
+        const currVal = gainParam.value;
+        gainParam.cancelScheduledValues(now);
+        gainParam.setValueAtTime(currVal, now);
+
+        const t0 = Math.max(t, now); // guard against now > t
+        const duckedVal = clamp(1 - Math.sqrt(depth), 0.01, currVal);
+        gainParam.exponentialRampToValueAtTime(duckedVal, t0 + onset);
+        gainParam.exponentialRampToValueAtTime(1, t0 + onset + attack);
+      },
+      0,
+      t - 0.01,
+    );
+  }
+
+  connectToOutput(node) {
+    node.connect(this.summingNode);
+  }
+}
+
+export class SuperdoughOutput {
+  channelMerger;
+  destinationGain;
+
+  constructor(audioContext) {
+    this.audioContext = audioContext;
+    this.initializeAudio();
+  }
+
+  initializeAudio() {
+    const audioContext = this.audioContext;
+    const maxChannelCount = audioContext.destination.maxChannelCount;
+    this.audioContext.destination.channelCount = maxChannelCount;
+    this.channelMerger = new ChannelMergerNode(audioContext, { numberOfInputs: audioContext.destination.channelCount });
+    this.destinationGain = new GainNode(audioContext);
+    this.channelMerger.connect(this.destinationGain);
+    this.destinationGain.connect(audioContext.destination);
+  }
+
+  reset() {
+    this.disconnect();
+    this.initializeAudio();
+  }
+  disconnect() {
+    this.channelMerger.disconnect();
+    this.destinationGain.disconnect();
+    this.destinationGain = null;
+    this.channelMerger = null;
+  }
+  connectToDestination = (input, channels = [0, 1]) => {
+    //This upmix can be removed if correct channel counts are set throughout the app,
+    // and then strudel could theoretically support surround sound audio files
+    const stereoMix = new StereoPannerNode(this.audioContext);
+    input.connect(stereoMix);
+
+    const splitter = new ChannelSplitterNode(this.audioContext, {
+      numberOfOutputs: stereoMix.channelCount,
+    });
+    stereoMix.connect(splitter);
+    channels.forEach((ch, i) => {
+      splitter.connect(this.channelMerger, i % stereoMix.channelCount, ch % this.audioContext.destination.channelCount);
+    });
+  };
+}
+
+export class SuperdoughAudioController {
+  audioContext;
+  output;
+  nodes = {};
+
+  constructor(audioContext) {
+    this.audioContext = audioContext;
+    this.output = new SuperdoughOutput(audioContext);
+  }
+
+  reset() {
+    Array.from(this.nodes).forEach((node) => {
+      node.disconnect();
+    });
+    this.nodes = {};
+    this.output.reset();
+  }
+
+  duck(targetOrbits, t, onsettime = 0, attacktime = 0.1, depth = 1) {
+    const targetArr = [targetOrbits].flat();
+    const onsetArr = [onsettime].flat();
+    const attackArr = [attacktime].flat();
+    const depthArr = [depth].flat();
+
+    targetArr.forEach((target, idx) => {
+      const orbit = this.nodes[target];
+
+      if (orbit == null) {
+        errorLogger(new Error(`duck target orbit ${target} does not exist`), 'superdough');
+        return;
+      }
+      const onset = onsetArr[idx] ?? onsetArr[0];
+      const attack = Math.max(attackArr[idx] ?? attackArr[0], 0.002);
+      const depth = depthArr[idx] ?? depthArr[0];
+
+      orbit.duck(t, onset, attack, depth);
+    });
+  }
+
+  getOrbit(orbitNum, channels) {
+    if (this.nodes[orbitNum] == null) {
+      this.nodes[orbitNum] = new Orbit(this.audioContext);
+      this.output.connectToDestination(this.nodes[orbitNum].output, channels);
+    }
+    return this.nodes[orbitNum];
+  }
+}

packages/superdough/synth.mjs

@@ -1,38 +1,22 @@
-import { clamp, midiToFreq, noteToMidi } from './util.mjs';
-import { registerSound, getAudioContext, soundMap, getLfo } from './superdough.mjs';
+import { clamp } from './util.mjs';
+import { registerSound, soundMap } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import {
   applyFM,
+  destroyAudioWorkletNode,
   gainNode,
   getADSRValues,
+  getFrequencyFromValue,
+  getLfo,
   getParamADSR,
   getPitchEnvelope,
   getVibratoOscillator,
-  webAudioTimeout,
   getWorklet,
+  noises,
+  webAudioTimeout,
 } from './helpers.mjs';
 import { getNoiseMix, getNoiseOscillator } from './noise.mjs';
 
-const getFrequencyFromValue = (value) => {
-  let { note, freq } = value;
-  note = note || 36;
-  if (typeof note === 'string') {
-    note = noteToMidi(note); // e.g. c3 => 48
-  }
-  // get frequency
-  if (!freq && typeof note === 'number') {
-    freq = midiToFreq(note); // + 48);
-  }
-
-  return Number(freq);
-};
-function destroyAudioWorkletNode(node) {
-  if (node == null) {
-    return;
-  }
-  node.disconnect();
-  node.parameters.get('end')?.setValueAtTime(0, 0);
-}
-
 const waveforms = ['triangle', 'square', 'sawtooth', 'sine'];
 const waveformAliases = [
   ['tri', 'triangle'],
@@ -40,7 +24,17 @@ const waveformAliases = [
   ['saw', 'sawtooth'],
   ['sin', 'sine'],
 ];
-const noises = ['pink', 'white', 'brown', 'crackle'];
+
+function makeSaturationCurve(amount, n_samples) {
+  const k = typeof amount === 'number' ? amount : 50;
+  const curve = new Float32Array(n_samples);
+
+  for (let i = 0; i < n_samples; i++) {
+    const x = (i * 2) / n_samples - 1;
+    curve[i] = Math.tanh(x * k);
+  }
+  return curve;
+}
 
 export function registerSynthSounds() {
   [...waveforms].forEach((s) => {
@@ -84,6 +78,75 @@ export function registerSynthSounds() {
       { type: 'synth', prebake: true },
     );
   });
+
+  registerSound(
+    'sbd',
+    (t, value, onended) => {
+      const { duration, decay = 0.5, pdecay = 0.5, penv = 36, clip } = value;
+      const ctx = getAudioContext();
+      const attackhold = 0.02;
+      const noiselvl = 1.2;
+      const noisedecay = 0.025;
+      const mixGain = 1;
+
+      const o = ctx.createOscillator();
+      o.type = 'triangle';
+      o.frequency.value = getFrequencyFromValue(value, 29);
+      o.detune.setValueAtTime(penv * 100, 0);
+      o.detune.setValueAtTime(penv * 100, t);
+      o.detune.exponentialRampToValueAtTime(0.001, t + pdecay);
+      const g = gainNode(1);
+      g.gain.setValueAtTime(1, t + attackhold);
+      g.gain.exponentialRampToValueAtTime(0.001, t + attackhold + decay);
+      o.start(t);
+
+      const noise = getNoiseOscillator('brown', t, 2);
+      const noiseGain = gainNode(1);
+      noiseGain.gain.setValueAtTime(noiselvl, t);
+      noiseGain.gain.exponentialRampToValueAtTime(0.001, t + noisedecay);
+
+      const sat = new WaveShaperNode(ctx);
+      // tri to sine diode shaper emulation
+      sat.curve = makeSaturationCurve(2, ctx.sampleRate);
+
+      const mix = gainNode(mixGain);
+
+      o.onended = () => {
+        o.disconnect();
+        g.disconnect();
+        sat.disconnect();
+        noise.node.disconnect();
+        noiseGain.disconnect();
+        mix.disconnect();
+        onended();
+      };
+
+      const node = o.connect(sat).connect(g).connect(mix);
+      noise.node.connect(noiseGain).connect(mix);
+
+      const holdEnd = t + decay;
+      let end = holdEnd + 0.01;
+      if (clip != null) {
+        end = Math.min(t + clip * duration, end);
+      }
+
+      // prevent clicking
+      mix.gain.setValueAtTime(mixGain, end - 0.01);
+      mix.gain.linearRampToValueAtTime(0, end);
+
+      o.stop(end);
+      noise.stop(end);
+
+      return {
+        node,
+        stop: (endTime) => {
+          o.stop(endTime);
+        },
+      };
+    },
+    { type: 'synth', prebake: true },
+  );
+
   registerSound(
     'supersaw',
     (begin, value, onended) => {
@@ -121,10 +184,7 @@ export function registerSynthSounds() {
       const gainAdjustment = 1 / Math.sqrt(voices);
       getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
       const vibratoOscillator = getVibratoOscillator(o.parameters.get('detune'), value, begin);
-      // const fm = applyFM(o.parameters.get('frequency'), value, begin);
-      // https://codeberg.org/uzu/strudel/issues/1428
-      // if you think about re-enabling this, please test with fm > 1 first
-      // it's like 10x gain, so it's really dangerous
+      const fm = applyFM(o.parameters.get('frequency'), value, begin);
       let envGain = gainNode(1);
       envGain = o.connect(envGain);
 
@@ -136,7 +196,7 @@ export function registerSynthSounds() {
           destroyAudioWorkletNode(o);
           envGain.disconnect();
           onended();
-          // fm?.stop();
+          fm?.stop();
           vibratoOscillator?.stop();
         },
         begin,

packages/superdough/util.mjs

@@ -7,7 +7,7 @@ export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
   }
-  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)([0-9]*)$/)?.slice(1) || [];
+  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)(-?[0-9]*)$/)?.slice(1) || [];
   if (!pc) {
     return [];
   }
@@ -76,3 +76,32 @@ export function cycleToSeconds(cycle, cps) {
 export function secondsToCycle(t, cps) {
   return 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 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;
+  if (Array.isArray(bank)) {
+    index = getSoundIndex(n, bank.length);
+    url = bank[index];
+  } else {
+    const midiDiff = (noteA) => noteToMidi(noteA) - midi;
+    // object format will expect keys as notes
+    const closest = Object.keys(bank)
+      .filter((k) => !k.startsWith('_'))
+      .reduce(
+        (closest, key, j) => (!closest || Math.abs(midiDiff(key)) < Math.abs(midiDiff(closest)) ? key : closest),
+        null,
+      );
+    transpose = -midiDiff(closest); // semitones to repitch
+    index = getSoundIndex(n, bank[closest].length);
+    url = bank[closest][index];
+  }
+  const label = `${s}:${index}`;
+  return { transpose, url, index, midi, label };
+}

packages/superdough/wavetable.mjs

@@ -0,0 +1,336 @@
+import { getAudioContext, registerSound } from './index.mjs';
+import { getCommonSampleInfo } from './util.mjs';
+import {
+  applyFM,
+  applyParameterModulators,
+  destroyAudioWorkletNode,
+  getADSRValues,
+  getFrequencyFromValue,
+  getParamADSR,
+  getPitchEnvelope,
+  getVibratoOscillator,
+  getWorklet,
+  webAudioTimeout,
+} from './helpers.mjs';
+import { logger } from './logger.mjs';
+
+export const Warpmode = Object.freeze({
+  NONE: 0,
+  ASYM: 1,
+  MIRROR: 2,
+  BENDP: 3,
+  BENDM: 4,
+  BENDMP: 5,
+  SYNC: 6,
+  QUANT: 7,
+  FOLD: 8,
+  PWM: 9,
+  ORBIT: 10,
+  SPIN: 11,
+  CHAOS: 12,
+  PRIMES: 13,
+  BINARY: 14,
+  BROWNIAN: 15,
+  RECIPROCAL: 16,
+  WORMHOLE: 17,
+  LOGISTIC: 18,
+  SIGMOID: 19,
+  FRACTAL: 20,
+  FLIP: 21,
+});
+
+const seenKeys = new Set();
+async function getPayload(url, label, frameLen = 2048) {
+  const key = `${url},${frameLen}`;
+  if (!seenKeys.has(key)) {
+    const buf = await loadBuffer(url, label);
+    const ch0 = buf.getChannelData(0);
+    const total = ch0.length;
+    const numFrames = Math.max(1, Math.floor(total / frameLen));
+    const frames = new Array(numFrames);
+    for (let i = 0; i < numFrames; i++) {
+      const start = i * frameLen;
+      frames[i] = ch0.subarray(start, start + frameLen);
+    }
+    seenKeys.add(key);
+    return { frames, frameLen, numFrames, key };
+  }
+  return { frameLen, key }; // worklet will use the cached version
+}
+
+function humanFileSize(bytes, si) {
+  var thresh = si ? 1000 : 1024;
+  if (bytes < thresh) return bytes + ' B';
+  var units = si
+    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+  var u = -1;
+  do {
+    bytes /= thresh;
+    ++u;
+  } while (bytes >= thresh);
+  return bytes.toFixed(1) + ' ' + units[u];
+}
+
+// Extract the sample rate of a .wav file
+function parseWavSampleRate(arrBuf) {
+  const dv = new DataView(arrBuf);
+  // Header is "RIFF<chunk size (4 bytes)>WAVE", so 12 bytes
+  let p = 12;
+  // Look through chunks for the format header
+  // (they will always have an 8 byte header (id and size) followed by a payload)
+  while (p + 8 <= dv.byteLength) {
+    // Parse id
+    const id = String.fromCharCode(dv.getUint8(p), dv.getUint8(p + 1), dv.getUint8(p + 2), dv.getUint8(p + 3));
+    // Parse chunk size
+    const size = dv.getUint32(p + 4, true);
+    if (id === 'fmt ') {
+      // The format chunk contains the sample rate after
+      // 8 bytes of header, 2 bytes of format tag, 2 bytes of num channels
+      // (for a total of 12)
+      return dv.getUint32(p + 12, true);
+    }
+    // Advance to next chunk
+    p += 8 + size + (size & 1);
+  }
+  return null;
+}
+
+async function decodeAtNativeRate(arr) {
+  const sr = parseWavSampleRate(arr) || 44100;
+  const tempAC = new OfflineAudioContext(1, 1, sr);
+  return await tempAC.decodeAudioData(arr);
+}
+
+const loadCache = {};
+const loadBuffer = (url, label) => {
+  url = url.replace('#', '%23');
+  if (!loadCache[url]) {
+    logger(`[wavetable] load table ${label}..`, 'load-table', { url });
+    const timestamp = Date.now();
+    loadCache[url] = fetch(url)
+      .then((res) => res.arrayBuffer())
+      .then(async (res) => {
+        const took = Date.now() - timestamp;
+        const size = humanFileSize(res.byteLength);
+        logger(`[wavetable] load table ${label}... done! loaded ${size} in ${took}ms`, 'loaded-table', { url });
+        const decoded = await decodeAtNativeRate(res);
+        return decoded;
+      });
+  }
+  return loadCache[url];
+};
+
+function githubPath(base, subpath = '') {
+  if (!base.startsWith('github:')) {
+    throw new Error('expected "github:" at the start of pseudoUrl');
+  }
+  let [_, path] = base.split('github:');
+  path = path.endsWith('/') ? path.slice(0, -1) : path;
+  if (path.split('/').length === 2) {
+    // assume main as default branch if none set
+    path += '/main';
+  }
+  return `https://raw.githubusercontent.com/${path}/${subpath}`;
+}
+
+const _processTables = (json, baseUrl, frameLen, options = {}) => {
+  baseUrl = json._base || baseUrl;
+  return Object.entries(json).forEach(([key, tables]) => {
+    if (key === '_base') return false;
+    if (typeof tables === 'string') {
+      tables = [tables];
+    }
+    if (typeof tables !== 'object') {
+      throw new Error('wrong json format for ' + key);
+    }
+    let resolvedUrl = baseUrl;
+    if (resolvedUrl.startsWith('github:')) {
+      resolvedUrl = githubPath(resolvedUrl, '');
+    }
+    tables = tables
+      .map((t) => resolvedUrl + t)
+      .filter((t) => {
+        if (!t.toLowerCase().endsWith('.wav')) {
+          logger(`[wavetable] skipping ${t} -- wavetables must be ".wav" format`);
+          return false;
+        }
+        return true;
+      });
+    if (tables.length) {
+      registerWaveTable(key, tables, { baseUrl, frameLen });
+    }
+  });
+};
+
+export function registerWaveTable(key, tables, params) {
+  registerSound(
+    key,
+    (t, hapValue, onended, cps) => {
+      return onTriggerSynth(t, hapValue, onended, tables, cps, params?.frameLen ?? 2048);
+    },
+    {
+      type: 'wavetable',
+      tables,
+      ...params,
+    },
+  );
+}
+
+/**
+ * Loads a collection of wavetables to use with `s`
+ *
+ * @name tables
+ */
+export const tables = async (url, frameLen, json, options = {}) => {
+  if (json !== undefined) return _processTables(json, url, frameLen);
+  if (url.startsWith('github:')) {
+    url = githubPath(url, 'strudel.json');
+  }
+  if (url.startsWith('local:')) {
+    url = `http://localhost:5432`;
+  }
+  if (typeof fetch !== 'function') {
+    // not a browser
+    return;
+  }
+  if (typeof fetch === 'undefined') {
+    // skip fetch when in node / testing
+    return;
+  }
+  return fetch(url)
+    .then((res) => res.json())
+    .then((json) => _processTables(json, url, frameLen, options))
+    .catch((error) => {
+      console.error(error);
+      throw new Error(`error loading "${url}"`);
+    });
+};
+
+export async function onTriggerSynth(t, value, onended, tables, cps, frameLen) {
+  const { s, n = 0, duration, clip } = value;
+  const ac = getAudioContext();
+  const [attack, decay, sustain, release] = getADSRValues([value.attack, value.decay, value.sustain, value.release]);
+  let { warpmode } = value;
+  if (typeof warpmode === 'string') {
+    warpmode = Warpmode[warpmode.toUpperCase()] ?? Warpmode.NONE;
+  }
+  const frequency = getFrequencyFromValue(value);
+  const { url, label } = getCommonSampleInfo(value, tables);
+  const payload = await getPayload(url, label, frameLen);
+  let holdEnd = t + duration;
+  if (clip !== undefined) {
+    holdEnd = Math.min(t + clip * duration, holdEnd);
+  }
+  const endWithRelease = holdEnd + release;
+  const envEnd = endWithRelease + 0.01;
+  const source = getWorklet(
+    ac,
+    'wavetable-oscillator-processor',
+    {
+      begin: t,
+      end: envEnd,
+      frequency,
+      detune: value.detune,
+      position: value.wt,
+      warp: value.warp,
+      warpMode: warpmode,
+      voices: Math.max(value.unison ?? 1, 1),
+      spread: value.spread,
+      phaserand: (value.wtphaserand ?? value.unison > 1) ? 1 : 0,
+    },
+    { outputChannelCount: [2] },
+  );
+  source.port.postMessage({ type: 'table', payload });
+  if (ac.currentTime > t) {
+    logger(`[wavetable] still loading sound "${s}:${n}"`, 'highlight');
+    return;
+  }
+  const posADSRParams = [value.wtattack, value.wtdecay, value.wtsustain, value.wtrelease];
+  const warpADSRParams = [value.warpattack, value.warpdecay, value.warpsustain, value.warprelease];
+  const wtParams = source.parameters;
+  const positionParam = wtParams.get('position');
+  const warpParam = wtParams.get('warp');
+
+  let wtrate = value.wtrate;
+  if (value.wtsync != null) {
+    wtrate = cps * value.wtsync;
+  }
+
+  const wtPosModulators = applyParameterModulators(
+    ac,
+    positionParam,
+    t,
+    endWithRelease,
+    {
+      offset: value.wt,
+      amount: value.wtenv,
+      defaultAmount: 0.5,
+      shape: 'linear',
+      values: posADSRParams,
+      holdEnd,
+      defaultValues: [0, 0.5, 0, 0.1],
+    },
+    {
+      frequency: wtrate,
+      depth: value.wtdepth,
+      defaultDepth: 0.5,
+      shape: value.wtshape,
+      skew: value.wtskew,
+      dcoffset: value.wtdc ?? 0,
+    },
+  );
+
+  let warprate = value.warprate;
+  if (value.warpsync != null) {
+    warprate = warprate = cps * value.warpsync;
+  }
+  const wtWarpModulators = applyParameterModulators(
+    ac,
+    warpParam,
+    t,
+    endWithRelease,
+    {
+      offset: value.warp,
+      amount: value.warpenv,
+      defaultAmount: 0.5,
+      shape: 'linear',
+      values: warpADSRParams,
+      holdEnd,
+      defaultValues: [0, 0.5, 0, 0.1],
+    },
+    {
+      frequency: warprate,
+      depth: value.warpdepth,
+      defaultDepth: 0.5,
+      shape: value.warpshape,
+      skew: value.warpskew,
+      dcoffset: value.warpdc ?? 0,
+    },
+  );
+  const vibratoOscillator = getVibratoOscillator(source.parameters.get('detune'), value, t);
+  const fm = applyFM(source.parameters.get('frequency'), value, t);
+  const envGain = ac.createGain();
+  const node = source.connect(envGain);
+  getParamADSR(node.gain, attack, decay, sustain, release, 0, 0.3, t, holdEnd, 'linear');
+  getPitchEnvelope(source.parameters.get('detune'), value, t, holdEnd);
+  const handle = { node, source };
+  const timeoutNode = webAudioTimeout(
+    ac,
+    () => {
+      destroyAudioWorkletNode(source);
+      vibratoOscillator?.stop();
+      fm?.stop();
+      node.disconnect();
+      wtPosModulators?.disconnect();
+      wtWarpModulators?.disconnect();
+      onended();
+    },
+    t,
+    envEnd,
+  );
+  handle.stop = (time) => {
+    timeoutNode.stop(time);
+  };
+  return handle;
+}

packages/superdough/worklets.mjs

@@ -4,22 +4,47 @@
 
 import OLAProcessor from './ola-processor';
 import FFT from './fft.js';
+import { getDistortionAlgorithm } from './helpers.mjs';
 
 const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
-const _mod = (n, m) => ((n % m) + m) % m;
+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));
+};
+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;
-// adjust waveshape to remove frequencies above nyquist to prevent aliasing
+// 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) {
-  // 0 <= phase < 1
+  dt = Math.min(dt, 1 - dt);
+  // Start of cycle
   if (phase < dt) {
     phase /= dt;
     // 2 * (phase - phase^2/2 - 0.5)
     return phase + phase - phase * phase - 1;
   }
 
-  // -1 < phase < 0
+  // End of cycle
   else if (phase > 1 - dt) {
     phase = (phase - 1) / dt;
     // 2 * (phase^2/2 + phase + 0.5)
@@ -113,9 +138,8 @@ class LFOProcessor extends AudioWorkletProcessor {
     }
   }
 
-  process(inputs, outputs, parameters) {
+  process(_inputs, outputs, parameters) {
     const begin = parameters['begin'][0];
-    // eslint-disable-next-line no-undef
     if (currentTime >= parameters.end[0]) {
       return false;
     }
@@ -141,9 +165,8 @@ class LFOProcessor extends AudioWorkletProcessor {
     const blockSize = output[0].length ?? 0;
 
     if (this.phase == null) {
-      this.phase = _mod(time * frequency + phaseoffset, 1);
+      this.phase = mod(time * frequency + phaseoffset, 1);
     }
-    // eslint-disable-next-line no-undef
     const dt = frequency / sampleRate;
     for (let n = 0; n < blockSize; n++) {
       for (let i = 0; i < output.length; i++) {
@@ -263,6 +286,73 @@ class ShapeProcessor extends AudioWorkletProcessor {
 }
 registerProcessor('shape-processor', ShapeProcessor);
 
+class TwoPoleFilter {
+  s0 = 0;
+  s1 = 0;
+  update(s, cutoff, resonance = 0) {
+    // 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 mrc = 1 - r * c;
+    this.s0 = mrc * this.s0 - c * this.s1 + c * s; // bpf
+    this.s1 = mrc * this.s1 + c * this.s0; // lpf
+    return this.s1; // return lpf by default
+  }
+}
+
+class DJFProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [{ name: 'value', defaultValue: 0.5 }];
+  }
+
+  constructor() {
+    super();
+    this.filters = [new TwoPoleFilter(), new TwoPoleFilter()];
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+
+    const hasInput = !(input[0] === undefined);
+    this.started = hasInput;
+
+    const value = clamp(parameters.value[0], 0, 1);
+    let filterType = 'none';
+    let cutoff;
+    let v = 1;
+    if (value > 0.51) {
+      filterType = 'hipass';
+      v = (value - 0.5) * 2;
+    } else if (value < 0.49) {
+      filterType = 'lopass';
+      v = value * 2;
+    }
+    cutoff = Math.pow(v * 11, 4);
+
+    for (let i = 0; i < input.length; i++) {
+      for (let n = 0; n < blockSize; n++) {
+        if (filterType == 'none') {
+          output[i][n] = input[i][n];
+        } else {
+          this.filters[i].update(input[i][n], cutoff, 0.1);
+          if (filterType === 'lopass') {
+            output[i][n] = this.filters[i].s1;
+          } else if (filterType === 'hipass') {
+            output[i][n] = input[i][n] - this.filters[i].s1;
+          } else {
+            output[i][n] = input[i][n];
+          }
+        }
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('djf-processor', DJFProcessor);
+
 function fast_tanh(x) {
   const x2 = x * x;
   return (x * (27.0 + x2)) / (27.0 + 9.0 * x2);
@@ -305,7 +395,6 @@ class LadderProcessor extends AudioWorkletProcessor {
     const drive = clamp(Math.exp(parameters.drive[0]), 0.1, 2000);
 
     let cutoff = parameters.frequency[0];
-    // eslint-disable-next-line no-undef
     cutoff = (cutoff * 2 * _PI) / sampleRate;
     cutoff = cutoff > 1 ? 1 : cutoff;
 
@@ -342,9 +431,10 @@ class DistortProcessor extends AudioWorkletProcessor {
     ];
   }
 
-  constructor() {
+  constructor({ processorOptions }) {
     super();
     this.started = false;
+    this.algorithm = getDistortionAlgorithm(processorOptions.algorithm);
   }
 
   process(inputs, outputs, parameters) {
@@ -356,13 +446,12 @@ class DistortProcessor extends AudioWorkletProcessor {
       return false;
     }
     this.started = hasInput;
-
-    const shape = Math.expm1(parameters.distort[0]);
-    const postgain = Math.max(0.001, Math.min(1, parameters.postgain[0]));
-
     for (let n = 0; n < blockSize; n++) {
-      for (let i = 0; i < input.length; i++) {
-        output[i][n] = (((1 + shape) * input[i][n]) / (1 + shape * Math.abs(input[i][n]))) * postgain;
+      const postgain = clamp(pv(parameters.postgain, n), 0.001, 1);
+      const shape = Math.expm1(pv(parameters.distort, n));
+      for (let ch = 0; ch < input.length; ch++) {
+        const x = input[ch][n];
+        output[ch][n] = postgain * this.algorithm(x, shape);
       }
     }
     return true;
@@ -371,21 +460,6 @@ class DistortProcessor extends AudioWorkletProcessor {
 registerProcessor('distort-processor', DistortProcessor);
 
 // SUPERSAW
-function lerp(a, b, n) {
-  return n * (b - a) + a;
-}
-
-function getUnisonDetune(unison, detune, voiceIndex) {
-  if (unison < 2) {
-    return 0;
-  }
-  return lerp(-detune * 0.5, detune * 0.5, voiceIndex / (unison - 1));
-}
-
-function applySemitoneDetuneToFrequency(frequency, detune) {
-  return frequency * Math.pow(2, detune / 12);
-}
-
 class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
@@ -437,54 +511,48 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
       },
     ];
   }
-  process(input, outputs, params) {
-    // eslint-disable-next-line no-undef
+  process(_input, outputs, params) {
     if (currentTime <= params.begin[0]) {
       return true;
     }
-    // eslint-disable-next-line no-undef
     if (currentTime >= params.end[0]) {
       // this.port.postMessage({ type: 'onended' });
       return false;
     }
-    let frequency = params.frequency[0];
-    //apply detune in cents
-    frequency = frequency * Math.pow(2, params.detune[0] / 1200);
 
     const output = outputs[0];
-    const voices = params.voices[0];
-    const freqspread = params.freqspread[0];
-    const panspread = params.panspread[0] * 0.5 + 0.5;
-    const gain1 = Math.sqrt(1 - panspread);
-    const gain2 = Math.sqrt(panspread);
 
-    for (let n = 0; n < voices; n++) {
-      const isOdd = (n & 1) == 1;
-
-      //applies unison "spread" detune in semitones
-      const freq = applySemitoneDetuneToFrequency(frequency, getUnisonDetune(voices, freqspread, n));
-      let gainL = gain1;
-      let gainR = gain2;
-      // invert right and left gain
-      if (isOdd) {
-        gainL = gain2;
-        gainR = gain1;
-      }
-      // eslint-disable-next-line no-undef
-      const dt = freq / sampleRate;
-
-      for (let i = 0; i < output[0].length; i++) {
+    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 freq = pv(params.frequency, i);
+      // Main detuning
+      freq = applySemitoneDetuneToFrequency(freq, detune / 100);
+      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));
+        // We must wrap this here because it is passed into sawblep below which
+        // has domain [0, 1]
+        const dt = mod(freqVoice / sampleRate, 1);
         this.phase[n] = this.phase[n] ?? Math.random();
         const v = waveshapes.sawblep(this.phase[n], dt);
 
         output[0][i] = output[0][i] + v * gainL;
         output[1][i] = output[1][i] + v * gainR;
 
-        this.phase[n] += dt;
-
-        if (this.phase[n] > 1.0) {
-          this.phase[n] = this.phase[n] - 1;
-        }
+        this.phase[n] = wrapPhase(this.phase[n] + dt);
       }
     }
     return true;
@@ -493,7 +561,7 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
 
 registerProcessor('supersaw-oscillator', SuperSawOscillatorProcessor);
 
-// Phase Vocoder sourced from // sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
+// Phase Vocoder sourced from https://github.com/olvb/phaze/tree/master?tab=readme-ov-file
 const BUFFERED_BLOCK_SIZE = 2048;
 
 function genHannWindow(length) {
@@ -908,3 +976,342 @@ class ByteBeatProcessor extends AudioWorkletProcessor {
 }
 
 registerProcessor('byte-beat-processor', ByteBeatProcessor);
+
+export const WarpMode = Object.freeze({
+  NONE: 0,
+  ASYM: 1,
+  MIRROR: 2,
+  BENDP: 3,
+  BENDM: 4,
+  BENDMP: 5,
+  SYNC: 6,
+  QUANT: 7,
+  FOLD: 8,
+  PWM: 9,
+  ORBIT: 10,
+  SPIN: 11,
+  CHAOS: 12,
+  PRIMES: 13,
+  BINARY: 14,
+  BROWNIAN: 15,
+  RECIPROCAL: 16,
+  WORMHOLE: 17,
+  LOGISTIC: 18,
+  SIGMOID: 19,
+  FRACTAL: 20,
+  FLIP: 21,
+});
+
+function hash32(u) {
+  u = u + 0x7ed55d16 + (u << 12);
+  u = u ^ 0xc761c23c ^ (u >>> 19);
+  u = u + 0x165667b1 + (u << 5);
+  u = (u + 0xd3a2646c) ^ (u << 9);
+  u = u + 0xfd7046c5 + (u << 3);
+  u = u ^ 0xb55a4f09 ^ (u >>> 16);
+  return u >>> 0;
+}
+const hash01 = (i) => (hash32(i) >>> 8) / 0x01000000;
+
+function bitReverse(i, n) {
+  let r = 0;
+  for (let b = 0; b < n; b++) {
+    r = (r << 1) | (i & 1);
+    i >>>= 1;
+  }
+  return r;
+}
+
+function noise(x) {
+  const i = Math.floor(x),
+    f = x - i;
+  const a = hash01(i),
+    b = hash01(i + 1);
+  return a + (b - a) * f;
+}
+
+function brownian(x, oct = 4) {
+  let amp = 0.5,
+    sum = 0,
+    norm = 0,
+    freq = 1;
+  for (let o = 0; o < oct; o++) {
+    sum += amp * noise(x * freq);
+    norm += amp;
+    amp *= 0.5;
+    freq *= 2;
+  }
+  return (sum / norm) * 2 - 1;
+}
+
+const tablesCache = {};
+class WavetableOscillatorProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: 'begin', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
+      { name: 'end', defaultValue: 0, min: 0, max: Number.POSITIVE_INFINITY },
+      { name: 'frequency', defaultValue: 220, minValue: 0.01, maxValue: 20000 },
+      { name: 'detune', defaultValue: 0.18 },
+      { name: 'position', defaultValue: 0, minValue: 0, maxValue: 1 },
+      { name: 'warp', defaultValue: 0, minValue: 0, maxValue: 1 },
+      { name: 'warpMode', defaultValue: 0 },
+      { name: 'voices', defaultValue: 1, minValue: 1, maxValue: 32 },
+      { name: 'spread', defaultValue: 0.7, minValue: 0, maxValue: 1 },
+      { name: 'phaserand', defaultValue: 0, minValue: 0, maxValue: 1 },
+    ];
+  }
+
+  constructor(options) {
+    super(options);
+    this.frameLen = 0;
+    this.numFrames = 0;
+    this.phase = [];
+    this.invSR = 1 / sampleRate;
+
+    this.port.onmessage = (e) => {
+      const { type, payload } = e.data || {};
+      if (type === 'table') {
+        const key = payload.key;
+        this.frameLen = payload.frameLen;
+        if (!tablesCache[key]) {
+          const tables = [payload.frames];
+          let table = tables[0];
+          for (let level = 1; level < 1; level++) {
+            const nextLen = table.length >> 1;
+            const nextTable = table.map((frame) => {
+              const avg = new Float32Array(nextLen);
+              for (let i = 0; i < nextLen; i++) {
+                avg[i] = (frame[2 * i] + frame[2 * i + 1]) / 2;
+              }
+              return avg;
+            });
+            tables.push(nextTable);
+            table = nextTable;
+            if (nextLen <= 32) break;
+          }
+          tablesCache[key] = tables;
+        }
+        this.tables = tablesCache[key];
+        this.numFrames = this.tables[0].length;
+      }
+    };
+  }
+
+  _mirror(x) {
+    return 1 - Math.abs(2 * x - 1);
+  }
+
+  _toBits(amt, min = 2, max = 12) {
+    const b = max + (min - max) * amt;
+    return { b, n: Math.round(Math.pow(2, b)) };
+  }
+
+  _warpPhase(phase, amt, mode) {
+    switch (mode) {
+      case WarpMode.NONE: {
+        return phase;
+      }
+      case WarpMode.ASYM: {
+        const a = 0.01 + 0.99 * amt;
+        return phase < a ? (0.5 * phase) / a : 0.5 + (0.5 * (phase - a)) / (1 - a);
+      }
+      case WarpMode.MIRROR: {
+        // Asym, then mirror
+        return this._mirror(this._warpPhase(phase, amt, WarpMode.ASYM));
+      }
+      case WarpMode.BENDP: {
+        return Math.pow(phase, 1 + 3 * amt);
+      }
+      case WarpMode.BENDM: {
+        return Math.pow(phase, 1 / (1 + 3 * amt));
+      }
+      case WarpMode.BENDMP: {
+        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);
+        return (phase * syncRatio) % 1;
+      }
+      case WarpMode.QUANT: {
+        const { n } = this._toBits(amt);
+        return ffloor(phase * n) / n;
+      }
+      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;
+      }
+      case WarpMode.PWM: {
+        const w = clamp(0.5 + 0.49 * (2 * amt - 1), 0, 1);
+        if (phase < w) return (phase / w) * 0.5;
+        return 0.5 + ((phase - w) / (1 - w)) * 0.5;
+      }
+      case WarpMode.ORBIT: {
+        const depth = 0.5 * amt;
+        const n = 3;
+        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
+      }
+      case WarpMode.SPIN: {
+        const depth = 0.5 * amt;
+        const { n } = this._toBits(amt, 1, 6);
+        return frac(phase + depth * Math.sin(2 * Math.PI * n * phase));
+      }
+      case WarpMode.CHAOS: {
+        const r = 3.7 + 0.3 * amt;
+        const logistic = r * phase * (1 - phase);
+        return clamp((1 - amt) * phase + amt * logistic, 0, 1);
+      }
+      case WarpMode.PRIMES: {
+        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;
+          return true;
+        };
+        let { n } = this._toBits(amt, 3);
+        while (!isPrime(n)) n++;
+        return ffloor(phase * n) / n;
+      }
+      case WarpMode.BINARY: {
+        let { b } = this._toBits(amt, 3);
+        b = Math.round(b);
+        const n = 1 << b;
+        const idx = ffloor(phase * n);
+        const ridx = bitReverse(idx, b);
+        return ridx / n;
+      }
+      case WarpMode.MODULAR: {
+        const { n } = this._toBits(amt);
+        const depth = 0.5 * amt;
+        const jump = frac(phase * n) / n;
+        return frac(phase + depth * jump);
+      }
+      case WarpMode.BROWNIAN: {
+        const disp = 0.25 * amt * brownian(64 * phase, 4);
+        return frac(phase + disp);
+      }
+      case WarpMode.RECIPROCAL: {
+        const g = 2 + 4 * amt;
+        const num = phase * g;
+        const den = phase + (1 - phase) * g;
+        const y = den > 1e-12 ? num / den : 0;
+        return clamp(y, 0, 1);
+      }
+      case WarpMode.WORMHOLE: {
+        const gap = clamp(0.8 * amt, 0, 1);
+        const a = 0.5 * (1 - gap);
+        const b = 0.5 * (1 + gap);
+        if (phase < a) return (phase / a) * 0.5;
+        if (phase > b) return 0.5 * (1 + (phase - b) / (1 - b));
+        return 0.5;
+      }
+      case WarpMode.LOGISTIC: {
+        let x = phase;
+        const r = 3.6 + 0.4 * amt;
+        const iters = 1 + Math.round(2 * amt);
+        for (let i = 0; i < iters; i++) x = r * x * (1 - x);
+        return clamp(x, 0, 1);
+      }
+      case WarpMode.SIGMOID: {
+        const k = 1 + 10 * amt;
+        const x = phase - 0.5;
+        const y = 1 / (1 + Math.exp(-k * x));
+        const y0 = 1 / (1 + Math.exp(0.5 * k));
+        const y1 = 1 / (1 + Math.exp(-0.5 * k));
+        return (y - y0) / (y1 - y0);
+      }
+      case WarpMode.FRACTAL: {
+        const d = 0.5 * Math.sin(2 * Math.PI * phase) * amt;
+        return frac(phase + d);
+      }
+      case WarpMode.FLIP: {
+        return phase;
+      }
+      default:
+        return phase;
+    }
+  }
+
+  _sampleFrame(frame, phase) {
+    const len = frame.length;
+    const pos = phase * len;
+    const i = pos | 0;
+    const frac = pos - i;
+    const a = frame[i];
+    const i1 = i + 1 < len ? i + 1 : 0; // fast wrap
+    const b = frame[i1];
+    return a + (b - a) * frac;
+  }
+
+  _chooseMip(dphi) {
+    const approxHarm = clamp(dphi, 1e-6, 64);
+    let level = 0;
+    while (level + 1 < (this.tables?.length || 1) && approxHarm < this.tables[level][0].length / 8) {
+      level++;
+    }
+    return level;
+  }
+
+  process(_inputs, outputs, parameters) {
+    if (currentTime >= parameters.end[0]) {
+      return false;
+    }
+    if (currentTime <= parameters.begin[0]) {
+      return true;
+    }
+    const outL = outputs[0][0];
+    const outR = outputs[0][1] || outputs[0][0];
+    if (!this.tables) {
+      outL.fill(0);
+      if (outR !== outL) outR.set(outL);
+      return true;
+    }
+    for (let i = 0; i < outL.length; i++) {
+      const detune = pv(parameters.detune, 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 warpAmount = clamp(pv(parameters.warp, i), 0, 1);
+      const warpMode = pv(parameters.warpMode, i);
+      const voices = pv(parameters.voices, i);
+      const phaseRand = clamp(pv(parameters.phaserand, i), 0, 1);
+      const spread = voices > 1 ? clamp(pv(parameters.spread, i), 0, 1) : 0;
+      const gain1 = Math.sqrt(0.5 - 0.5 * spread);
+      const gain2 = Math.sqrt(0.5 + 0.5 * spread);
+      let f = pv(parameters.frequency, i);
+      f = applySemitoneDetuneToFrequency(f, detune / 100); // overall detune
+      const normalizer = 1 / Math.sqrt(voices);
+      for (let n = 0; n < voices; n++) {
+        const isOdd = (n & 1) == 1;
+        let gainL = gain1;
+        let gainR = gain2;
+        // invert right and left gain
+        if (isOdd) {
+          gainL = gain2;
+          gainR = gain1;
+        }
+        const fVoice = applySemitoneDetuneToFrequency(f, getUnisonDetune(voices, detune, n)); // voice detune
+        const dPhase = fVoice * this.invSR;
+        const level = this._chooseMip(dPhase);
+        const table = this.tables[level];
+
+        // warp phase then sample
+        this.phase[n] = this.phase[n] ?? Math.random() * phaseRand;
+        const ph = this._warpPhase(this.phase[n], warpAmount, warpMode);
+        const s0 = this._sampleFrame(table[fIdx], ph);
+        const s1 = this._sampleFrame(table[Math.min(this.numFrames - 1, fIdx + 1)], ph);
+        let s = s0 + (s1 - s0) * frac;
+        if (warpMode === WarpMode.FLIP && this.phase[n] < warpAmount) {
+          s = -s;
+        }
+        outL[i] += s * gainL * normalizer;
+        outR[i] += s * gainR * normalizer;
+        this.phase[n] = wrapPhase(this.phase[n] + dPhase);
+      }
+    }
+    return true;
+  }
+}
+
+registerProcessor('wavetable-oscillator-processor', WavetableOscillatorProcessor);

packages/superdough/zzfx.mjs

@@ -1,6 +1,7 @@
 //import { ZZFX } from 'zzfx';
 import { midiToFreq, noteToMidi } from './util.mjs';
-import { registerSound, getAudioContext } from './superdough.mjs';
+import { registerSound } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 import { buildSamples } from './zzfx_fork.mjs';
 
 export const getZZFX = (value, t) => {

packages/superdough/zzfx_fork.mjs

@@ -1,4 +1,4 @@
-import { getAudioContext } from './superdough.mjs';
+import { getAudioContext } from './audioContext.mjs';
 
 // https://github.com/KilledByAPixel/ZzFX/blob/master/ZzFX.js#L85C5-L180C6
 // changes: replaced this.volume with 1 + using sampleRate from getAudioContext()

packages/supradough/.gitignore

@@ -0,0 +1 @@
+pattern.wav

packages/supradough/README.md

@@ -0,0 +1,3 @@
+# supradough
+
+platform agnostic synth and sampler intended for live coding. a reimplementation of superdough.

packages/supradough/dough-export.mjs

@@ -0,0 +1,123 @@
+// this is a poc of how a pattern can be rendered as a wav file using node
+// run via: node dough-export.mjs
+import fs from 'node:fs';
+import WavEncoder from 'wav-encoder';
+import { evalScope } from '@strudel/core';
+import { miniAllStrings } from '@strudel/mini';
+import { Dough } from './dough.mjs';
+
+await evalScope(
+  import('@strudel/core'),
+  import('@strudel/mini'),
+  import('@strudel/tonal'),
+  // import('@strudel/tonal'),
+);
+
+miniAllStrings(); // allows using single quotes for mini notation / skip transpilation
+
+let sampleRate = 48000,
+  cps = 0.4;
+
+/* await doughsamples('github:eddyflux/crate');
+await doughsamples('github:eddyflux/wax'); */
+
+let pat = note('c,eb,g,<bb c4 d4 eb4>')
+  .s('sine')
+  .press()
+  .add(note(24))
+  .fmi(3)
+  .fmh(5.01)
+  .dec(0.4)
+  .delay('.6:<.12 .22>:.8')
+  .jux(press)
+  .rarely(add(note('12')))
+  .lpf(400)
+  .lpq(0.2)
+  .lpd(0.4)
+  .lpenv(3)
+  .fmdecay(0.4)
+  .fmenv(1)
+  .postgain(0.6)
+  .stack(s('<pink white>*8').dec(0.07).rarely(ply('2')).delay(0.5).hpf(sine.range(200, 2000).slow(4)).hpq(0.2))
+  .stack(
+    s('[- white@3]*2')
+      .dec(0.4)
+      .hpf('<2000!3 <4000 8000>>*4')
+      .hpq(0.6)
+      .ply('<1 2>*4')
+      .postgain(0.5)
+      .delay(0.5)
+      .jux(rev)
+      .lpf(5000),
+  )
+  .stack(
+    note('<c2 - [- f1] ->*2')
+      .s('square')
+      .lpf(sine.range(100, 300).slow(4))
+      .lpe(1)
+      .segment(8)
+      .lpd(0.3)
+      .lpq(0.2)
+      .dec(0.2)
+      .speed('<1 2>')
+      .ply('<1 2>')
+      .postgain(1),
+  )
+  .stack(
+    chord('<Cm Cm7 Cm9 Cm11 Fm Fm7 Fm9 Fm11>')
+      .voicing()
+      .s('<sine>')
+      .clip(1)
+      .rel(0.4)
+      .vib('4:.2')
+      .gain(0.7)
+      .hpf(1200)
+      .fm(0.5)
+      .att(1)
+      .lpa(0.5)
+      .lpf(200)
+      .lpenv(4)
+      .chorus(0.8),
+  )
+  .slow(1 / cps);
+
+let cycles = 30;
+let seconds = cycles + 1; // 1s release tail
+const haps = pat.queryArc(0, cycles);
+
+const dough = new Dough(sampleRate);
+
+console.log('spawn voices...');
+haps.forEach((hap) => {
+  hap.value._begin = Number(hap.whole.begin);
+  hap.value._duration = hap.duration /*  / cps */;
+  dough.scheduleSpawn(hap.value);
+});
+console.log(`render ${seconds}s long buffer, each dot is 1 second:`);
+const buffers = [new Float32Array(seconds * sampleRate), new Float32Array(seconds * sampleRate)];
+let t = performance.now();
+while (dough.t <= buffers[0].length) {
+  dough.update();
+  buffers[0][dough.t] = dough.out[0];
+  buffers[1][dough.t] = dough.out[1];
+  if (dough.t % sampleRate === 0) {
+    process.stdout.write('.');
+  }
+}
+const took = (performance.now() - t) / 1000;
+const load = (took / seconds) * 100;
+const speed = (seconds / took).toFixed(2);
+console.log('');
+console.log(`done!
+rendered ${seconds}s in ${took.toFixed(2)}s 
+speed: ${speed}x
+load: ${load.toFixed(2)}%`);
+
+const patternAudio = {
+  sampleRate,
+  channelData: buffers,
+};
+
+WavEncoder.encode(patternAudio).then((buffer) => {
+  fs.writeFileSync('pattern.wav', new Float32Array(buffer));
+});

packages/supradough/dough-worklet.mjs

@@ -0,0 +1,39 @@
+import { Dough } from './dough.mjs';
+
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+
+class DoughProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.dough = new Dough(sampleRate, currentTime);
+    this.port.onmessage = (event) => {
+      if (event.data.spawn) {
+        this.dough.scheduleSpawn(event.data.spawn);
+      } else if (event.data.sample) {
+        this.dough.loadSample(event.data.sample, event.data.channels, event.data.sampleRate);
+      } else if (event.data.samples) {
+        event.data.samples.forEach(([name, channels, sampleRate]) => {
+          this.dough.loadSample(name, channels, sampleRate);
+        });
+      } else {
+        console.log('unrecognized event type', event.data);
+      }
+    };
+  }
+  process(inputs, outputs, params) {
+    if (this.disconnected) {
+      return false;
+    }
+    const output = outputs[0];
+    for (let i = 0; i < output[0].length; i++) {
+      this.dough.update();
+      for (let c = 0; c < output.length; c++) {
+        //prevent speaker blowout via clipping if threshold exceeds
+        output[c][i] = clamp(this.dough.out[c], -1, 1);
+      }
+    }
+    return true; // keep the audio processing going
+  }
+}
+
+registerProcessor('dough-processor', DoughProcessor);

packages/supradough/index.mjs

@@ -0,0 +1,5 @@
+// import _workletUrl from './dough-worklet.mjs?url'; // only for dev (breaks for production build)
+import _workletUrl from './dough-worklet.mjs?audioworklet'; // only for prod (breaks in development?!)
+
+export * from './dough.mjs';
+export const workletUrl = _workletUrl;

packages/supradough/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "supradough",
+  "version": "1.2.3",
+  "description": "platform agnostic synth and sampler intended for live coding. a reimplementation of superdough.",
+  "main": "index.mjs",
+  "type": "module",
+  "publishConfig": {
+    "main": "dist/index.mjs"
+  },
+  "scripts": {
+    "build": "vite build",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tidalcycles/strudel.git"
+  },
+  "keywords": [
+    "tidalcycles",
+    "strudel",
+    "pattern",
+    "livecoding",
+    "algorave"
+  ],
+  "author": "Felix Roos <flix91@gmail.com>",
+  "license": "AGPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/tidalcycles/strudel/issues"
+  },
+  "homepage": "https://github.com/tidalcycles/strudel#readme",
+  "devDependencies": {
+    "vite": "^6.0.11",
+    "vite-plugin-bundle-audioworklet": "workspace:*",
+    "wav-encoder": "^1.3.0"
+  },
+  "dependencies": {}
+}

packages/tonal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/tonal",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Tonal functions for strudel",
   "main": "index.mjs",
   "publishConfig": {

packages/tonal/test/tonal.test.mjs

@@ -7,80 +7,130 @@ This program is free software: you can redistribute it and/or modify it under th
 // import { strict as assert } from 'assert';
 
 import '../tonal.mjs'; // need to import this to add prototypes
-import { pure, n, seq, note } from '@strudel/core';
+import { pure, n, seq, note, noteToMidi } from '@strudel/core';
 import { describe, it, expect } from 'vitest';
 import { mini } from '../../mini/mini.mjs';
 
 describe('tonal', () => {
-  it('Should run tonal functions ', () => {
-    expect(pure('c3').scale('C major').scaleTranspose(1).firstCycleValues).toEqual(['D3']);
+  describe('scaleTranspose', () => {
+    it('transposes notes by scale degrees', () => {
+      expect(pure('c3').scale('C major').scaleTranspose(1).firstCycleValues).toEqual(['D3']);
+    });
   });
-  it('scale with plain values', () => {
-    expect(
-      seq(0, 1, 2)
-        .scale('C major')
-        .note()
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
+  describe('scale', () => {
+    it('converts plain values', () => {
+      expect(
+        seq(0, 1, 2)
+          .scale('C major')
+          .note()
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (mini notation)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('C:major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (no tonic)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (explicit mini notation)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale(mini('C:major'))
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts decorated n values', () => {
+      expect(
+        n(seq('0b', '1#', '-2', '3##', '4bb'))
+          .scale('C major')
+          .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'];
+
+      expect(
+        note(seq(inputNotes))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
+    it('snaps notes to the correct octave', () => {
+      const inputNotes = ['Cb0', 'Eb4', 'G1', 'A#19', 'Bb8'];
+      const expectedNotes = ['B#-1', 'D#4', 'G#1', 'A#19', 'A#8'];
+
+      expect(
+        note(seq(inputNotes))
+          .scale('A# minor') // A#, B#, C#, D#, E#, F#, G#
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
+    it('handles scale names provided with colons', () => {
+      const inputNotes = ['Cb', 'E', 'G', 'A#', 'Bb'];
+      const expectedNotes = ['A#2', 'D#3', 'G#3', 'A#3', 'A#3'];
+
+      expect(
+        note(seq(inputNotes))
+          .scale('F#:pentatonic') // F#, G#, A#, C#, and D#
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
   });
-  it('scale with n values', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('C major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale with colon', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('C:major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale without tonic', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale with mininotation colon', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale(mini('C:major'))
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('transposes note numbers with interval numbers', () => {
-    expect(
-      note(seq(40, 40, 40))
-        .transpose(0, 1, 2)
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual([40, 41, 42]);
-    expect(seq(40, 40, 40).transpose(0, 1, 2).firstCycleValues).toEqual([40, 41, 42]);
-  });
-  it('transposes note numbers with interval strings', () => {
-    expect(
-      note(seq(40, 40, 40))
-        .transpose('1P', '2M', '3m')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual([40, 42, 43]);
-    expect(seq(40, 40, 40).transpose('1P', '2M', '3m').firstCycleValues).toEqual([40, 42, 43]);
-  });
-  it('transposes note strings with interval numbers', () => {
-    expect(
-      note(seq('c', 'c', 'c'))
-        .transpose(0, 1, 2)
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C', 'Db', 'D']);
-    expect(seq('c', 'c', 'c').transpose(0, 1, 2).firstCycleValues).toEqual(['C', 'Db', 'D']);
-  });
-  it('transposes note strings with interval strings', () => {
-    expect(
-      note(seq('c', 'c', 'c'))
-        .transpose('1P', '2M', '3m')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C', 'D', 'Eb']);
-    expect(seq('c', 'c', 'c').transpose('1P', '2M', '3m').firstCycleValues).toEqual(['C', 'D', 'Eb']);
+  describe('transpose', () => {
+    it('transposes note numbers with interval numbers', () => {
+      expect(
+        note(seq(40, 40, 40))
+          .transpose(0, 1, 2)
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual([40, 41, 42]);
+      expect(seq(40, 40, 40).transpose(0, 1, 2).firstCycleValues).toEqual([40, 41, 42]);
+    });
+    it('transposes note numbers with interval strings', () => {
+      expect(
+        note(seq(40, 40, 40))
+          .transpose('1P', '2M', '3m')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual([40, 42, 43]);
+      expect(seq(40, 40, 40).transpose('1P', '2M', '3m').firstCycleValues).toEqual([40, 42, 43]);
+    });
+    it('transposes note strings with interval numbers', () => {
+      expect(
+        note(seq('c', 'c', 'c'))
+          .transpose(0, 1, 2)
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C', 'Db', 'D']);
+      expect(seq('c', 'c', 'c').transpose(0, 1, 2).firstCycleValues).toEqual(['C', 'Db', 'D']);
+    });
+    it('transposes note strings with interval strings', () => {
+      expect(
+        note(seq('c', 'c', 'c'))
+          .transpose('1P', '2M', '3m')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C', 'D', 'Eb']);
+      expect(seq('c', 'c', 'c').transpose('1P', '2M', '3m').firstCycleValues).toEqual(['C', 'D', 'Eb']);
+    });
   });
 });

packages/tonal/tonal.mjs

@@ -6,19 +6,28 @@ 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 { stepInNamedScale } from './tonleiter.mjs';
+import { stepInNamedScale, nearestNumberIndex } from './tonleiter.mjs';
+import { noteToMidi } from '../core/util.mjs';
 
 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
 
-function scaleStep(step, scale) {
-  scale = scale.replaceAll(':', ' ');
-  step = Math.ceil(step);
-  let { intervals, tonic, empty } = Scale.get(scale);
-  if ((empty && isNote(scale)) || (empty && !tonic)) {
-    throw new Error(`incomplete scale. Make sure to use ":" instead of spaces, example: .scale("C:major")`);
+function getScale(scaleName) {
+  scaleName = scaleName.replaceAll(':', ' ');
+  const scale = Scale.get(scaleName);
+  const { tonic, empty } = scale;
+  if ((empty && isNote(scaleName)) || (empty && !tonic)) {
+    throw new Error(
+      `Scale name ${scaleName} is incomplete. Make sure to use ":" instead of spaces, example: .scale("C:major")`,
+    );
   } else if (empty) {
-    throw new Error(`invalid scale "${scale}"`);
+    throw new Error(`Invalid scale name "${scaleName}"`);
   }
+  return scale;
+}
+
+function scaleStep(step, scale) {
+  step = Math.ceil(step);
+  let { intervals, tonic } = getScale(scale);
   tonic = tonic || 'C';
   const { pc, oct = 3 } = Note.get(tonic);
   const octaveOffset = Math.floor(step / intervals.length);
@@ -30,8 +39,7 @@ function scaleStep(step, scale) {
 // transpose note inside scale by offset steps
 // function scaleOffset(scale: string, offset: number, note: string) {
 function scaleOffset(scale, offset, note) {
-  let [tonic, scaleName] = Scale.tokenize(scale);
-  let { notes } = Scale.get(`${tonic} ${scaleName}`);
+  let { notes } = getScale(scale);
   notes = notes.map((note) => Note.get(note).pc); // use only pc!
   offset = Number(offset);
   if (isNaN(offset)) {
@@ -88,13 +96,14 @@ function scaleOffset(scale, offset, note) {
  * @returns Pattern
  * @memberof Pattern
  * @name transpose
+ * @synonyms trans
  * @example
  * "c2 c3".fast(2).transpose("<0 -2 5 3>".slow(2)).note()
  * @example
  * "c2 c3".fast(2).transpose("<1P -2M 4P 3m>".slow(2)).note()
  */
 
-export const transpose = register('transpose', function (intervalOrSemitones, pat) {
+export const { transpose, trans } = register(['transpose', 'trans'], function transposeFn(intervalOrSemitones, pat) {
   return pat.withHap((hap) => {
     const note = hap.value.note ?? hap.value;
     if (typeof note === 'number') {
@@ -119,10 +128,7 @@ export const transpose = register('transpose', function (intervalOrSemitones, pa
     const interval = !isNaN(Number(intervalOrSemitones))
       ? Interval.fromSemitones(intervalOrSemitones)
       : String(intervalOrSemitones);
-    // TODO: move simplify to player to preserve enharmonics
-    // tone.js doesn't understand multiple sharps flats e.g. F##3 has to be turned into G3
-    // TODO: check if this is still relevant..
-    const targetNote = Note.simplify(Note.transpose(note, interval));
+    const targetNote = Note.transpose(note, interval);
     if (typeof hap.value === 'object') {
       return hap.withValue(() => ({ ...hap.value, note: targetNote }));
     }
@@ -142,6 +148,7 @@ export const transpose = register('transpose', function (intervalOrSemitones, pa
  * @name scaleTranspose
  * @param {offset} offset number of steps inside the scale
  * @returns Pattern
+ * @synonyms scaleTrans, strans
  * @example
  * "-8 [2,4,6]"
  * .scale('C4 bebop major')
@@ -149,25 +156,79 @@ export const transpose = register('transpose', function (intervalOrSemitones, pa
  * .note()
  */
 
-export const scaleTranspose = register('scaleTranspose', function (offset /* : number | string */, pat) {
-  return pat.withHap((hap) => {
-    if (!hap.context.scale) {
-      throw new Error('can only use scaleTranspose after .scale');
+export const { scaleTranspose, scaleTrans, strans } = register(
+  ['scaleTranspose', 'scaleTrans', 'strans'],
+  function (offset /* : number | string */, pat) {
+    return pat.withHap((hap) => {
+      if (!hap.context.scale) {
+        throw new Error('can only use scaleTranspose after .scale');
+      }
+      if (typeof hap.value === 'object')
+        return hap.withValue(() => ({
+          ...hap.value,
+          note: scaleOffset(hap.context.scale, Number(offset), hap.value.note),
+        }));
+      if (typeof hap.value !== 'string') {
+        throw new Error('can only use scaleTranspose with notes');
+      }
+      return hap.withValue(() => scaleOffset(hap.context.scale, Number(offset), hap.value));
+    });
+  },
+);
+
+// Converts a step value, which is a number optionally decorated with sharps and flats,
+// to a number and an `offset` number of semitones
+function _convertStepToNumberAndOffset(step) {
+  let asNumber = Number(step);
+  let offset = 0;
+  if (isNaN(asNumber)) {
+    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);
+
+    if (!match) {
+      throw new Error(`invalid scale step "${step}", expected number or integer with optional # b suffixes`);
     }
-    if (typeof hap.value === 'object')
-      return hap.withValue(() => ({
-        ...hap.value,
-        note: scaleOffset(hap.context.scale, Number(offset), hap.value.note),
-      }));
-    if (typeof hap.value !== 'string') {
-      throw new Error('can only use scaleTranspose with notes');
-    }
-    return hap.withValue(() => scaleOffset(hap.context.scale, Number(offset), hap.value));
-  });
-});
+    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;
+  }
+  return [asNumber, offset];
+}
+
+let scaleToMidisAndNotes = {};
+// Finds the nearest scale note to `note`
+function _getNearestScaleNote(scaleName, note, preferHigher = true) {
+  let noteMidi = typeof note === 'string' ? noteToMidi(note) : note;
+  if (scaleToMidisAndNotes[scaleName] === undefined) {
+    const { intervals, tonic } = getScale(scaleName);
+    const { pc } = Note.get(tonic);
+    const expandedIntervals = intervals.concat('8P'); // add the octave for wrapping
+    const sNotes = expandedIntervals.map((interval) => Note.transpose(pc + '0', interval));
+    const sMidi = sNotes.map(noteToMidi);
+    // Cache
+    scaleToMidisAndNotes[scaleName] = [sMidi, sNotes];
+  }
+  const [scaleMidis, scaleNotes] = scaleToMidisAndNotes[scaleName];
+  const rootMidi = scaleMidis[0];
+  const octaveDiff = Math.floor((noteMidi - rootMidi) / 12);
+  const alignedMidis = scaleMidis.map((m) => m + 12 * octaveDiff);
+  const noteIdx = nearestNumberIndex(noteMidi, alignedMidis, preferHigher);
+  const noteMatch = scaleNotes[noteIdx];
+  return Note.transpose(noteMatch, Interval.fromSemitones(12 * octaveDiff));
+}
 
 /**
- * Turns numbers into notes in the scale (zero indexed). Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
+ * 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.
+ *
+ * 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).
  *
@@ -186,6 +247,12 @@ export const scaleTranspose = register('scaleTranspose', function (offset /* : n
  * n(rand.range(0,12).segment(8))
  * .scale("C:ritusen")
  * .s("piano")
+ * @example
+ * n("<[0,7b] [-4# -4] [-2,7##] 4 [0,7] [-4# -4b] [-2,7###] 4b>*4")
+ * .scale("C:<major minor>/2")
+ * .s("piano")
+ * @example
+ * note("C1*16").transpose(irand(36)).scale('Cb2 major').scaleTranspose(3)
  */
 
 export const scale = register(
@@ -199,49 +266,35 @@ export const scale = register(
       pat
         .fmap((value) => {
           const isObject = typeof value === 'object';
-          let step = isObject ? value.n : value;
-          if (isObject) {
+          // 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);
-          }
-          let asNumber = Number(step);
-          let semitones = 0;
-          if (isNaN(asNumber)) {
-            step = String(step);
-            if (!/^[-+]?\d+(#*|b*){1}$/.test(step)) {
-              logger(
-                `[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`,
-                'error',
-              );
+            if (isNote(step)) {
+              // legacy..
+              return pure(step);
+            }
+            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;
             }
-            const isharp = step.indexOf('#');
-            if (isharp >= 0) {
-              asNumber = Number(step.substring(0, isharp));
-              semitones = step.length - isharp;
-            } else {
-              const iflat = step.indexOf('b');
-              asNumber = Number(step.substring(0, iflat));
-              semitones = iflat - step.length;
-            }
+            return value;
           }
-          try {
-            let note;
-            if (isObject && value.anchor) {
-              note = stepInNamedScale(asNumber, scale, value.anchor);
-            } else {
-              note = scaleStep(asNumber, scale);
-            }
-            if (semitones != 0) note = Note.transpose(note, Interval.fromSemitones(semitones));
-            value = pure(isObject ? { ...value, note } : note);
-          } catch (err) {
-            logger(`[tonal] ${err.message}`, 'error');
-            value = silence;
+          // The case where the note has been defined via `note`
+          else {
+            const note = _getNearestScaleNote(scale, value.note);
+            return pure(isObject ? { ...value, note } : note);
           }
-          return value;
         })
         .outerJoin()
         // legacy:

packages/tonal/tonleiter.mjs

@@ -101,11 +101,11 @@ export function nearestNumberIndex(target, numbers, preferHigher) {
 let scaleSteps = {}; // [scaleName]: semitones[]
 
 export function stepInNamedScale(step, scale, anchor, preferHigher) {
-  let [root, scaleName] = Scale.tokenize(scale);
+  const [root, scaleName] = Scale.tokenize(scale);
   const rootMidi = x2midi(root);
   const rootChroma = midi2chroma(rootMidi);
   if (!scaleSteps[scaleName]) {
-    let { intervals } = Scale.get(`C ${scaleName}`);
+    const { intervals } = Scale.get(`C ${scaleName}`);
     // cache result
     scaleSteps[scaleName] = intervals.map(step2semitones);
   }
@@ -222,6 +222,7 @@ export const Note = {
 };
 
 // TODO: support octave numbers
+// Example: Note("Bb3").transpose("c3")
 export function transpose(note, step) {
   // example: E, 3
   const stepNumber = Step.tokenize(step)[1]; // 3
@@ -235,5 +236,3 @@ export function transpose(note, step) {
   const offsetAccidentals = accidentalString(Step.accidentals(step) + Note.accidentals(note) + stepIndex - indexOffset); // "we need to add a # to to the G to make it a major third from E"
   return [targetNote, offsetAccidentals].join('');
 }
-
-//Note("Bb3").transpose("c3")

packages/transpiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/transpiler",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Transpiler for strudel user code. Converts syntactically correct but semantically meaningless JS into evaluatable strudel code.",
   "main": "index.mjs",
   "type": "module",

packages/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/web",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Easy to setup, opiniated bundle of Strudel for the browser.",
   "module": "web.mjs",
   "publishConfig": {

packages/webaudio/index.mjs

@@ -7,4 +7,5 @@ This program is free software: you can redistribute it and/or modify it under th
 export * from './webaudio.mjs';
 export * from './scope.mjs';
 export * from './spectrum.mjs';
+export * from './supradough.mjs';
 export * from 'superdough';

packages/webaudio/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/webaudio",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Web Audio helpers for Strudel",
   "main": "index.mjs",
   "type": "module",
@@ -35,7 +35,8 @@
   "dependencies": {
     "@strudel/core": "workspace:*",
     "@strudel/draw": "workspace:*",
-    "superdough": "workspace:*"
+    "superdough": "workspace:*",
+    "supradough": "workspace:*"
   },
   "devDependencies": {
     "vite": "^6.0.11"

packages/webaudio/supradough.mjs

@@ -0,0 +1,130 @@
+import { Pattern } from '@strudel/core';
+import { connectToDestination, getAudioContext, getWorklet } from 'superdough';
+
+let doughWorklet;
+
+function initDoughWorklet() {
+  const ac = getAudioContext();
+  doughWorklet = getWorklet(
+    ac,
+    'dough-processor',
+    {},
+    {
+      outputChannelCount: [2],
+    },
+  );
+  connectToDestination(doughWorklet); // channels?
+}
+
+const soundMap = new Map();
+const loadedSounds = new Map();
+
+Pattern.prototype.supradough = function () {
+  return this.onTrigger((hap, __, cps, begin) => {
+    hap.value._begin = begin;
+    hap.value._duration = hap.duration / cps;
+    !doughWorklet && initDoughWorklet();
+    const s = (hap.value.bank ? hap.value.bank + '_' : '') + hap.value.s;
+    const n = hap.value.n ?? 0;
+    const soundKey = `${s}:${n}`;
+    if (soundMap.has(s)) {
+      hap.value.s = soundKey; // dough.mjs is unaware of bank and n (only maps keys to buffers)
+    }
+    if (soundMap.has(s) && !loadedSounds.has(soundKey)) {
+      const urls = soundMap.get(s);
+      const url = urls[n % urls.length];
+      console.log(`load ${soundKey} from ${url}`);
+      const loadSample = fetchSample(url);
+      loadedSounds.set(soundKey, loadSample);
+      loadSample.then(({ channels, sampleRate }) =>
+        doughWorklet.port.postMessage({
+          sample: soundKey,
+          channels,
+          sampleRate,
+        }),
+      );
+    }
+
+    doughWorklet.port.postMessage({ spawn: hap.value });
+  }, 1);
+};
+
+function githubPath(base, subpath = '') {
+  if (!base.startsWith('github:')) {
+    throw new Error('expected "github:" at the start of pseudoUrl');
+  }
+  let [_, path] = base.split('github:');
+  path = path.endsWith('/') ? path.slice(0, -1) : path;
+  if (path.split('/').length === 2) {
+    // assume main as default branch if none set
+    path += '/main';
+  }
+  return `https://raw.githubusercontent.com/${path}/${subpath}`;
+}
+export async function fetchSampleMap(url) {
+  if (url.startsWith('github:')) {
+    url = githubPath(url, 'strudel.json');
+  }
+  if (url.startsWith('local:')) {
+    url = `http://localhost:5432`;
+  }
+  if (url.startsWith('shabda:')) {
+    let [_, path] = url.split('shabda:');
+    url = `https://shabda.ndre.gr/${path}.json?strudel=1`;
+  }
+  if (url.startsWith('shabda/speech')) {
+    let [_, path] = url.split('shabda/speech');
+    path = path.startsWith('/') ? path.substring(1) : path;
+    let [params, words] = path.split(':');
+    let gender = 'f';
+    let language = 'en-GB';
+    if (params) {
+      [language, gender] = params.split('/');
+    }
+    url = `https://shabda.ndre.gr/speech/${words}.json?gender=${gender}&language=${language}&strudel=1'`;
+  }
+  if (typeof fetch !== 'function') {
+    // not a browser
+    return;
+  }
+  const base = url.split('/').slice(0, -1).join('/');
+  if (typeof fetch === 'undefined') {
+    // skip fetch when in node / testing
+    return;
+  }
+  const json = await fetch(url)
+    .then((res) => res.json())
+    .catch((error) => {
+      console.error(error);
+      throw new Error(`error loading "${url}"`);
+    });
+  return [json, json._base || base];
+}
+
+// for some reason, only piano and flute work.. is it because mp3??
+
+async function fetchSample(url) {
+  const buffer = await fetch(url)
+    .then((res) => res.arrayBuffer())
+    .then((buf) => getAudioContext().decodeAudioData(buf));
+  let channels = [];
+  for (let i = 0; i < buffer.numberOfChannels; i++) {
+    channels.push(buffer.getChannelData(i));
+  }
+  return { channels, sampleRate: buffer.sampleRate };
+}
+
+export async function doughsamples(sampleMap, baseUrl) {
+  if (typeof sampleMap === 'string') {
+    const [json, base] = await fetchSampleMap(sampleMap);
+    // console.log('json', json, 'base', base);
+    return doughsamples(json, base);
+  }
+  Object.entries(sampleMap).map(async ([key, urls]) => {
+    if (key !== '_base') {
+      urls = urls.map((url) => baseUrl + url);
+      // console.log('set', key, urls);
+      soundMap.set(key, urls);
+    }
+  });
+}

packages/webaudio/webaudio.mjs

@@ -5,7 +5,12 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import * as strudel from '@strudel/core';
-import { superdough, getAudioContext, setLogger, doughTrigger } from 'superdough';
+import { superdough, getAudioContext, setLogger, doughTrigger, registerWorklet } from 'superdough';
+import './supradough.mjs';
+import { workletUrl } from 'supradough';
+
+registerWorklet(workletUrl);
+
 const { Pattern, logger, repl } = strudel;
 
 setLogger(logger);

packages/xen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strudel/xen",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Xenharmonic API for strudel",
   "main": "index.mjs",
   "type": "module",

packages/xen/tunejs.js

@@ -139,10 +139,10 @@ Tune.prototype.MIDI = function(stepIn,octaveIn) {
 
 /* Load a new scale */
 
-Tune.prototype.loadScale = function(name){
+Tune.prototype.loadScale = function(scale){
 
 	/* load the scale */
-	var freqs = TuningList[name].frequencies
+	var freqs = isArrayOfNumbers(scale) ? scale : TuningList[scale].frequencies
 	this.scale = []
 	for (var i=0;i<freqs.length-1;i++) {
 		this.scale.push(freqs[i]/freqs[0])
@@ -207,8 +207,13 @@ Tune.prototype.search = function(letters) {
 	return possible
 }
 
-Tune.prototype.isValidScale = function(name) {
-  return !!TuningList[name];
+function isArrayOfNumbers(arg) {
+    return Array.isArray(arg) && arg.length > 0 && arg.every(item => typeof item === 'number' && !isNaN(item));
+}
+
+/* allow an array of values too */
+Tune.prototype.isValidScale = function(scale) {
+  return !!TuningList[scale] || isArrayOfNumbers(scale) ;
 }
 
 /* Return a collection of notes as an array */

pnpm-lock.yaml

@@ -201,8 +201,8 @@ importers:
         specifier: ^6.1.0
         version: 6.1.0(@codemirror/autocomplete@6.18.4)(@codemirror/commands@6.8.0)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)
       '@replit/codemirror-vim':
-        specifier: ^6.2.1
-        version: 6.2.1(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)
+        specifier: ^6.3.0
+        version: 6.3.0(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)
       '@replit/codemirror-vscode-keymap':
         specifier: ^6.0.2
         version: 6.0.2(@codemirror/autocomplete@6.18.4)(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/lint@6.8.4)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)
@@ -517,6 +517,18 @@ importers:
         specifier: workspace:*
         version: link:../vite-plugin-bundle-audioworklet
 
+  packages/supradough:
+    devDependencies:
+      vite:
+        specifier: ^6.0.11
+        version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+      vite-plugin-bundle-audioworklet:
+        specifier: workspace:*
+        version: link:../vite-plugin-bundle-audioworklet
+      wav-encoder:
+        specifier: ^1.3.0
+        version: 1.3.0
+
   packages/tidal:
     dependencies:
       '@strudel/core':
@@ -625,6 +637,9 @@ importers:
       superdough:
         specifier: workspace:*
         version: link:../superdough
+      supradough:
+        specifier: workspace:*
+        version: link:../supradough
     devDependencies:
       vite:
         specifier: ^6.0.11
@@ -2232,14 +2247,14 @@ packages:
       '@codemirror/state': ^6.0.1
       '@codemirror/view': ^6.3.0
 
-  '@replit/codemirror-vim@6.2.1':
-    resolution: {integrity: sha512-qDAcGSHBYU5RrdO//qCmD8K9t6vbP327iCj/iqrkVnjbrpFhrjOt92weGXGHmTNRh16cUtkUZ7Xq7rZf+8HVow==}
+  '@replit/codemirror-vim@6.3.0':
+    resolution: {integrity: sha512-aTx931ULAMuJx6xLf7KQDOL7CxD+Sa05FktTDrtLaSy53uj01ll3Zf17JdKsriER248oS55GBzg0CfCTjEneAQ==}
     peerDependencies:
-      '@codemirror/commands': ^6.0.0
-      '@codemirror/language': ^6.1.0
-      '@codemirror/search': ^6.2.0
-      '@codemirror/state': ^6.0.1
-      '@codemirror/view': ^6.0.3
+      '@codemirror/commands': 6.x.x
+      '@codemirror/language': 6.x.x
+      '@codemirror/search': 6.x.x
+      '@codemirror/state': 6.x.x
+      '@codemirror/view': 6.x.x
 
   '@replit/codemirror-vscode-keymap@6.0.2':
     resolution: {integrity: sha512-j45qTwGxzpsv82lMD/NreGDORFKSctMDVkGRopaP+OrzSzv+pXDQuU3LnFvKpasyjVT0lf+PKG1v2DSCn/vxxg==}
@@ -5714,6 +5729,7 @@ packages:
   node-domexception@1.0.0:
     resolution: {integrity: sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==}
     engines: {node: '>=10.5.0'}
+    deprecated: Use your platform's native DOMException instead
 
   node-fetch-native@1.6.6:
     resolution: {integrity: sha512-8Mc2HhqPdlIfedsuZoc3yioPuzp6b+L5jRCRY1QzuWZh2EGJVQrGppC6V6cF0bLdbW0+O2YpqCA25aF/1lvipQ==}
@@ -6803,6 +6819,7 @@ packages:
   source-map@0.8.0-beta.0:
     resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==}
     engines: {node: '>= 8'}
+    deprecated: The work that was done in this beta branch won't be included in future versions
 
   sourcemap-codec@1.4.8:
     resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==}
@@ -7535,6 +7552,9 @@ packages:
   walk-up-path@3.0.1:
     resolution: {integrity: sha512-9YlCL/ynK3CTlrSRrDxZvUauLzAswPCrsaCgilqFevUYpeEW0/3ScEjaa3kbW/T0ghhkEr7mv+fpjqn1Y1YuTA==}
 
+  wav-encoder@1.3.0:
+    resolution: {integrity: sha512-FXJdEu2qDOI+wbVYZpu21CS1vPEg5NaxNskBr4SaULpOJMrLE6xkH8dECa7PiS+ZoeyvP7GllWUAxPN3AvFSEw==}
+
   wav@1.0.2:
     resolution: {integrity: sha512-viHtz3cDd/Tcr/HbNqzQCofKdF6kWUymH9LGDdskfWFoIy/HJ+RTihgjEcHfnsy1PO4e9B+y4HwgTwMrByquhg==}
 
@@ -7657,6 +7677,7 @@ packages:
 
   workbox-google-analytics@7.0.0:
     resolution: {integrity: sha512-MEYM1JTn/qiC3DbpvP2BVhyIH+dV/5BjHk756u9VbwuAhu0QHyKscTnisQuz21lfRpOwiS9z4XdqeVAKol0bzg==}
+    deprecated: It is not compatible with newer versions of GA starting with v4, as long as you are using GAv3 it should be ok, but the package is not longer being maintained
 
   workbox-navigation-preload@7.0.0:
     resolution: {integrity: sha512-juWCSrxo/fiMz3RsvDspeSLGmbgC0U9tKqcUPZBCf35s64wlaLXyn2KdHHXVQrb2cqF7I0Hc9siQalainmnXJA==}
@@ -9595,7 +9616,7 @@ snapshots:
       '@codemirror/state': 6.5.1
       '@codemirror/view': 6.36.2
 
-  '@replit/codemirror-vim@6.2.1(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)':
+  '@replit/codemirror-vim@6.3.0(@codemirror/commands@6.8.0)(@codemirror/language@6.10.8)(@codemirror/search@6.5.8)(@codemirror/state@6.5.1)(@codemirror/view@6.36.2)':
     dependencies:
       '@codemirror/commands': 6.8.0
       '@codemirror/language': 6.10.8
@@ -15955,6 +15976,8 @@ snapshots:
 
   walk-up-path@3.0.1: {}
 
+  wav-encoder@1.3.0: {}
+
   wav@1.0.2:
     dependencies:
       buffer-alloc: 1.2.0

website/package.json

@@ -8,8 +8,7 @@
     "start": "astro dev",
     "build": "astro build",
     "preview": "astro preview --port 3009 --host 0.0.0.0",
-    "astro": "astro",
-    "postinstall": "cp node_modules/hs2js/dist/tree-sitter.wasm public && cp node_modules/hs2js/dist/tree-sitter-haskell.wasm public"
+    "astro": "astro"
   },
   "dependencies": {
     "@algolia/client-search": "^5.20.0",

website/public/encoder_disc.svg

@@ -0,0 +1,155 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 12.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+
+<svg
+   version="1.0"
+   id="Layer_1"
+   width="284.46"
+   height="284.46"
+   viewBox="0 0 284.46 284.46"
+   overflow="visible"
+   enable-background="new 0 0 284.46 284.46"
+   xml:space="preserve"
+   sodipodi:version="0.32"
+   inkscape:version="1.4 (1:1.4+202410161351+e7c3feb100)"
+   sodipodi:docname="encoder_disc.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/"><metadata
+   id="metadata2068"><rdf:RDF><cc:Work
+       rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+         rdf:resource="http://purl.org/dc/dcmitype/StillImage" /></cc:Work></rdf:RDF></metadata><defs
+   id="defs2066">
+	
+
+		
+	
+			
+			
+		
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+			
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+			</defs><sodipodi:namedview
+   inkscape:window-height="1131"
+   inkscape:window-width="1920"
+   inkscape:pageshadow="2"
+   inkscape:pageopacity="0.0"
+   borderopacity="1.0"
+   bordercolor="#666666"
+   pagecolor="#ffffff"
+   id="base"
+   inkscape:zoom="1.0549412"
+   inkscape:cx="195.27154"
+   inkscape:cy="-101.90141"
+   inkscape:window-x="0"
+   inkscape:window-y="0"
+   inkscape:current-layer="Layer_1"
+   inkscape:showpageshadow="2"
+   inkscape:pagecheckerboard="0"
+   inkscape:deskcolor="#d1d1d1"
+   inkscape:window-maximized="1" />
+<path
+   id="path1"
+   style="fill:#f9f9f9;stroke:none;stroke-width:1.23072"
+   d="M 142.22902,0.61574073 A 141.61462,141.61462 0 0 0 0.61574173,142.22901 141.61462,141.61462 0 0 0 142.22902,283.84425 141.61462,141.61462 0 0 0 283.84425,142.22901 141.61462,141.61462 0 0 0 142.22902,0.61574073 Z m 0,106.22069927 a 35.393924,35.393924 0 0 1 35.39453,35.39257 35.393924,35.393924 0 0 1 -35.39453,35.39455 35.393924,35.393924 0 0 1 -35.39258,-35.39455 35.393924,35.393924 0 0 1 35.39258,-35.39257 z" /><g
+   id="g2"><path
+     d="M 242.47,41.99 242.441,42.02 217.4,67.06 C 198.17,47.83 171.589,35.93 142.23,35.93 V 0.5 c 39.17,0 74.6,15.85 100.24,41.49 z"
+     id="path2015" /><path
+     d="m 142.23,0.5 v 35.43 c -29.37,0 -55.93,11.89 -75.17,31.13 L 42.02,42.02 41.99,41.99 C 67.63,16.35 103.06,0.5 142.23,0.5 Z"
+     id="path2017" /><path
+     d="m 142.23,35.93 v 35.43 c -19.59,0 -37.3,7.92 -50.12,20.75 L 67.06,67.06 C 86.3,47.82 112.86,35.93 142.23,35.93 Z"
+     id="path2019" /><path
+     d="M 67.06,67.06 92.11,92.11 C 79.28,104.93 71.36,122.64 71.36,142.23 H 35.93 c 0,-29.36 11.89,-55.94 31.13,-75.17 z"
+     id="path2021" /><path
+     d="M 92.11,192.35 67.06,217.4 C 47.82,198.171 35.93,171.59 35.93,142.23 h 35.43 c 0,19.589 7.92,37.3 20.75,50.12 z"
+     id="path2023" /><path
+     d="m 142.23,213.09 v 35.44 c -29.37,0 -55.93,-11.891 -75.17,-31.131 l 25.05,-25.05 c 12.82,12.821 30.53,20.741 50.12,20.741 z"
+     id="path2025" /><path
+     d="m 142.23,248.53 v 35.43 c -39.17,0 -74.6,-15.851 -100.24,-41.49 l 0.03,-0.03 25.04,-25.04 c 19.24,19.24 45.8,31.13 75.17,31.13 z"
+     id="path2027" /><path
+     d="m 142.23,283.96 v -35.43 c 29.36,0 55.94,-11.9 75.17,-31.131 l 25.04,25.04 0.029,0.03 C 216.83,268.109 181.4,283.96 142.23,283.96 Z"
+     id="path2029" /><path
+     d="m 177.66,142.229 h 35.43 c 0,19.59 -7.92,37.301 -20.74,50.12 L 167.3,167.3 c 6.4,-6.401 10.36,-15.25 10.36,-25.071 z"
+     id="path2031" /><path
+     d="m 167.3,167.3 25.05,25.05 c -12.819,12.82 -30.529,20.74 -50.12,20.74 v -35.43 c 9.8,0 18.66,-3.95 25.07,-10.36 z"
+     id="path2033" /><path
+     d="m 142.23,177.66 v 35.43 c -19.59,0 -37.3,-7.92 -50.12,-20.74 l 25.05,-25.04 c 6.42,6.41 15.28,10.35 25.07,10.35 z"
+     id="path2035" /><path
+     d="m 117.16,167.3 v 0.01 L 92.11,192.35 C 79.28,179.531 71.36,161.82 71.36,142.23 h 35.43 c 0,9.82 3.96,18.669 10.37,25.07 z"
+     id="path2037" /><path
+     fill="none"
+     stroke="#000000"
+     d="m 142.23,283.96 c -39.17,0 -74.6,-15.851 -100.24,-41.49 C 16.35,216.83 0.5,181.399 0.5,142.229 0.5,103.059 16.35,67.629 41.99,41.989 67.63,16.35 103.06,0.5 142.23,0.5 c 39.17,0 74.6,15.85 100.24,41.49 25.641,25.64 41.49,61.07 41.49,100.24 0,39.17 -15.85,74.601 -41.49,100.24 -25.64,25.639 -61.07,41.49 -100.24,41.49 z"
+     id="path2041" /><path
+     fill="none"
+     stroke="#000000"
+     d="m 248.53,142.229 c 0,-29.35 -11.891,-55.93 -31.13,-75.17 -19.23,-19.23 -45.811,-31.13 -75.17,-31.13 -29.37,0 -55.93,11.89 -75.17,31.13 -19.24,19.23 -31.13,45.81 -31.13,75.17 0,29.36 11.89,55.94 31.13,75.17 19.24,19.24 45.8,31.131 75.17,31.131 29.36,0 55.94,-11.9 75.17,-31.131 19.24,-19.239 31.13,-45.819 31.13,-75.17 z"
+     id="path2043" /><path
+     fill="none"
+     stroke="#000000"
+     d="m 142.23,213.09 c -19.59,0 -37.3,-7.92 -50.12,-20.74 -12.83,-12.819 -20.75,-30.53 -20.75,-50.12 0,-19.59 7.92,-37.3 20.75,-50.12 12.82,-12.83 30.53,-20.75 50.12,-20.75 19.59,0 37.3,7.92 50.12,20.75 12.82,12.82 20.74,30.53 20.74,50.12 0,19.59 -7.92,37.301 -20.74,50.12 -12.82,12.82 -30.53,20.74 -50.12,20.74 z"
+     id="path2045" /><path
+     fill="none"
+     stroke="#000000"
+     d="m 117.16,167.31 c 6.42,6.41 15.28,10.351 25.07,10.351 9.8,0 18.66,-3.95 25.07,-10.36 6.4,-6.4 10.36,-15.25 10.36,-25.07 0,-9.819 -3.95,-18.67 -10.36,-25.07 -6.399,-6.41 -15.27,-10.36 -25.07,-10.36 -9.8,0 -18.66,3.95 -25.08,10.35 -6.4,6.4 -10.36,15.26 -10.36,25.08 0,9.82 3.96,18.67 10.37,25.07"
+     id="path2047" /><path
+     id="polyline2049"
+     style="fill:none;stroke:#000000"
+     d="m 142.23,177.66 v 35.43 35.44 35.43"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2051"
+     style="fill:none;stroke:#000000"
+     d="m 167.3,167.3 25.05,25.05 25.05,25.049 25.04,25.04"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2053"
+     style="fill:none;stroke:#000000"
+     d="m 177.66,142.229 h 35.43 35.44 35.43"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2055"
+     style="fill:none;stroke:#000000"
+     d="M 167.3,117.16 192.35,92.11 217.4,67.06 242.44,42.02"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2057"
+     style="fill:none;stroke:#000000"
+     d="M 142.23,106.8 V 71.36 35.93 0.5"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2059"
+     style="fill:none;stroke:#000000"
+     d="M 117.15,117.15 92.11,92.11 67.06,67.06 42.02,42.02"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2061"
+     style="fill:none;stroke:#000000"
+     d="M 106.79,142.229 H 71.36 35.93 0.5"
+     sodipodi:nodetypes="cccc" /><path
+     id="polyline2063"
+     style="fill:none;stroke:#000000"
+     d="m 117.16,167.3 v 0.01 l -25.05,25.04 -25.05,25.049 -25.04,25.04"
+     sodipodi:nodetypes="ccccc" /></g>
+</svg>

website/public/fonts/tic80/license.txt

@@ -0,0 +1,5 @@
+The FontStruction “TIC-80 wide font”
+(https://fontstruct.com/fontstructions/show/1388526) by “nesbox” is licensed
+under a Creative Commons CC0 Public Domain Dedication license
+(http://creativecommons.org/publicdomain/zero/1.0/).
+[ancestry]