run prettier linter

fix download button, was returning undefined as file contents
code review
2026-07-22 13:13:10 -04:00 · 2025-06-01 09:07:49 -07:00 · 2025-05-31 15:08:45 -07:00 · 2025-05-31 14:47:51 -07:00 · 2025-05-31 14:31:13 -07:00 · 2025-05-29 22:27:48 -07:00
131 changed files with 4505 additions and 1032 deletions
@@ -1,62 +0,0 @@
-name: Tauri Builder
-on:
-  push:
-    tags:
-      - "v*"
-  workflow_dispatch:
-
-jobs:
-  release:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [macos-latest, ubuntu-latest, windows-latest]
-        include:
-          - os: ubuntu-latest
-            rust_target: x86_64-unknown-linux-gnu
-          - os: macos-latest
-            rust_target: x86_64-apple-darwin
-          - os: macos-latest
-            rust_target: aarch64-apple-darwin
-          - os: windows-latest
-            rust_target: x86_64-pc-windows-msvc
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8.6.2
-
-      - name: Node.js setup
-        uses: actions/setup-node@v3
-        with:
-          node-version: latest
-          # node-version-file: '.nvmrc'
-
-      - name: Install Rust (Stable)
-        run:
-          curl https://sh.rustup.rs -sSf | sh -s -- -y
-
-      - name: Install dependencies (ubuntu only)
-        if: matrix.platform == 'ubuntu-latest'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf libasound2-dev
-
-      - name: Install app dependencies from lockfile and build web
-        run: pnpm install
-
-      - name: Build the app
-        uses: tauri-apps/tauri-action@v0
-
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          # tauri-action replaces \_\_VERSION\_\_ with the app version
-          tagName: ${{ github.ref_name }}
-          releaseName: "Strudel v__VERSION__"
-          releaseBody: |
-            See the assets to download this version and install.
-          releaseDraft: true
-          prerelease: false
@@ -31,6 +31,10 @@ This project is organized into many [packages](./packages), which are also avail

 Read more about how to use these in your own project [here](https://strudel.cc/technical-manual/project-start).

+You will need to abide by the terms of the [GNU Affero Public Licence v3](LICENSE.md). As such, Strudel code can only be shared within free/open source projects under the same license -- see the license for details.
+
+Licensing info for the default sound banks can be found over on the [dough-samples](https://github.com/felixroos/dough-samples/blob/main/README.md) repository.
+
 ## Contributing

 There are many ways to contribute to this project! See [contribution guide](./CONTRIBUTING.md).
@@ -59,6 +59,7 @@
    "@eslint/eslintrc": "^3.2.0",
    "@eslint/js": "^9.19.0",
    "@tauri-apps/cli": "^2.2.7",
+    "@vitest/coverage-v8": "3.0.4",
    "@vitest/ui": "^3.0.4",
    "acorn": "^8.14.0",
    "dependency-tree": "^11.0.1",
@@ -70,6 +71,7 @@
    "jsdoc-json": "^2.0.2",
    "lerna": "^8.1.9",
    "prettier": "^3.4.2",
-    "vitest": "^3.0.4"
+    "vitest": "^3.0.4",
+    "vite-plugin-bundle-audioworklet": "workspace:*"
  }
 }
@@ -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 { dragDropPlugin } from './dragdrop.mjs';

 const extensions = {
  isLineWrappingEnabled: (on) => (on ? EditorView.lineWrapping : []),
@@ -67,6 +68,7 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
  const initialSettings = Object.keys(compartments).map((key) =>
    compartments[key].of(extensions[key](parseBooleans(settings[key]))),
  );
+
  initTheme(settings.theme);
  let state = EditorState.create({
    doc: initialCode,
@@ -77,6 +79,7 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
      javascript(),
      sliderPlugin,
      widgetPlugin,
+      dragDropPlugin,
      // indentOnInput(), // works without. already brought with javascript extension?
      // bracketMatching(), // does not do anything
      syntaxHighlighting(defaultHighlightStyle),
@@ -0,0 +1,112 @@
+import { ViewPlugin } from '@codemirror/view';
+import { logger } from '@strudel/core';
+
+// Helper function to read file content
+async function readFileContent(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => resolve(e.target.result);
+    reader.onerror = reject;
+    reader.readAsText(file);
+  });
+}
+
+// Check for common text file formats, to avoid
+// accidentally loading images or other files
+function isCodeFile(file) {
+  const codeExtensions = ['.js', '.strudel', '.str'];
+  const fileName = file.name.toLowerCase();
+  return codeExtensions.some((ext) => fileName.endsWith(ext)) || file.type.startsWith('text/');
+}
+
+// Create drag and drop extension
+export const dragDropPlugin = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      this.view = view;
+      this.handleDrop = this.handleDrop.bind(this);
+      this.handleDragOver = this.handleDragOver.bind(this);
+      this.handleDragEnter = this.handleDragEnter.bind(this);
+      this.handleDragLeave = this.handleDragLeave.bind(this);
+
+      // Add event listeners
+      view.dom.addEventListener('drop', this.handleDrop);
+      view.dom.addEventListener('dragover', this.handleDragOver);
+      view.dom.addEventListener('dragenter', this.handleDragEnter);
+      view.dom.addEventListener('dragleave', this.handleDragLeave);
+    }
+
+    handleDragOver(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      e.dataTransfer.dropEffect = 'copy';
+    }
+
+    handleDragEnter(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      this.view.dom.classList.add('cm-drag-over');
+    }
+
+    handleDragLeave(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      // Only remove the class if we're leaving the editor entirely
+      if (!this.view.dom.contains(e.relatedTarget)) {
+        this.view.dom.classList.remove('cm-drag-over');
+      }
+    }
+
+    async handleDrop(e) {
+      e.preventDefault();
+      e.stopPropagation();
+      this.view.dom.classList.remove('cm-drag-over');
+
+      const files = Array.from(e.dataTransfer.files);
+
+      // Filter for code files only
+      const codeFiles = files.filter(isCodeFile);
+
+      if (codeFiles.length === 0) {
+        logger('No code files were dropped. Please drop text-based files.', 'warning');
+        return;
+      }
+
+      try {
+        // Read all files
+        const fileContents = await Promise.all(
+          codeFiles.map(async (file) => {
+            const content = await readFileContent(file);
+            return `// File: ${file.name}\n${content}`;
+          }),
+        );
+
+        // Combine content
+        const newContent = fileContents.join('\n\n');
+
+        // Replace entire editor contents
+        this.view.dispatch({
+          changes: { from: 0, to: this.view.state.doc.length, insert: newContent },
+          selection: { anchor: newContent.length },
+        });
+
+        // Focus the editor
+        this.view.focus();
+
+        // Show success message
+        const fileNames = codeFiles.map((f) => f.name).join(', ');
+        logger(`Successfully loaded ${codeFiles.length} file(s): ${fileNames}`, 'highlight');
+      } catch (error) {
+        console.error('Error reading dropped files:', error);
+        logger(`Error loading files: ${error.message}`, 'error');
+      }
+    }
+
+    destroy() {
+      this.view.dom.removeEventListener('drop', this.handleDrop);
+      this.view.dom.removeEventListener('dragover', this.handleDragOver);
+      this.view.dom.removeEventListener('dragenter', this.handleDragEnter);
+      this.view.dom.removeEventListener('dragleave', this.handleDragLeave);
+    }
+  },
+);
@@ -11,7 +11,9 @@ export const flashField = StateField.define({
      for (let e of tr.effects) {
        if (e.is(setFlash)) {
          if (e.value && tr.newDoc.length > 0) {
-            const mark = Decoration.mark({ attributes: { style: `background-color: #FFCA2880` } });
+            const mark = Decoration.mark({
+              attributes: { style: `background-color: rgba(255,255,255, .4); filter: invert(10%)` },
+            });
            flash = Decoration.set([mark.range(0, tr.newDoc.length)]);
          } else {
            flash = Decoration.set([]);
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/codemirror",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Codemirror Extensions for Strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -4,16 +4,16 @@ import blackscreen, { settings as blackscreenSettings } from './themes/blackscre
 import whitescreen, { settings as whitescreenSettings } from './themes/whitescreen.mjs';
 import teletext, { settings as teletextSettings } from './themes/teletext.mjs';
 import algoboy, { settings as algoboySettings } from './themes/algoboy.mjs';
-import terminal, { settings as terminalSettings } from './themes/terminal.mjs';
-import abcdef, { settings as abcdefSettings } from './themes/abcdef.mjs';
+import CutiePi, { settings as CutiePiSettings } from './themes/CutiePi.mjs';
+import sonicPink, { settings as sonicPinkSettings } from './themes/sonic-pink.mjs';
+import redText, { settings as redTextSettings } from './themes/red-text.mjs';
+import greenText, { settings as greenTextSettings } from './themes/green-text.mjs';
 import androidstudio, { settings as androidstudioSettings } from './themes/androidstudio.mjs';
 import atomone, { settings as atomOneSettings } from './themes/atomone.mjs';
 import aura, { settings as auraSettings } from './themes/aura.mjs';
-import bespin, { settings as bespinSettings } from './themes/bespin.mjs';
 import darcula, { settings as darculaSettings } from './themes/darcula.mjs';
 import dracula, { settings as draculaSettings } from './themes/dracula.mjs';
 import duotoneDark, { settings as duotoneDarkSettings } from './themes/duotoneDark.mjs';
-import duotoneLight, { settings as duotoneLightSettings } from './themes/duotoneLight.mjs';
 import eclipse, { settings as eclipseSettings } from './themes/eclipse.mjs';
 import githubDark, { settings as githubDarkSettings } from './themes/githubDark.mjs';
 import githubLight, { settings as githubLightSettings } from './themes/githubLight.mjs';
@@ -31,51 +31,47 @@ import tokyoNightStorm, { settings as tokyoNightStormSettings } from './themes/t
 import tokyoNightDay, { settings as tokyoNightDaySettings } from './themes/tokyoNightDay.mjs';
 import vscodeDark, { settings as vscodeDarkSettings } from './themes/vscodeDark.mjs';
 import vscodeLight, { settings as vscodeLightSettings } from './themes/vscodeLight.mjs';
-// import xcodeDark, { settings as xcodeDarkSettings } from './themes/xcodeDark.mjs';
 import xcodeLight, { settings as xcodeLightSettings } from './themes/xcodeLight.mjs';
 import bbedit, { settings as bbeditSettings } from './themes/bbedit.mjs';
 import noctisLilac, { settings as noctisLilacSettings } from './themes/noctisLilac.mjs';

 import { setTheme } from '@strudel/draw';
-
 export const themes = {
  strudelTheme,
-  bluescreen,
-  blackscreen,
-  whitescreen,
-  teletext,
  algoboy,
+  androidstudio,
  atomone,
  aura,
+  bbedit,
+  blackscreen,
+  bluescreen,
+  CutiePi,
  darcula,
  dracula,
-  // todo: optimize
-  // bespin,
-  //abcdef,
-  androidstudio,
  duotoneDark,
+  eclipse,
  githubDark,
+  githubLight,
+  greenText,
  gruvboxDark,
+  gruvboxLight,
+  sonicPink,
  materialDark,
-  nord,
+  materialLight,
  monokai,
+  noctisLilac,
+  nord,
+  redText,
  solarizedDark,
+  solarizedLight,
  sublime,
+  teletext,
  tokyoNight,
+  tokyoNightDay,
  tokyoNightStorm,
  vscodeDark,
-  //xcodeDark,
-  // LIGHT
-  bbedit,
-  //duotoneLight,
-  eclipse,
-  githubLight,
-  gruvboxLight,
-  materialLight,
  vscodeLight,
-  noctisLilac,
-  solarizedLight,
-  tokyoNightDay,
+  whitescreen,
  xcodeLight,
 };

@@ -86,20 +82,19 @@ export const settings = {
  whitescreen: whitescreenSettings,
  teletext: teletextSettings,
  algoboy: algoboySettings,
-  terminal: terminalSettings,
-  abcdef: abcdefSettings,
  androidstudio: androidstudioSettings,
  atomone: atomOneSettings,
  aura: auraSettings,
  bbedit: bbeditSettings,
-  bespin: bespinSettings,
  darcula: darculaSettings,
  dracula: draculaSettings,
-  duotoneLight: duotoneLightSettings,
  duotoneDark: duotoneDarkSettings,
  eclipse: eclipseSettings,
+  CutiePi: CutiePiSettings,
+  sonicPink: sonicPinkSettings,
  githubLight: githubLightSettings,
  githubDark: githubDarkSettings,
+  greenText: greenTextSettings,
  gruvboxDark: gruvboxDarkSettings,
  gruvboxLight: gruvboxLightSettings,
  materialDark: materialDarkSettings,
@@ -107,6 +102,7 @@ export const settings = {
  noctisLilac: noctisLilacSettings,
  nord: nordSettings,
  monokai: monokaiSettings,
+  redText: redTextSettings,
  solarizedLight: solarizedLightSettings,
  solarizedDark: solarizedDarkSettings,
  sublime: sublimeSettings,
@@ -115,7 +111,6 @@ export const settings = {
  vscodeDark: vscodeDarkSettings,
  vscodeLight: vscodeLightSettings,
  xcodeLight: xcodeLightSettings,
-  //xcodeDark: xcodeDarkSettings,
  tokyoNightDay: tokyoNightDaySettings,
 };

@@ -0,0 +1,45 @@
+/*
+ * Cutie Pi
+ * by Switch Angel
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+const deepPurple = '#5c019a';
+const yellowPink = '#fbeffc';
+const grey = '#272C35';
+const pinkAccent = '#fee1ff';
+const lightGrey = '#465063';
+const bratGreen = '#9acd3f';
+const lighterGrey = '#97a1b7';
+const pink = '#f6a6fd';
+
+export const settings = {
+  background: 'white',
+  lineBackground: 'transparent',
+  foreground: deepPurple,
+  caret: '#797977',
+  selection: yellowPink,
+  selectionMatch: '#2B323D',
+  gutterBackground: grey,
+  gutterForeground: lightGrey,
+  gutterBorder: 'transparent',
+  lineHighlight: pinkAccent,
+};
+
+export default createTheme({
+  theme: 'light',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: deepPurple,
+    },
+    { tag: [t.tagName, t.heading], color: settings.foreground },
+    { tag: t.comment, color: lighterGrey },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: pink },
+    { tag: [t.attributeName, t.number], color: '#d19a66' },
+    { tag: t.className, color: grey },
+    { tag: t.keyword, color: deepPurple },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: bratGreen },
+  ],
+});
@@ -1,55 +0,0 @@
-/**
- * @name abcdef
- * @author codemirror.net
- * https://codemirror.net/5/theme/abcdef.css
- */
-import { tags as t } from '@lezer/highlight';
-import { createTheme } from './theme-helper.mjs';
-
-export const settings = {
-  background: '#0f0f0f',
-  lineBackground: '#0f0f0f99',
-  foreground: '#defdef',
-  caret: '#00FF00',
-  selection: '#515151',
-  selectionMatch: '#515151',
-  gutterBackground: '#555',
-  gutterForeground: '#FFFFFF',
-  lineHighlight: '#314151',
-};
-
-export default createTheme({
-  theme: 'dark',
-  settings: {
-    background: '#0f0f0f',
-    foreground: '#defdef',
-    caret: '#00FF00',
-    selection: '#515151',
-    selectionMatch: '#515151',
-    // gutterBackground: '#555',
-    gutterBackground: 'transparent',
-    /* gutterForeground: '#FFFFFF', */
-    gutterForeground: '#7a7b7c',
-    lineHighlight: '#0a6bcb3d',
-  },
-  styles: [
-    { tag: t.labelName, color: 'inherit' },
-    { tag: t.keyword, color: 'darkgoldenrod', fontWeight: 'bold' },
-    { tag: t.atom, color: '#77F' },
-    { tag: t.comment, color: '#7a7b7c', fontStyle: 'italic' },
-    { tag: t.number, color: 'violet' },
-    { tag: t.definition(t.variableName), color: '#fffabc' },
-    { tag: t.variableName, color: '#abcdef' },
-    { tag: t.function(t.variableName), color: '#fffabc' },
-    { tag: t.typeName, color: '#FFDD44' },
-    { tag: t.tagName, color: '#def' },
-    { tag: t.string, color: '#2b4' },
-    { tag: t.meta, color: '#C9F' },
-    // { tag: t.qualifier, color: '#FFF700' },
-    // { tag: t.builtin, color: '#30aabc' },
-    { tag: t.bracket, color: '#8a8a8a' },
-    { tag: t.attributeName, color: '#DDFF00' },
-    { tag: t.heading, color: 'aquamarine', fontWeight: 'bold' },
-    { tag: t.link, color: 'blueviolet', fontWeight: 'bold' },
-  ],
-});
@@ -54,6 +54,7 @@ export default createTheme({
      tag: [t.keyword, t.tagName, t.arithmeticOperator],
      color: palette[1],
    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: palette[0] },
    { tag: [t.function(t.variableName), t.propertyName], color: palette[0] },
    { tag: t.atom, color: palette[1] },
  ],
@@ -1,5 +1,5 @@
-/**
- * @name androidstudio
+/*
+ * androidstudio
 */
 import { tags as t } from '@lezer/highlight';
 import { createTheme } from './theme-helper.mjs';
@@ -1,5 +1,5 @@
-/**
- * @name Atom One
+/*
+ * Atom One
 * Atom One dark syntax theme
 *
 * https://github.com/atom/one-dark-syntax
@@ -38,12 +38,14 @@ export default createTheme({
      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
      color: 'hsl(207, 82%, 66%)',
    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: 'hsl( 29, 54%, 61%)' },
    { tag: [t.tagName, t.heading], color: '#e06c75' },
    { tag: t.comment, color: '#54636D' },
    { tag: [t.variableName, t.propertyName, t.labelName], color: 'hsl(220, 14%, 71%)' },
    { tag: [t.attributeName, t.number], color: 'hsl( 29, 54%, 61%)' },
    { tag: t.className, color: 'hsl( 39, 67%, 69%)' },
    { tag: t.keyword, color: 'hsl(286, 60%, 67%)' },
+
    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: '#98c379' },
  ],
 });
@@ -1,39 +0,0 @@
-// this is different from https://thememirror.net/bespin
-import { tags as t } from '@lezer/highlight';
-import { createTheme } from './theme-helper.mjs';
-
-export const settings = {
-  background: '#28211c',
-  lineBackground: '#28211c99',
-  foreground: '#9d9b97',
-  caret: '#797977',
-  selection: '#36312e',
-  selectionMatch: '#4f382b',
-  gutterBackground: '#28211c',
-  gutterForeground: '#666666',
-  lineHighlight: 'rgba(255, 255, 255, 0.1)',
-};
-export default createTheme({
-  theme: 'dark',
-  settings: {
-    background: '#28211c',
-    foreground: '#9d9b97',
-    caret: '#797977',
-    selection: '#4f382b',
-    selectionMatch: '#4f382b',
-    gutterBackground: '#28211c',
-    gutterForeground: '#666666',
-    lineHighlight: '#ffffff1a',
-  },
-  styles: [
-    { tag: [t.atom, t.number, t.link, t.bool], color: '#9b859d' },
-    { tag: t.comment, color: '#937121' },
-    { tag: [t.keyword, t.tagName], color: '#cf6a4c' },
-    { tag: t.string, color: '#f9ee98' },
-    { tag: t.bracket, color: '#9d9b97' },
-    { tag: [t.variableName], color: '#5ea6ea' },
-    { tag: t.definition(t.variableName), color: '#cf7d34' },
-    { tag: [t.function(t.variableName), t.className], color: '#cf7d34' },
-    { tag: [t.propertyName, t.attributeName], color: '#54be0d' },
-  ],
-});
@@ -1,6 +1,5 @@
-/**
- * @name darcula
- * @author darcula
+/*
+ * darcula
 * Name: IntelliJ IDEA darcula theme
 * From IntelliJ IDEA by JetBrains
 */
@@ -1,6 +1,5 @@
-/**
+/*
 * @name dracula
- * @author dracula
 * Michael Kaminsky (http://github.com/mkaminsky11)
 * Original dracula color scheme by Zeno Rocha (https://github.com/zenorocha/dracula-theme)
 */
@@ -1,6 +1,6 @@
-/**
- * @name duotone
- * @author Bram de Haan
+/*
+ * duotone
+ * author Bram de Haan
 * by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes)
 */
 import { tags as t } from '@lezer/highlight';
@@ -1,6 +1,6 @@
-/**
- * @name duotone
- * @author Bram de Haan
+/*
+ * duotone
+ * author Bram de Haan
 * by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes)
 */
 import { tags as t } from '@lezer/highlight';
@@ -1,6 +1,3 @@
-/**
- * @name github
- */
 import { tags as t } from '@lezer/highlight';
 import { createTheme } from './theme-helper.mjs';

@@ -1,6 +1,3 @@
-/**
- * @name github
- */
 import { tags as t } from '@lezer/highlight';
 import { createTheme } from './theme-helper.mjs';

@@ -0,0 +1,39 @@
+/*
+ * Atom One
+ * Atom One dark syntax theme
+ *
+ * https://github.com/atom/one-dark-syntax
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = ['#000000', '#8ed675', '#56bd2a', '#54636D', '#171717'];
+
+export const settings = {
+  background: hex[0],
+  lineBackground: 'transparent',
+  foreground: hex[2],
+  selection: hex[4],
+  selectionMatch: hex[0],
+  gutterBackground: hex[0],
+  gutterForeground: hex[3],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[0],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[2],
+    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: hex[1] },
+    { tag: t.comment, color: hex[3] },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: hex[2] },
+    { tag: [t.attributeName, t.number], color: hex[1] },
+    { tag: t.keyword, color: hex[2] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[1] },
+  ],
+});
@@ -1,7 +1,6 @@
-/**
- * @name gruvbox-dark
- * @author morhetz
- * Name: Gruvbox
+/*
+ * gruvbox-dark
+ * author morhetz
 * From github.com/codemirror/codemirror5/blob/master/theme/gruvbox-dark.css
 */
 import { tags as t } from '@lezer/highlight';
@@ -1,7 +1,6 @@
-/**
- * @name gruvbox-light
- * @author morhetz
- * Name: Gruvbox
+/*
+ * gruvbox-light
+ * author morhetz
 * From github.com/codemirror/codemirror5/blob/master/theme/gruvbox-light.css
 */
 import { tags as t } from '@lezer/highlight';
@@ -0,0 +1,39 @@
+/*
+ * Atom One
+ * Atom One dark syntax theme
+ *
+ * https://github.com/atom/one-dark-syntax
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = ['#000000', '#ff5356', '#bd312a', '#54636D', '#171717'];
+
+export const settings = {
+  background: hex[0],
+  lineBackground: 'transparent',
+  foreground: hex[2],
+  selection: hex[4],
+  selectionMatch: hex[0],
+  gutterBackground: hex[0],
+  gutterForeground: hex[3],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[0],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[2],
+    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: hex[1] },
+    { tag: t.comment, color: hex[3] },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: hex[2] },
+    { tag: [t.attributeName, t.number], color: hex[1] },
+    { tag: t.keyword, color: hex[2] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[1] },
+  ],
+});
@@ -0,0 +1,39 @@
+/*
+ * Atom One
+ * Atom One dark syntax theme
+ *
+ * https://github.com/atom/one-dark-syntax
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from './theme-helper.mjs';
+
+const hex = ['#1e1e1e', '#fbde2d', '#ff1493', '#4c83ff', '#ededed', '#cccccc', '#ffffff30', '#dc2f8c'];
+
+export const settings = {
+  background: '#000000',
+  lineBackground: 'transparent',
+  foreground: hex[4],
+  selection: hex[6],
+  gutterBackground: hex[0],
+  gutterForeground: hex[5],
+  gutterBorder: 'transparent',
+  lineHighlight: hex[0],
+};
+
+export default createTheme({
+  theme: 'dark',
+  settings,
+  styles: [
+    {
+      tag: [t.function(t.variableName), t.function(t.propertyName), t.url, t.processingInstruction],
+      color: hex[4],
+    },
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: hex[3] },
+
+    { tag: t.comment, color: '#54636D' },
+    { tag: [t.variableName, t.propertyName, t.labelName], color: hex[4] },
+    { tag: [t.attributeName, t.number], color: hex[3] },
+    { tag: t.keyword, color: hex[1] },
+    { tag: [t.string, t.regexp, t.special(t.propertyName)], color: hex[2] },
+  ],
+});
@@ -5,14 +5,11 @@ export const settings = {
  background: '#222',
  lineBackground: '#22222299',
  foreground: '#fff',
-  // foreground: '#75baff',
  caret: '#ffcc00',
  selection: 'rgba(128, 203, 196, 0.5)',
  selectionMatch: '#036dd626',
-  // lineHighlight: '#8a91991a', // original
  lineHighlight: '#00000050',
  gutterBackground: 'transparent',
-  // gutterForeground: '#8a919966',
  gutterForeground: '#8a919966',
 };

@@ -20,6 +17,7 @@ export default createTheme({
  theme: 'dark',
  settings,
  styles: [
+    { tag: [t.atom, t.bool, t.special(t.variableName)], color: '#89ddff' },
    { tag: t.labelName, color: '#89ddff' },
    { tag: t.keyword, color: '#c792ea' },
    { tag: t.operator, color: '#89ddff' },
@@ -1,34 +0,0 @@
-import { tags as t } from '@lezer/highlight';
-import { createTheme } from './theme-helper.mjs';
-
-export const settings = {
-  background: '#292A30',
-  lineBackground: '#292A3099',
-  foreground: '#CECFD0',
-  caret: '#fff',
-  selection: '#727377',
-  selectionMatch: '#727377',
-  lineHighlight: '#2F3239',
-};
-
-export default createTheme({
-  theme: 'dark',
-  settings: {
-    background: '#292A30',
-    foreground: '#CECFD0',
-    caret: '#fff',
-    selection: '#727377',
-    selectionMatch: '#727377',
-    lineHighlight: '#ffffff0f',
-  },
-  styles: [
-    { tag: [t.comment, t.quote], color: '#7F8C98' },
-    { tag: [t.keyword], color: '#FF7AB2', fontWeight: 'bold' },
-    { tag: [t.string, t.meta], color: '#FF8170' },
-    { tag: [t.typeName], color: '#DABAFF' },
-    { tag: [t.definition(t.variableName)], color: '#6BDFFF' },
-    { tag: [t.name], color: '#6BAA9F' },
-    { tag: [t.variableName], color: '#ACF2E4' },
-    { tag: [t.regexp, t.link], color: '#FF8170' },
-  ],
-});
@@ -1,5 +1,5 @@
 /*
-controls.mjs - <short description TODO>
+controls.mjs - Registers audio controls for pattern manipulation and effects.
 Copyright (C) 2022 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/controls.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/>.
 */
@@ -445,6 +445,32 @@ export const { coarse } = registerControl('coarse');
 */
 export const { drive } = registerControl('drive');

+/**
+ * Create byte beats with custom expressions
+ *
+ * @name byteBeatExpression
+ * @synonyms bbexpr
+ *
+ * @param {number | Pattern} byteBeatExpression bitwise expression for creating bytebeat
+ * @example
+ * s("bytebeat").bbexpr('t*(t>>15^t>>66)')
+ *
+ */
+export const { byteBeatExpression, bbexpr } = registerControl('byteBeatExpression', 'bbexpr');
+
+/**
+ * Create byte beats with custom expressions
+ *
+ * @name byteBeatStartTime
+ * @synonyms bbst
+ *
+ * @param {number | Pattern} byteBeatStartTime in samples (t)
+ * @example
+ * note("c3!8".add("{0 0 12 0 7 5 3}%8")).s("bytebeat:5").bbst("<3 1>".mul(10000))._scope()
+ *
+ */
+export const { byteBeatStartTime, bbst } = registerControl('byteBeatStartTime', 'bbst');
+
 /**
 * Allows you to set the output channels on the interface
 *
@@ -458,6 +484,41 @@ export const { drive } = registerControl('drive');
 */
 export const { channels, ch } = registerControl('channels', 'ch');

+/**
+ * controls the pulsewidth of the pulse oscillator
+ *
+ * @name pw
+ * @param {number | Pattern} pulsewidth
+ * @example
+ * note("{f a c e}%16").s("pulse").pw(".8:1:.2")
+ * @example
+ * n(run(8)).scale("D:pentatonic").s("pulse").pw("0 .75 .5 1")
+ */
+export const { pw } = registerControl(['pw', 'pwrate', 'pwsweep']);
+
+/**
+ * controls the lfo rate for the pulsewidth of the pulse oscillator
+ *
+ * @name pwrate
+ * @param {number | Pattern} rate
+ * @example
+ * n(run(8)).scale("D:pentatonic").s("pulse").pw("0.5").pwrate("<5 .1 25>").pwsweep("<0.3 .8>")
+
+ *
+ */
+export const { pwrate } = registerControl('pwrate');
+
+/**
+ * controls the lfo sweep for the pulsewidth of the pulse oscillator
+ *
+ * @name pwsweep
+ * @param {number | Pattern} sweep
+ * @example
+ * n(run(8)).scale("D:pentatonic").s("pulse").pw("0.5").pwrate("<5 .1 25>").pwsweep("<0.3 .8>")
+ *
+ */
+export const { pwsweep } = registerControl('pwsweep');
+
 /**
 * Phaser audio effect that approximates popular guitar pedals.
 *
@@ -1461,7 +1522,7 @@ export const { vowel } = registerControl('vowel');
 * @name waveloss
 */
 export const { waveloss } = registerControl('waveloss');
-/*
+/**
 * Noise crackle density
 *
 * @name density
@@ -1513,22 +1574,11 @@ export const { scram } = registerControl('scram');
 export const { binshift } = registerControl('binshift');
 export const { hbrick } = registerControl('hbrick');
 export const { lbrick } = registerControl('lbrick');
-export const { midichan } = registerControl('midichan');
-export const { midimap } = registerControl('midimap');
-export const { midiport } = registerControl('midiport');
-export const { control } = registerControl('control');
-export const { ccn } = registerControl('ccn');
-export const { ccv } = registerControl('ccv');
-export const { polyTouch } = registerControl('polyTouch');
-export const { midibend } = registerControl('midibend');
-export const { miditouch } = registerControl('miditouch');
-export const { ctlNum } = registerControl('ctlNum');
+
 export const { frameRate } = registerControl('frameRate');
 export const { frames } = registerControl('frames');
 export const { hours } = registerControl('hours');
-export const { midicmd } = registerControl('midicmd');
 export const { minutes } = registerControl('minutes');
-export const { progNum } = registerControl('progNum');
 export const { seconds } = registerControl('seconds');
 export const { songPtr } = registerControl('songPtr');
 export const { uid } = registerControl('uid');
@@ -1621,6 +1671,151 @@ export const ar = register('ar', (t, pat) => {
  return pat.set({ attack, release });
 });

+//MIDI
+
+/**
+ * MIDI channel: Sets the MIDI channel for the event.
+ *
+ * @name midichan
+ * @param {number | Pattern} channel MIDI channel number (0-15)
+ * @example
+ * note("c4").midichan(1).midi()
+ */
+export const { midichan } = registerControl('midichan');
+
+export const { midimap } = registerControl('midimap');
+
+/**
+ * MIDI port: Sets the MIDI port for the event.
+ *
+ * @name midiport
+ * @param {number | Pattern} port MIDI port
+ * @example
+ * note("c a f e").midiport("<0 1 2 3>").midi()
+ */
+export const { midiport } = registerControl('midiport');
+
+/**
+ * MIDI command: Sends a MIDI command message.
+ *
+ * @name midicmd
+ * @param {number | Pattern} command MIDI command
+ * @example
+ * midicmd("clock*48,<start stop>/2").midi()
+ */
+export const { midicmd } = registerControl('midicmd');
+
+/**
+ * MIDI control: Sends a MIDI control change message.
+ *
+ * @name control
+ * @param {number | Pattern}  MIDI control number (0-127)
+ * @param {number | Pattern}  MIDI controller value (0-127)
+ */
+export const control = register('control', (args, pat) => {
+  if (!Array.isArray(args)) {
+    throw new Error('control expects an array of [ccn, ccv]');
+  }
+  const [_ccn, _ccv] = args;
+  return pat.ccn(_ccn).ccv(_ccv);
+});
+
+/**
+ * MIDI control number: Sends a MIDI control change message.
+ *
+ * @name ccn
+ * @param {number | Pattern}  MIDI control number (0-127)
+ */
+export const { ccn } = registerControl('ccn');
+/**
+ * MIDI control value: Sends a MIDI control change message.
+ *
+ * @name ccv
+ * @param {number | Pattern}  MIDI control value (0-127)
+ */
+export const { ccv } = registerControl('ccv');
+export const { ctlNum } = registerControl('ctlNum');
+// TODO: ctlVal?
+
+/**
+ * MIDI NRPN non-registered parameter number: Sends a MIDI NRPN non-registered parameter number message.
+ * @name nrpnn
+ * @param {number | Pattern} nrpnn MIDI NRPN non-registered parameter number (0-127)
+ * @example
+ * note("c4").nrpnn("1:8").nrpv("123").midichan(1).midi()
+ */
+export const { nrpnn } = registerControl('nrpnn');
+/**
+ * MIDI NRPN non-registered parameter value: Sends a MIDI NRPN non-registered parameter value message.
+ * @name nrpv
+ * @param {number | Pattern} nrpv MIDI NRPN non-registered parameter value (0-127)
+ * @example
+ * note("c4").nrpnn("1:8").nrpv("123").midichan(1).midi()
+ */
+export const { nrpv } = registerControl('nrpv');
+
+/**
+ * MIDI program number: Sends a MIDI program change message.
+ *
+ * @name progNum
+ * @param {number | Pattern} program MIDI program number (0-127)
+ * @example
+ * note("c4").progNum(10).midichan(1).midi()
+ */
+export const { progNum } = registerControl('progNum');
+
+/**
+ * MIDI sysex: Sends a MIDI sysex message.
+ * @name sysex
+ * @param {number | Pattern} id Sysex ID
+ * @param {number | Pattern} data Sysex data
+ * @example
+ * note("c4").sysex(["0x77", "0x01:0x02:0x03:0x04"]).midichan(1).midi()
+ */
+export const sysex = register('sysex', (args, pat) => {
+  if (!Array.isArray(args)) {
+    throw new Error('sysex expects an array of [id, data]');
+  }
+  const [id, data] = args;
+  return pat.sysexid(id).sysexdata(data);
+});
+/**
+ * MIDI sysex ID: Sends a MIDI sysex identifier message.
+ * @name sysexid
+ * @param {number | Pattern} id Sysex ID
+ * @example
+ * note("c4").sysexid("0x77").sysexdata("0x01:0x02:0x03:0x04").midichan(1).midi()
+ */
+export const { sysexid } = registerControl('sysexid');
+/**
+ * MIDI sysex data: Sends a MIDI sysex message.
+ * @name sysexdata
+ * @param {number | Pattern} data Sysex data
+ * @example
+ * note("c4").sysexid("0x77").sysexdata("0x01:0x02:0x03:0x04").midichan(1).midi()
+ */
+export const { sysexdata } = registerControl('sysexdata');
+
+/**
+ * MIDI pitch bend: Sends a MIDI pitch bend message.
+ * @name midibend
+ * @param {number | Pattern} midibend MIDI pitch bend (-1 - 1)
+ * @example
+ * note("c4").midibend(sine.slow(4).range(-0.4,0.4)).midi()
+ */
+export const { midibend } = registerControl('midibend');
+/**
+ * MIDI key after touch: Sends a MIDI key after touch message.
+ * @name miditouch
+ * @param {number | Pattern} miditouch MIDI key after touch (0-1)
+ * @example
+ * note("c4").miditouch(sine.slow(4).range(0,1)).midi()
+ */
+export const { miditouch } = registerControl('miditouch');
+
+// TODO: what is this?
+export const { polyTouch } = registerControl('polyTouch');
+
 export const getControlName = (alias) => {
  if (controlAlias.has(alias)) {
    return controlAlias.get(alias);
@@ -1632,14 +1827,46 @@ export const getControlName = (alias) => {
 * Sets properties in a batch.
 *
 * @name as
- * @param {Array} mapping the control names that are set
+ * @param {String | Array} mapping the control names that are set
 * @example
 * "c:.5 a:1 f:.25 e:.8".as("note:clip")
+ * @example
+ * "{0@2 0.25 0 0.5 .3 .5}%8".as("begin").s("sax_vib").clip(1)
 */
 export const as = register('as', (mapping, pat) => {
+  mapping = Array.isArray(mapping) ? mapping : [mapping];
  return pat.fmap((v) => {
    v = Array.isArray(v) ? v : [v];
    v = Object.fromEntries(mapping.map((prop, i) => [getControlName(prop), v[i]]));
    return v;
  });
 });
+
+/**
+ * Allows you to scrub an audio file like a tape loop by passing values that represents the position in the audio file
+ * in the optional array syntax ex: "0.5:2", the second value controls the speed of playback
+ * @name scrub
+ * @memberof Pattern
+ * @returns Pattern
+ * @example
+ * samples('github:switchangel/pad')
+ * s("swpad:0").scrub("{0.1!2 .25@3 0.7!2 <0.8:1.5>}%8")
+ * @example
+ * samples('github:yaxu/clean-breaks/main');
+ * s("amen/4").fit().scrub("{0@3 0@2 4@3}%8".div(16))
+ */
+
+export const scrub = register(
+  'scrub',
+  (beginPat, pat) => {
+    return beginPat.outerBind((v) => {
+      if (!Array.isArray(v)) {
+        v = [v];
+      }
+      const [beginVal, speedMultiplier = 1] = v;
+
+      return pat.begin(beginVal).mul(speed(speedMultiplier)).clip(1);
+    });
+  },
+  false,
+);
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/core",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Port of Tidal Cycles to JavaScript",
  "main": "index.mjs",
  "type": "module",
@@ -388,7 +388,7 @@ export class Pattern {

  polyJoin = function () {
    const pp = this;
-    return pp.fmap((p) => p.repeat(pp._steps.div(p._steps))).outerJoin();
+    return pp.fmap((p) => p.extend(pp._steps.div(p._steps))).outerJoin();
  };

  polyBind(func) {
@@ -1244,6 +1244,16 @@ export function reify(thing) {
  return pure(thing);
 }

+/** Takes a list of patterns, and returns a pattern of lists.
+ */
+export function sequenceP(pats) {
+  let result = pure([]);
+  for (const pat of pats) {
+    result = result.bind((list) => pat.fmap((v) => list.concat([v])));
+  }
+  return result;
+}
+
 /** The given items are played at the same time at the same length.
 *
 * @return {Pattern}
@@ -1318,7 +1328,7 @@ export function stackBy(by, ...pats) {
    left: stackLeft,
    right: stackRight,
    expand: stack,
-    repeat: (...args) => polymeterSteps(steps, ...args),
+    repeat: (...args) => polymeter(...args).steps(steps),
  };
  return by
    .inhabit(lookup)
@@ -1820,7 +1830,10 @@ export const { fastGap, fastgap } = register(['fastGap', 'fastgap'], function (f
 export const focus = register('focus', function (b, e, pat) {
  b = Fraction(b);
  e = Fraction(e);
-  return pat._fast(Fraction(1).div(e.sub(b))).late(b.cyclePos());
+  return pat
+    ._early(b.sam())
+    ._fast(Fraction(1).div(e.sub(b)))
+    ._late(b);
 });

 export const { focusSpan, focusspan } = register(['focusSpan', 'focusspan'], function (span, pat) {
@@ -2030,7 +2043,7 @@ export const zoom = register('zoom', function (s, e, pat) {
    return nothing;
  }
  const d = e.sub(s);
-  const steps = __steps ? pat._steps.mulmaybe(d) : undefined;
+  const steps = __steps ? pat._steps?.mulmaybe(d) : undefined;
  return pat
    .withQuerySpan((span) => span.withCycle((t) => t.mul(d).add(s)))
    .withHapSpan((span) => span.withCycle((t) => t.sub(s).div(d)))
@@ -2092,11 +2105,13 @@ export const linger = register(

 /**
 * Samples the pattern at a rate of n events per cycle. Useful for turning a continuous pattern into a discrete one.
+ * @name segment
+ * @synonyms seg
 * @param {number} segments number of segments per cycle
 * @example
 * note(saw.range(40,52).segment(24))
 */
-export const segment = register('segment', function (rate, pat) {
+export const { segment, seg } = register(['segment', 'seg'], function (rate, pat) {
  return pat.struct(pure(true)._fast(rate)).setSteps(rate);
 });

@@ -2426,9 +2441,14 @@ const _chunk = function (n, func, pat, back = false, fast = false) {
  return pat.when(binary_pat, func);
 };

-export const { chunk, slowchunk, slowChunk } = register(['chunk', 'slowchunk', 'slowChunk'], function (n, func, pat) {
-  return _chunk(n, func, pat, false, false);
-});
+export const { chunk, slowchunk, slowChunk } = register(
+  ['chunk', 'slowchunk', 'slowChunk'],
+  function (n, func, pat) {
+    return _chunk(n, func, pat, false, false);
+  },
+  true,
+  true,
+);

 /**
 * Like `chunk`, but cycles through the parts in reverse order. Known as chunk' in tidalcycles
@@ -2440,9 +2460,14 @@ export const { chunk, slowchunk, slowChunk } = register(['chunk', 'slowchunk', '
 * "0 1 2 3".chunkBack(4, x=>x.add(7))
 * .scale("A:minor").note()
 */
-export const { chunkBack, chunkback } = register(['chunkBack', 'chunkback'], function (n, func, pat) {
-  return _chunk(n, func, pat, true);
-});
+export const { chunkBack, chunkback } = register(
+  ['chunkBack', 'chunkback'],
+  function (n, func, pat) {
+    return _chunk(n, func, pat, true);
+  },
+  true,
+  true,
+);

 /**
 * Like `chunk`, but the cycles of the source pattern aren't repeated
@@ -2456,9 +2481,14 @@ export const { chunkBack, chunkback } = register(['chunkBack', 'chunkback'], fun
 * .fastChunk(4, x => x.color('red')).slow(2)
 * .scale("C2:major").note()
 */
-export const { fastchunk, fastChunk } = register(['fastchunk', 'fastChunk'], function (n, func, pat) {
-  return _chunk(n, func, pat, false, true);
-});
+export const { fastchunk, fastChunk } = register(
+  ['fastchunk', 'fastChunk'],
+  function (n, func, pat) {
+    return _chunk(n, func, pat, false, true);
+  },
+  true,
+  true,
+);

 // TODO - redefine elsewhere in terms of mask
 export const bypass = register(
@@ -2472,16 +2502,24 @@ export const bypass = register(
 );

 /**
- * Loops the pattern inside at `offset` for `cycles`.
+ * Loops the pattern inside an `offset` for `cycles`.
+ * If you think of the entire span of time in cycles as a ribbon, you can cut a single piece and loop it.
+ * @name ribbon
+ * @synonym rib
 * @param {number} offset start point of loop in cycles
 * @param {number} cycles loop length in cycles
 * @example
- * note("<c d e f>").ribbon(1, 2).fast(2)
+ * note("<c d e f>").ribbon(1, 2)
 * @example
 * // Looping a portion of randomness
- * note(irand(8).segment(4).scale('C3 minor')).ribbon(1337, 2)
+ * n(irand(8).segment(4)).scale("c:pentatonic").ribbon(1337, 2)
+ * @example
+ * // rhythm generator
+ * s("bd!16?").ribbon(29,.5)
 */
-export const ribbon = register('ribbon', (offset, cycles, pat) => pat.early(offset).restart(pure(1).slow(cycles)));
+export const { ribbon, rib } = register(['ribbon', 'rib'], (offset, cycles, pat) =>
+  pat.early(offset).restart(pure(1).slow(cycles)),
+);

 export const hsla = register('hsla', (h, s, l, a, pat) => {
  return pat.color(`hsla(${h}turn,${s * 100}%,${l * 100}%,${a})`);
@@ -2635,34 +2673,10 @@ export function _polymeterListSteps(steps, ...args) {
 /**
 * *Experimental*
 *
- * Aligns the steps of the patterns, to match the given number of steps per cycle, creating polymeters.
- *
- * @name polymeterSteps
- * @param  {number} steps how many items are placed in one cycle
- * @param  {any[]} patterns one or more patterns
- * @example
- * // the same as "{c d, e f g}%4"
- * polymeterSteps(4, "c d", "e f g").note()
- */
-export function polymeterSteps(steps, ...args) {
-  if (args.length == 0) {
-    return silence;
-  }
-  if (Array.isArray(args[0])) {
-    // Support old behaviour
-    return _polymeterListSteps(steps, ...args);
-  }
-
-  return polymeter(...args).pace(steps);
-}
-
-/**
- * *Experimental*
- *
- * Aligns the steps of the patterns, to match the steps per cycle of the first pattern, creating polymeters. See `polymeterSteps` to set the target steps explicitly.
+ * Aligns the steps of the patterns, creating polymeters. The patterns are repeated until they all fit the cycle. For example, in the below the first pattern is repeated twice, and the second is repeated three times, to fit the lowest common multiple of six steps.
 * @synonyms pm
 * @example
- * // The same as note("{c eb g, c2 g2}")
+ * // The same as note("{c eb g, c2 g2}%6")
 * polymeter("c eb g", "c2 g2").note()
 *
 */
@@ -2678,13 +2692,12 @@ export function polymeter(...args) {
  if (args.length == 0) {
    return silence;
  }
-  const steps = args[0]._steps;
+  const steps = lcm(...args.map((x) => x._steps));
  if (steps.eq(Fraction(0))) {
    return nothing;
  }
-  const [head, ...tail] = args;

-  const result = stack(head, ...tail.map((pat) => pat._slow(pat._steps.div(steps))));
+  const result = stack(...args.map((x) => x.pace(steps)));
  result._steps = steps;
  return result;
 }
@@ -2845,16 +2858,16 @@ export const drop = stepRegister('drop', function (i, pat) {
 /**
 * *Experimental*
 *
- * `repeat` is similar to `fast` in that it 'speeds up' the pattern, but it also increases the step count
- * accordingly. So `stepcat("a b".repeat(2), "c d")` would be the same as `"a b a b c d"`, whereas
+ * `extend` is similar to `fast` in that it increases its density, but it also increases the step count
+ * accordingly. So `stepcat("a b".extend(2), "c d")` would be the same as `"a b a b c d"`, whereas
 * `stepcat("a b".fast(2), "c d")` would be the same as `"[a b] [a b] c d"`.
 * @example
 * stepcat(
- *   sound("bd bd - cp").repeat(2),
+ *   sound("bd bd - cp").extend(2),
 *   sound("bd - sd -")
 * ).pace(8)
 */
-export const repeat = stepRegister('repeat', function (factor, pat) {
+export const extend = stepRegister('extend', function (factor, pat) {
  return pat.fast(factor).expand(factor);
 });

@@ -3052,8 +3065,6 @@ export const timeCat = stepcat;
 // Deprecated stepwise aliases
 export const s_cat = stepcat;
 export const s_alt = stepalt;
-export const s_polymeterSteps = polymeterSteps;
-Pattern.prototype.s_polymeterSteps = Pattern.prototype.polymeterSteps;
 export const s_polymeter = polymeter;
 Pattern.prototype.s_polymeter = Pattern.prototype.polymeter;
 export const s_taper = shrink;
@@ -3066,8 +3077,8 @@ export const s_sub = drop;
 Pattern.prototype.s_sub = Pattern.prototype.drop;
 export const s_expand = expand;
 Pattern.prototype.s_expand = Pattern.prototype.expand;
-export const s_extend = repeat;
-Pattern.prototype.s_extend = Pattern.prototype.repeat;
+export const s_extend = extend;
+Pattern.prototype.s_extend = Pattern.prototype.extend;
 export const s_contract = contract;
 Pattern.prototype.s_contract = Pattern.prototype.contract;
 export const s_tour = tour;
@@ -156,8 +156,7 @@ export const pickmodReset = register('pickmodReset', function (lookup, pat) {
  return _pick(lookup, pat, true).resetJoin();
 });

-/**
-  /** * Picks patterns (or plain values) either from a list (by index) or a lookup table (by name).
+/** Picks patterns (or plain values) either from a list (by index) or a lookup table (by name).
   * Similar to `pick`, but cycles are squeezed into the target ('inhabited') pattern.
   * @name inhabit
   * @synonyms pickSqueeze
@@ -5,7 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
 */

 import { Hap } from './hap.mjs';
-import { Pattern, fastcat, pure, register, reify, silence, stack } from './pattern.mjs';
+import { Pattern, fastcat, pure, register, reify, silence, stack, sequenceP } from './pattern.mjs';
 import Fraction from './fraction.mjs';

 import { id, keyAlias, getCurrentKeyboardState } from './util.mjs';
@@ -20,9 +20,6 @@ export const signal = (func) => {
  return new Pattern(query);
 };

-export const isaw = signal((t) => 1 - (t % 1));
-export const isaw2 = isaw.toBipolar();
-
 /**
 *  A sawtooth signal between 0 and 1.
 *
@@ -36,8 +33,40 @@ export const isaw2 = isaw.toBipolar();
 *
 */
 export const saw = signal((t) => t % 1);
+
+/**
+ *  A sawtooth signal between -1 and 1 (like `saw`, but bipolar).
+ *
+ * @return {Pattern}
+ */
 export const saw2 = saw.toBipolar();

+/**
+ *  A sawtooth signal between 1 and 0 (like `saw`, but flipped).
+ *
+ * @return {Pattern}
+ * @example
+ * note("<c3 [eb3,g3] g2 [g3,bb3]>*8")
+ * .clip(isaw.slow(2))
+ * @example
+ * n(isaw.range(0,8).segment(8))
+ * .scale('C major')
+ *
+ */
+export const isaw = signal((t) => 1 - (t % 1));
+
+/**
+ *  A sawtooth signal between 1 and -1 (like `saw2`, but flipped).
+ *
+ * @return {Pattern}
+ */
+export const isaw2 = isaw.toBipolar();
+
+/**
+ *  A sine signal between -1 and 1 (like `sine`, but bipolar).
+ *
+ * @return {Pattern}
+ */
 export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));

 /**
@@ -61,6 +90,12 @@ export const sine = sine2.fromBipolar();
 *
 */
 export const cosine = sine._early(Fraction(1).div(4));
+
+/**
+ *  A cosine signal between -1 and 1 (like `cosine`, but bipolar).
+ *
+ * @return {Pattern}
+ */
 export const cosine2 = sine2._early(Fraction(1).div(4));

 /**
@@ -72,6 +107,12 @@ export const cosine2 = sine2._early(Fraction(1).div(4));
 *
 */
 export const square = signal((t) => Math.floor((t * 2) % 2));
+
+/**
+ *  A square signal between -1 and 1 (like `square`, but bipolar).
+ *
+ * @return {Pattern}
+ */
 export const square2 = square.toBipolar();

 /**
@@ -82,9 +123,37 @@ export const square2 = square.toBipolar();
 * n(tri.segment(8).range(0,7)).scale("C:minor")
 *
 */
-export const tri = fastcat(isaw, saw);
-export const tri2 = fastcat(isaw2, saw2);
+export const tri = fastcat(saw, isaw);

+/**
+ *  A triangle signal between -1 and 1 (like `tri`, but bipolar).
+ *
+ * @return {Pattern}
+ */
+export const tri2 = fastcat(saw2, isaw2);
+
+/**
+ *  An inverted triangle signal between 1 and 0 (like `tri`, but flipped).
+ *
+ * @return {Pattern}
+ * @example
+ * n(itri.segment(8).range(0,7)).scale("C:minor")
+ *
+ */
+export const itri = fastcat(isaw, saw);
+
+/**
+ *  An inverted triangle signal between -1 and 1 (like `itri`, but bipolar).
+ *
+ * @return {Pattern}
+ */
+export const itri2 = fastcat(isaw2, saw2);
+
+/**
+ *  A signal representing the cycle time.
+ *
+ * @return {Pattern}
+ */
 export const time = signal(id);

 /**
@@ -210,9 +279,9 @@ const _rearrangeWith = (ipat, n, pat) => {
 };

 /**
- * @name shuffle
 * Slices a pattern into the given number of parts, then plays those parts in random order.
 * Each part will be played exactly once per cycle.
+ * @name shuffle
 * @example
 * note("c d e f").sound("piano").shuffle(4)
 * @example
@@ -223,9 +292,9 @@ export const shuffle = register('shuffle', (n, pat) => {
 });

 /**
- * @name scramble
 * Slices a pattern into the given number of parts, then plays those parts at random. Similar to `shuffle`,
 * but parts might be played more than once, or not at all, per cycle.
+ * @name scramble
 * @example
 * note("c d e f").sound("piano").scramble(4)
 * @example
@@ -364,19 +433,30 @@ export const chooseCycles = (...xs) => chooseInWith(rand.segment(1), xs);
 export const randcat = chooseCycles;

 const _wchooseWith = function (pat, ...pairs) {
+  // A list of patterns of values
  const values = pairs.map((pair) => reify(pair[0]));
+
+  // A list of weight patterns
  const weights = [];
-  let accum = 0;
+
+  let total = pure(0);
  for (const pair of pairs) {
-    accum += pair[1];
-    weights.push(accum);
+    // 'add' accepts either values or patterns of values here, so no need
+    // to explicitly reify
+    total = total.add(pair[1]);
+    // accumulate our list of weight patterns
+    weights.push(total);
  }
-  const total = accum;
+  // a pattern of lists of weights
+  const weightspat = sequenceP(weights);
+
+  // Takes a number from 0-1, returns a pattern of patterns of values
  const match = function (r) {
-    const find = r * total;
-    return values[weights.findIndex((x) => x > find, weights)];
+    const findpat = total.mul(r);
+    return weightspat.fmap((weights) => (find) => values[weights.findIndex((x) => x > find, weights)]).appLeft(findpat);
  };
-  return pat.fmap(match);
+  // This returns a pattern of patterns.. The innerJoin is in wchooseCycles
+  return pat.bind(match);
 };

 const wchooseWith = (...args) => _wchooseWith(...args).outerJoin();
@@ -398,6 +478,9 @@ export const wchoose = (...pairs) => wchooseWith(rand, ...pairs);
 * wchooseCycles(["bd",10], ["hh",1], ["sd",1]).s().fast(8)
 * @example
 * wchooseCycles(["bd bd bd",5], ["hh hh hh",3], ["sd sd sd",1]).fast(4).s()
+ * @example
+ * // The probability can itself be a pattern
+ * wchooseCycles(["bd(3,8)","<5 0>"], ["hh hh hh",3]).fast(4).s()
 */
 export const wchooseCycles = (...pairs) => _wchooseWith(rand.segment(1), ...pairs).innerJoin();

@@ -443,6 +526,9 @@ export const degradeByWith = register(
 * s("hh*8").degradeBy(0.2)
 * @example
 * s("[hh?0.2]*8")
+ * @example
+ * //beat generator
+ * s("bd").segment(16).degradeBy(.5).ribbon(16,1)
 */
 export const degradeBy = register(
  'degradeBy',
@@ -22,7 +22,6 @@ import {
  sequence,
  palindrome,
  polymeter,
-  polymeterSteps,
  polyrhythm,
  silence,
  fast,
@@ -611,17 +610,10 @@ describe('Pattern', () => {
  });
  describe('polymeter()', () => {
    it('Can layer up cycles, stepwise, with lists', () => {
-      expect(polymeterSteps(3, ['d', 'e']).firstCycle()).toStrictEqual(
-        fastcat(pure('d'), pure('e'), pure('d')).firstCycle(),
-      );
-
      expect(polymeter(['a', 'b', 'c'], ['d', 'e']).fast(2).firstCycle()).toStrictEqual(
        stack(sequence('a', 'b', 'c', 'a', 'b', 'c'), sequence('d', 'e', 'd', 'e', 'd', 'e')).firstCycle(),
      );
    });
-    it('Can layer up cycles, stepwise, with weighted patterns', () => {
-      sameFirst(polymeterSteps(3, sequence('a', 'b')).fast(2), sequence('a', 'b', 'a', 'b', 'a', 'b'));
-    });
  });

  describe('firstOf()', () => {
@@ -1265,4 +1257,14 @@ describe('Pattern', () => {
      expect(s('bev').chop(8).loopAt(2)._steps).toStrictEqual(Fraction(4));
    });
  });
+  describe('bite', () => {
+    it('works with uneven patterns', () => {
+      sameFirst(
+        fastcat(slowcat('a', 'b', 'c', 'd', 'e'), slowcat(1, 2, 3, 4, 5))
+          .bite(2, stepcat(pure(0), pure(1).expand(2)))
+          .fast(5),
+        stepcat(slowcat('a', 'b', 'c', 'd', 'e'), slowcat(1, 2, 3, 4, 5).expand(2)).fast(5),
+      );
+    });
+  });
 });
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/csound",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "csound bindings for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/draw",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Helpers for drawing with Strudel",
  "main": "index.mjs",
  "type": "module",
@@ -0,0 +1,93 @@
+# @strudel/gamepad
+
+This package adds gamepad input functionality to strudel Patterns.
+
+## Install
+
+```sh
+npm i @strudel/gamepad --save
+```
+
+## Usage
+
+```javascript
+import { gamepad } from '@strudel/gamepad';
+
+// Initialize gamepad (optional index parameter, defaults to 0)
+const pad = gamepad(0);
+
+// Use gamepad inputs in patterns
+const pattern = sequence([
+  // Button inputs
+  pad.a,        // A button value (0-1)
+  pad.tglA,     // A button toggle (0 or 1)
+  
+  // Analog stick inputs
+  pad.x1,       // Left stick X (0-1)
+  pad.x1_2,     // Left stick X (-1 to 1)
+]);
+```
+
+## Available Controls
+
+### Buttons
+- Face Buttons
+  - `a`, `b`, `x`, `y` (or uppercase `A`, `B`, `X`, `Y`)
+  - Toggle versions: `tglA`, `tglB`, `tglX`, `tglY`
+- Shoulder Buttons
+  - `lb`, `rb`, `lt`, `rt` (or uppercase `LB`, `RB`, `LT`, `RT`)
+  - Toggle versions: `tglLB`, `tglRB`, `tglLT`, `tglRT`
+- D-Pad
+  - `up`, `down`, `left`, `right` (or `u`, `d`, `l`, `r` or uppercase)
+  - Toggle versions: `tglUp`, `tglDown`, `tglLeft`, `tglRight`(or `tglU`, `tglD`, `tglL`, `tglR`)
+
+### Analog Sticks
+- Left Stick
+  - `x1`, `y1` (0 to 1 range)
+  - `x1_2`, `y1_2` (-1 to 1 range)
+- Right Stick
+  - `x2`, `y2` (0 to 1 range)
+  - `x2_2`, `y2_2` (-1 to 1 range)
+
+## Examples
+
+```javascript
+// Use button values to control amplitude
+$: sequence([
+  s("bd").gain(pad.X),    // X button controls gain
+  s("[hh oh]").gain(pad.tglY),    // Y button toggles gain
+]);
+
+// Use analog stick for continuous control
+$: note("c4*4".add(pad.y1_2.range(-24,24))) // Left stick Y controls pitch shift
+  .pan(pad.x1_2);          // Left stick X controls panning
+
+// Use toggle buttons to switch patterns on/off
+
+// Define button sequences
+const HADOKEN = [
+  'd',               // Down
+  'r',               // Right
+  'a',               // A
+];
+
+const KONAMI = 'uuddlrlrba' //Konami Code ↑↑↓↓←→←→BA
+
+// Add these lines to enable buttons(but why?)
+$:pad.D.segment(16).gain(0)
+$:pad.R.segment(16).gain(0)
+$:pad.A.segment(16).gain(0)
+
+// Check button sequence (returns 1 when detected, 0 when not within last 1 second)
+$: sound("hadoken").gain(pad.checkSequence(HADOKEN))
+
+```
+
+## Multiple Gamepads
+
+You can connect multiple gamepads by specifying the gamepad index:
+
+```javascript
+const pad1 = gamepad(0);  // First gamepad
+const pad2 = gamepad(1);  // Second gamepad
+```
@@ -0,0 +1,117 @@
+import { MiniRepl } from '../../../website/src/docs/MiniRepl';
+
+# Gamepad
+
+The Gamepad module allows you to integrate gamepad input functionality into your musical patterns. This can be particularly useful for live performances or interactive installations where you want to manipulate sounds using a game controller.
+
+## Getting Started
+
+Initialize a gamepad by calling the gamepad() function with an optional index parameter.
+
+<MiniRepl
+  client:idle
+  tune={`// Initialize gamepad (optional index parameter, defaults to 0)
+const gp = gamepad(0)
+note("c a f e").mask(gp.a)`}
+/>
+
+## Available Controls
+
+The gamepad module provides access to buttons and analog sticks as normalized signals (0-1) that can modulate your patterns.
+
+### Buttons
+
+| Type             | Controls                                                                                       |
+| ---------------- | ---------------------------------------------------------------------------------------------- |
+| Face Buttons     | `a`, `b`, `x`, `y` (or uppercase `A`, `B`, `X`, `Y`)                                           |
+|                  | Toggle versions: `tglA`, `tglB`, `tglX`, `tglY`                                                |
+| Shoulder Buttons | `lb`, `rb`, `lt`, `rt` (or uppercase `LB`, `RB`, `LT`, `RT`)                                   |
+|                  | Toggle versions: `tglLB`, `tglRB`, `tglLT`, `tglRT`                                            |
+| D-Pad            | `up`, `down`, `left`, `right` (or `u`, `d`, `l`, `r` or uppercase)                             |
+|                  | Toggle versions: `tglUp`, `tglDown`, `tglLeft`, `tglRight` (or `tglU`, `tglD`, `tglL`, `tglR`) |
+
+### Analog Sticks
+
+| Stick       | Controls                       |
+| ----------- | ------------------------------ |
+| Left Stick  | `x1`, `y1` (0 to 1 range)      |
+|             | `x1_2`, `y1_2` (-1 to 1 range) |
+| Right Stick | `x2`, `y2` (0 to 1 range)      |
+|             | `x2_2`, `y2_2` (-1 to 1 range) |
+
+### Button Sequence
+
+| Stick           | Controls                                |
+| --------------- | --------------------------------------- |
+| Button Sequence | `btnSequence()`, `btnSeq()`, `btnseq()` |
+
+## Using Gamepad Inputs
+
+Once initialized, you can use various gamepad inputs in your patterns. Here are some examples:
+
+### Button Inputs
+
+You can use button inputs to control different aspects of your music, such as gain or triggering events.
+
+<MiniRepl
+  client:idle
+  tune={`const gp = gamepad(0)
+  // Use button values to control amplitude
+$: stack(
+  s("[[hh hh] oh hh oh]/2").mask(gp.tglX).bank("RolandTR909"), // X btn for HH
+   s("cr*1").mask(gp.Y).bank("RolandTR909"), // LB btn for CR
+  s("bd").mask(gp.tglA).bank("RolandTR909"), // A btn for BD
+  s("[ht - - mt - - lt - ]/2").mask(gp.tglB).bank("RolandTR909"), // B btn for Toms
+  s("sd*4").mask(gp.RB).bank("RolandTR909"), // RB btn for SD
+).cpm(120)
+`}
+/>
+
+### Analog Stick Inputs
+
+Analog sticks can be used for continuous control, such as pitch shifting or panning.
+
+<MiniRepl
+  client:idle
+  tune={`const gp = gamepad(0)
+  // Use analog stick for continuous control
+$: note("c4 d3 a3 e3").sound("sawtooth") 
+  .lpf(gp.x1.range(100,4000)) 
+  .lpq(gp.y1.range(5,30))
+  .decay(gp.y2.range(0.1,2))
+  .lpenv(gp.x2.range(-5,5))
+  .cpm(120)
+  `}
+/>
+
+### Button Sequences
+
+You can define button sequences to trigger specific actions, like playing a sound when a sequence is detected.
+
+<MiniRepl client:idle tune={`const gp = gamepad(0)
+// Define button sequences
+const HADOUKEN = [
+  'd',               // Down
+  'r',               // Right
+  'a',               // A
+]
+const KONAMI = 'uuddlrlrba' //Konami Code ↑↑↓↓←→←→BA
+
+// Check butto-n sequence (returns 1 while detected, 0 when not within last 1 second)
+$: s("free_hadouken -").slow(2)
+.mask(gp.btnSequence(HADOUKEN)).room(1).cpm(120)
+
+// hadouken.wav by Syna-Max
+//https://freesound.org/people/Syna-Max/sounds/67674/
+samples({free_hadouken: 'https://cdn.freesound.org/previews/67/67674_111920-lq.mp3'})
+`} />
+
+## Multiple Gamepads
+
+Strudel supports multiple gamepads. You can specify the gamepad index to connect to different devices.
+
+<MiniRepl
+  client:idle
+  tune={`const pad1 = gamepad(0);  // First gamepad
+const pad2 = gamepad(1);  // Second gamepad`}
+/>
@@ -0,0 +1,246 @@
+// @strudel/gamepad/index.mjs
+
+import { signal } from '@strudel/core';
+
+// Button mapping for Logitech Dual Action (STANDARD GAMEPAD Vendor: 046d Product: c216)
+export const buttonMap = {
+  a: 0,
+  b: 1,
+  x: 2,
+  y: 3,
+  lb: 4,
+  rb: 5,
+  lt: 6,
+  rt: 7,
+  back: 8,
+  start: 9,
+  u: 12,
+  up: 12,
+  d: 13,
+  down: 13,
+  l: 14,
+  left: 14,
+  r: 15,
+  right: 15,
+};
+
+class ButtonSequenceDetector {
+  constructor(timeWindow = 1000) {
+    this.sequence = [];
+    this.timeWindow = timeWindow;
+    this.lastInputTime = 0;
+    this.buttonStates = Array(16).fill(0); // Track previous state of each button
+    // Button mapping for character inputs
+  }
+
+  addInput(buttonIndex, buttonValue) {
+    const currentTime = Date.now();
+
+    // Only add input on button press (rising edge)
+    if (buttonValue === 1 && this.buttonStates[buttonIndex] === 0) {
+      // Clear sequence if too much time has passed
+      if (currentTime - this.lastInputTime > this.timeWindow) {
+        this.sequence = [];
+      }
+
+      // Store the button name instead of index
+      const buttonName = Object.keys(buttonMap).find((key) => buttonMap[key] === buttonIndex) || buttonIndex.toString();
+
+      this.sequence.push({
+        input: buttonName,
+        timestamp: currentTime,
+      });
+
+      this.lastInputTime = currentTime;
+
+      //console.log(this.sequence);
+      // Keep only inputs within the time window
+      this.sequence = this.sequence.filter((entry) => currentTime - entry.timestamp <= this.timeWindow);
+    }
+
+    // Update button state
+    this.buttonStates[buttonIndex] = buttonValue;
+  }
+
+  checkSequence(targetSequence) {
+    if (!Array.isArray(targetSequence) && typeof targetSequence !== 'string') {
+      console.error('ButtonSequenceDetector: targetSequence must be an array or string');
+      return 0;
+    }
+
+    if (this.sequence.length < targetSequence.length) return 0;
+
+    // Convert string input to array if needed
+    const sequence =
+      typeof targetSequence === 'string'
+        ? targetSequence.toLowerCase().split('')
+        : targetSequence.map((s) => s.toString().toLowerCase());
+
+    //console.log(this.sequence);
+
+    // Get the last n inputs where n is the target sequence length
+    const lastInputs = this.sequence.slice(-targetSequence.length).map((entry) => entry.input);
+
+    // Compare sequences
+    return lastInputs.every((input, index) => {
+      const target = sequence[index];
+      // Check if either the input matches directly or they refer to the same button in the map
+      return (
+        input === target ||
+        buttonMap[input] === buttonMap[target] ||
+        // Also check if the numerical index matches
+        buttonMap[input] === parseInt(target)
+      );
+    })
+      ? 1
+      : 0;
+  }
+}
+
+class GamepadHandler {
+  constructor(index = 0) {
+    // Add index parameter
+    this._gamepads = {};
+    this._activeGamepad = index; // Use provided index
+    this._axes = [0, 0, 0, 0];
+    this._buttons = Array(16).fill(0);
+    this.setupEventListeners();
+  }
+
+  setupEventListeners() {
+    window.addEventListener('gamepadconnected', (e) => {
+      this._gamepads[e.gamepad.index] = e.gamepad;
+      if (!this._activeGamepad) {
+        this._activeGamepad = e.gamepad.index;
+      }
+    });
+
+    window.addEventListener('gamepaddisconnected', (e) => {
+      delete this._gamepads[e.gamepad.index];
+      if (this._activeGamepad === e.gamepad.index) {
+        this._activeGamepad = Object.keys(this._gamepads)[0] || null;
+      }
+    });
+  }
+
+  poll() {
+    if (this._activeGamepad !== null) {
+      const gamepad = navigator.getGamepads()[this._activeGamepad];
+      if (gamepad) {
+        // Update axes (normalized to 0-1 range)
+        this._axes = gamepad.axes.map((axis) => (axis + 1) / 2);
+        // Update buttons
+        this._buttons = gamepad.buttons.map((button) => button.value);
+      }
+    }
+  }
+
+  getAxes() {
+    return this._axes;
+  }
+  getButtons() {
+    return this._buttons;
+  }
+}
+
+// Module-level state store for toggle states
+const gamepadStates = new Map();
+
+export const gamepad = (index = 0) => {
+  const handler = new GamepadHandler(index);
+  const sequenceDetector = new ButtonSequenceDetector(2000);
+
+  // Base signal that polls gamepad state and handles sequence detection
+  const baseSignal = signal((t) => {
+    handler.poll();
+    const axes = handler.getAxes();
+    const buttons = handler.getButtons();
+
+    // Add all button inputs to sequence detector
+    buttons.forEach((value, i) => {
+      sequenceDetector.addInput(i, value);
+    });
+
+    return { axes, buttons, t };
+  });
+
+  // Create axes patterns
+  const axes = {
+    x1: baseSignal.fmap((state) => state.axes[0]),
+    y1: baseSignal.fmap((state) => state.axes[1]),
+    x2: baseSignal.fmap((state) => state.axes[2]),
+    y2: baseSignal.fmap((state) => state.axes[3]),
+  };
+
+  // Add bipolar versions
+  axes.x1_2 = axes.x1.toBipolar();
+  axes.y1_2 = axes.y1.toBipolar();
+  axes.x2_2 = axes.x2.toBipolar();
+  axes.y2_2 = axes.y2.toBipolar();
+
+  // Create button patterns
+  const buttons = Array(16)
+    .fill(null)
+    .map((_, i) => {
+      // Create unique key for this gamepad+button combination
+      const stateKey = `gamepad${index}_btn${i}`;
+
+      // Initialize toggle state if it doesn't exist
+      if (!gamepadStates.has(stateKey)) {
+        gamepadStates.set(stateKey, {
+          lastButtonState: 0,
+          toggleState: 0,
+        });
+      }
+
+      // Direct button value pattern (no longer needs to call addInput)
+      const btn = baseSignal.fmap((state) => state.buttons[i]);
+
+      // Button toggle pattern with persistent state
+      const toggle = baseSignal.fmap((state) => {
+        const currentState = state.buttons[i];
+        const buttonState = gamepadStates.get(stateKey);
+
+        if (currentState === 1 && buttonState.lastButtonState === 0) {
+          // Toggle the state on rising edge
+          buttonState.toggleState = buttonState.toggleState === 0 ? 1 : 0;
+        }
+
+        buttonState.lastButtonState = currentState;
+        return buttonState.toggleState;
+      });
+
+      return { value: btn, toggle };
+    });
+
+  // Create sequence checker pattern
+  const btnSequence = (sequence) => {
+    return baseSignal.fmap(() => sequenceDetector.checkSequence(sequence));
+  };
+  const checkSequence = btnSequence;
+  const btnSeq = btnSequence;
+  const btnseq = btnSeq;
+
+  // Return an object with all controls
+  return {
+    ...axes,
+    buttons,
+    ...Object.fromEntries(
+      Object.entries(buttonMap).flatMap(([key, index]) => [
+        [key.toLowerCase(), buttons[index].value],
+        [key.toUpperCase(), buttons[index].value],
+        [`tgl${key.toLowerCase()}`, buttons[index].toggle],
+        [`tgl${key.toUpperCase()}`, buttons[index].toggle],
+      ]),
+    ),
+    checkSequence,
+    btnSequence,
+    btnSeq,
+    btnseq,
+    raw: baseSignal,
+  };
+};
+
+// Optional: Export for debugging or state management
+export const getGamepadStates = () => Object.fromEntries(gamepadStates);
+export const clearGamepadStates = () => gamepadStates.clear();
@@ -0,0 +1,3 @@
+import './gamepad.mjs';
+
+export * from './gamepad.mjs';
@@ -0,0 +1,37 @@
+{
+  "name": "@strudel/gamepad",
+  "version": "1.2.2",
+  "description": "Gamepad Inputs for strudel",
+  "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": [
+    "titdalcycles",
+    "strudel",
+    "pattern",
+    "livecoding",
+    "algorave"
+  ],
+  "author": "Yuta Nakayama <nkymut@gmail.com>",
+  "license": "AGPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/tidalcycles/strudel/issues"
+  },
+  "homepage": "https://github.com/tidalcycles/strudel#readme",
+  "dependencies": {
+    "@strudel/core": "workspace:*"
+  },
+  "devDependencies": {
+    "vite": "^6.0.11"
+  }
+}
@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+import { dependencies } from './package.json';
+import { resolve } from 'path';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'index.mjs'),
+      formats: ['es'],
+      fileName: (ext) => ({ es: 'index.mjs' })[ext],
+    },
+    rollupOptions: {
+      external: [...Object.keys(dependencies)],
+    },
+    target: 'esnext',
+  },
+});
@@ -1,6 +1,7 @@
 {
  "name": "hs2js",
-  "version": "0.1.0",
+  "version": "0.2.0",
+  "private": true,
  "description": "Experimental Haskell in JavaScript interpreter",
  "main": "src/index.mjs",
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/hydra",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Hydra integration for strudel",
  "main": "hydra.mjs",
  "type": "module",
@@ -7,3 +7,187 @@ This package adds midi functionality to strudel Patterns.
 ```sh
 npm i @strudel/midi --save
 ```
+
+## Available Controls
+
+The following MIDI controls are available:
+
+OUTPUT:
+
+- `midi` - opens a midi output device.
+- `note` - Sends MIDI note messages. Can accept note names (e.g. "c4") or MIDI note numbers (0-127)
+- `midichan` - Sets the MIDI channel (1-16, defaults to 1)
+- `velocity` - Sets note velocity (0-1, defaults to 0.9)
+- `gain` - Modifies velocity by multiplying with it (0-1, defaults to 1)
+- `control` - Sets MIDI control change messages
+- `ccn` - Sets MIDI CC controller number (0-127)
+- `ccv` - Sets MIDI CC value (0-1)
+- `progNum` - Sends MIDI program change messages (0-127)
+- `sysex` - Sends MIDI System Exclusive messages (id: number 0-127 or array of bytes 0-127, data: array of bytes 0-127)
+- `sysexid` - Sets MIDI System Exclusive ID (number 0-127 or array of bytes 0-127)
+- `sysexdata` - Sets MIDI System Exclusive data (array of bytes 0-127)
+- `midibend` - Sets MIDI pitch bend (-1 - 1)
+- `miditouch` - Sets MIDI key after touch (0-1)
+- `midicmd` - Sends MIDI system real-time messages to control timing and transport on MIDI devices.
+- `nrpnn` - Sets MIDI NRPN non-registered parameter number (array of bytes 0-127)
+- `nrpv` - Sets MIDI NRPN non-registered parameter value (0-127)
+
+
+INPUT:
+
+- `midin` - Opens a MIDI input port to receive MIDI control change messages.
+
+Additional controls can be mapped using the mapping object passed to `.midi()`:
+
+## Examples
+
+### midi(outputName?, options?)
+
+Either connect a midi device or use the IAC Driver (Mac) or Midi Through Port (Linux) for internal midi messages.
+If no outputName is given, it uses the first midi output it finds.
+
+```javascript
+$: chord("<C^7 A7 Dm7 G7>").voicing().midi('IAC Driver')
+```
+
+In the console, you will see a log of the available MIDI devices as soon as you run the code, e.g. `Midi connected! Using "Midi Through Port-0".`
+
+### Options
+
+The `.midi()` function accepts an options object with the following properties:
+
+```javascript
+$: note("c a f e").midi('IAC Driver', { isController: true, midimap: 'default'})
+```
+
+<details>
+<summary>Available Options</summary>
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| isController | boolean | false | When true, disables sending note messages. Useful for MIDI controllers |
+| latencyMs | number | 34 | Latency in milliseconds to align MIDI with audio engine |
+| noteOffsetMs | number | 10 | Offset in milliseconds for note-off messages to prevent glitching |
+| midichannel | number | 1 | Default MIDI channel (1-16) |
+| velocity | number | 0.9 | Default note velocity (0-1) |
+| gain | number | 1 | Default gain multiplier for velocity (0-1) |
+| midimap | string | 'default' | Name of MIDI mapping to use for control changes |
+| midiport | string/number | - | MIDI device name or index |
+
+</details>
+
+
+
+
+### midiport(outputName)
+
+Selects the MIDI output device to use, pattern can be used to switch between devices.
+
+```javascript
+$: midiport('IAC Driver')
+$: note("c a f e").midiport("<0 1 2 3>").midi()
+```
+
+### midichan(number)
+
+Selects the MIDI channel to use. If not used, `.midi` will use channel 1 by default.
+
+### control, ccn && ccv
+
+`control` sends MIDI control change messages to your MIDI device.
+
+- `ccn` sets the cc number. Depends on your synths midi mapping
+- `ccv` sets the cc value. normalized from 0 to 1.
+
+```javascript
+$: note("c a f e").control([74, sine.slow(4)]).midi()
+$: note("c a f e").ccn(74).ccv(sine.slow(4)).midi()
+```
+
+In the above snippet, `ccn` is set to 74, which is the filter cutoff for many synths. `ccv` is controlled by a saw pattern.
+Having everything in one pattern, the `ccv` pattern will be aligned to the note pattern, because the structure comes from the left by default.
+But you can also control cc messages separately like this:
+
+```javascript
+$: note("c a f e").midi()
+$: ccv(sine.segment(16).slow(4)).ccn(74).midi()
+```
+
+### progNum (Program Change)
+
+`progNum` control sends MIDI program change messages to switch between different presets/patches on your MIDI device.
+Program change values should be numbers between 0 and 127.
+
+```javascript
+// Play notes while changing programs
+note("c3 e3 g3").progNum("<0 1 2>").midi()
+```
+
+Program change messages are useful for switching between different instrument sounds or presets during a performance. 
+The exact sound that each program number maps to depends on your MIDI device's configuration.
+
+## sysex,  sysexid && sysexdata (System Exclusive Message)
+
+`sysex`, `sysexid` and `sysexdata` control sends MIDI System Exclusive (SysEx) messages to your MIDI device. 
+sysEx messages are device-specific commands that allow deeper control over synthesizer parameters. 
+The value should be an array of numbers between 0-255 representing the SysEx data bytes.
+
+```javascript
+// Send a simple SysEx message
+let id = 0x43; //Yamaha
+//let id = "0x00:0x20:0x32"; //Behringer ID can be an array of numbers
+let data = "0x79:0x09:0x11:0x0A:0x00:0x00"; // Set NSX-39 voice to say "Aa"
+$: note("c d e f e d c").sysex(id, data).midi();
+$: note("c d e f e d c").sysexid(id).sysexdata(data).midi();
+```
+
+The exact format of SysEx messages depends on your MIDI device's specification.
+Consult your device's MIDI implementation guide for details on supported SysEx messages.
+
+### midibend && miditouch
+
+`midibend` sets MIDI pitch bend (-1 - 1)
+`miditouch` sets MIDI key after touch (0-1)
+
+```javascript
+
+$: note("c d e f e d c").midibend(sine.slow(4).range(-0.4,0.4)).midi();
+$: note("c d e f e d c").miditouch(sine.slow(4).range(0,1)).midi();
+
+```
+
+### midicmd
+
+`midicmd` sends MIDI system real-time messages to control timing and transport on MIDI devices.
+
+It supports the following commands:
+
+- `clock`/`midiClock` - Sends MIDI timing clock messages
+- `start` - Sends MIDI start message
+- `stop` - Sends MIDI stop message
+- `continue` - Sends MIDI continue message
+
+```javascript
+// You can control the clock with a pattern and ensure it starts in sync when the repl begins.
+// Note: It might act unexpectedly if MIDI isn't set up initially.
+stack(
+  midicmd("clock*48,<start stop>/2").midi('IAC Driver') 
+)
+```
+
+`midicmd` also supports sending control change, program change and sysex messages.
+
+- `cc` - sends MIDI control change messages.
+- `progNum` - sends MIDI program change messages.
+- `sysex` - sends MIDI system exclusive messages.
+
+```javascript
+stack(
+  // "cc:ccn:ccv"
+  midicmd("cc:74:1").midi('IAC Driver'),
+  // "progNum:progNum"
+  midicmd("progNum:1").midi('IAC Driver'),
+  // "sysex:[sysexid]:[sysexdata]"
+  midicmd("sysex:[0x43]:[0x79:0x09:0x11:0x0A:0x00:0x00]").midi('IAC Driver')
+)
+```
@@ -8,6 +8,7 @@ import * as _WebMidi from 'webmidi';
 import { Pattern, getEventOffsetMs, isPattern, logger, ref } from '@strudel/core';
 import { noteToMidi, getControlName } from '@strudel/core';
 import { Note } from 'webmidi';
+
 // if you use WebMidi from outside of this package, make sure to import that instance:
 export const { WebMidi } = _WebMidi;

@@ -43,13 +44,16 @@ export function enableWebMidi(options = {}) {
      resolve(WebMidi);
      return;
    }
-    WebMidi.enable((err) => {
-      if (err) {
-        reject(err);
-      }
-      onReady?.(WebMidi);
-      resolve(WebMidi);
-    });
+    WebMidi.enable(
+      (err) => {
+        if (err) {
+          reject(err);
+        }
+        onReady?.(WebMidi);
+        resolve(WebMidi);
+      },
+      { sysex: true },
+    );
  });
 }

@@ -174,6 +178,7 @@ function normalize(value = 0, min = 0, max = 1, exp = 1) {
  normalized = Math.min(1, Math.max(0, normalized));
  return Math.pow(normalized, exp);
 }
+
 function mapCC(mapping, value) {
  return Object.keys(value)
    .filter((key) => !!mapping[getControlName(key)])
@@ -196,18 +201,127 @@ function sendCC(ccn, ccv, device, midichan, timeOffsetString) {
  device.sendControlChange(ccn, scaled, midichan, { time: timeOffsetString });
 }

-Pattern.prototype.midi = function (output) {
-  if (isPattern(output)) {
+// sends a program change message to the given device on the given channel
+function sendProgramChange(progNum, device, midichan, timeOffsetString) {
+  if (typeof progNum !== 'number' || progNum < 0 || progNum > 127) {
+    throw new Error('expected progNum (program change) to be a number between 0 and 127');
+  }
+  device.sendProgramChange(progNum, midichan, { time: timeOffsetString });
+}
+
+// sends a sysex message to the given device on the given channel
+function sendSysex(sysexid, sysexdata, device, timeOffsetString) {
+  if (Array.isArray(sysexid)) {
+    if (!sysexid.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+      throw new Error('all sysexid bytes must be integers between 0 and 255');
+    }
+  } else if (!Number.isInteger(sysexid) || sysexid < 0 || sysexid > 255) {
+    throw new Error('A:sysexid must be an number between 0 and 255 or an array of such integers');
+  }
+
+  if (!Array.isArray(sysexdata)) {
+    throw new Error('expected sysex to be an array of numbers (0-255)');
+  }
+  if (!sysexdata.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+    throw new Error('all sysex bytes must be integers between 0 and 255');
+  }
+  device.sendSysex(sysexid, sysexdata, { time: timeOffsetString });
+}
+
+// sends a NRPN message to the given device on the given channel
+function sendNRPN(nrpnn, nrpv, device, midichan, timeOffsetString) {
+  if (Array.isArray(nrpnn)) {
+    if (!nrpnn.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+      throw new Error('all nrpnn bytes must be integers between 0 and 255');
+    }
+  } else if (!Number.isInteger(nrpv) || nrpv < 0 || nrpv > 255) {
+    throw new Error('A:sysexid must be an number between 0 and 255 or an array of such integers');
+  }
+
+  device.sendNRPN(nrpnn, nrpv, midichan, { time: timeOffsetString });
+}
+
+// sends a pitch bend message to the given device on the given channel
+function sendPitchBend(midibend, device, midichan, timeOffsetString) {
+  if (typeof midibend !== 'number' || midibend < -1 || midibend > 1) {
+    throw new Error('expected midibend to be a number between -1 and 1');
+  }
+  device.sendPitchBend(midibend, midichan, { time: timeOffsetString });
+}
+
+// sends a channel aftertouch message to the given device on the given channel
+function sendAftertouch(miditouch, device, midichan, timeOffsetString) {
+  if (typeof miditouch !== 'number' || miditouch < 0 || miditouch > 1) {
+    throw new Error('expected miditouch to be a number between 0 and 1');
+  }
+  device.sendChannelAftertouch(miditouch, midichan, { time: timeOffsetString });
+}
+
+// sends a note message to the given device on the given channel
+function sendNote(note, velocity, duration, device, midichan, timeOffsetString) {
+  if (note == null || note === '') {
+    throw new Error('note cannot be null or empty');
+  }
+  if (velocity != null && (typeof velocity !== 'number' || velocity < 0 || velocity > 1)) {
+    throw new Error('velocity must be a number between 0 and 1');
+  }
+  if (duration != null && (typeof duration !== 'number' || duration < 0)) {
+    throw new Error('duration must be a positive number');
+  }
+
+  const midiNumber = typeof note === 'number' ? note : noteToMidi(note);
+  const midiNote = new Note(midiNumber, { attack: velocity, duration });
+  device.playNote(midiNote, midichan, {
+    time: timeOffsetString,
+  });
+}
+
+/**
+ * MIDI output: Opens a MIDI output port.
+ * @param {string | number} midiport MIDI device name or index defaulting to 0
+ * @param {object} options Additional MIDI configuration options
+ * @example
+ * note("c4").midichan(1).midi('IAC Driver Bus 1')
+ * @example
+ * note("c4").midichan(1).midi('IAC Driver Bus 1', { controller: true, latency: 50 })
+ */
+
+Pattern.prototype.midi = function (midiport, options = {}) {
+  if (isPattern(midiport)) {
    throw new Error(
-      `.midi does not accept Pattern input. Make sure to pass device name with single quotes. Example: .midi('${
+      `.midi does not accept Pattern input for midiport. Make sure to pass device name with single quotes. Example: .midi('${
        WebMidi.outputs?.[0]?.name || 'IAC Driver Bus 1'
      }')`,
    );
  }

+  // For backward compatibility
+  if (typeof midiport === 'object') {
+    const { port, isController = false, ...configOptions } = midiport;
+    options = {
+      isController,
+      ...configOptions,
+      ...options, // Keep any options passed separately
+    };
+    midiport = port;
+  }
+
+  let midiConfig = {
+    // Default configuration values
+    isController: false, // Disable sending notes for midi controllers
+    latencyMs: 34, // Default latency to get audio engine to line up in ms
+    noteOffsetMs: 10, // Default note-off offset to prevent glitching in ms
+    midichannel: 1, // Default MIDI channel
+    velocity: 0.9, // Default velocity
+    gain: 1, // Default gain
+    midimap: 'default', // Default MIDI map
+    midiport: midiport, // Store the port in the config
+    ...options, // Override defaults with provided options
+  };
+
  enableWebMidi({
    onEnabled: ({ outputs }) => {
-      const device = getDevice(output, outputs);
+      const device = getDevice(midiConfig.midiport, outputs);
      const otherOutputs = outputs.filter((o) => o.name !== device.name);
      logger(
        `Midi enabled! Using "${device.name}". ${
@@ -221,26 +335,35 @@ Pattern.prototype.midi = function (output) {

  return this.onTrigger((time_deprecate, hap, currentTime, cps, targetTime) => {
    if (!WebMidi.enabled) {
-      console.log('not enabled');
+      logger('Midi not enabled');
      return;
    }
    hap.ensureObjectValue();
+
    //magic number to get audio engine to line up, can probably be calculated somehow
-    const latencyMs = 34;
+    const latencyMs = midiConfig.latencyMs;
    // passing a string with a +num into the webmidi api adds an offset to the current time https://webmidijs.org/api/classes/Output
    const timeOffsetString = `+${getEventOffsetMs(targetTime, currentTime) + latencyMs}`;

-    // destructure value
+    // midi event values from hap with configurable defaults
    let {
      note,
+      nrpnn,
+      nrpv,
      ccn,
      ccv,
-      midichan = 1,
+      midichan = midiConfig.midichannel,
      midicmd,
-      gain = 1,
-      velocity = 0.9,
-      midimap = 'default',
-      midiport = output,
+      midibend,
+      miditouch,
+      polyTouch,
+      gain = midiConfig.gain,
+      velocity = midiConfig.velocity,
+      progNum,
+      sysexid,
+      sysexdata,
+      midimap = midiConfig.midimap,
+      midiport = midiConfig.midiport,
    } = hap.value;

    const device = getDevice(midiport, WebMidi.outputs);
@@ -252,24 +375,62 @@ Pattern.prototype.midi = function (output) {
    }

    velocity = gain * velocity;
+
+    // Handle midimap
    // if midimap is set, send a cc messages from defined controls
    if (midicontrolMap.has(midimap)) {
      const ccs = mapCC(midicontrolMap.get(midimap), hap.value);
      ccs.forEach(({ ccn, ccv }) => sendCC(ccn, ccv, device, midichan, timeOffsetString));
+    } else if (midimap !== 'default') {
+      // Add warning when a non-existent midimap is specified
+      logger(`[midi] midimap "${midimap}" not found! Available maps: ${[...midicontrolMap.keys()].join(', ')}`);
    }

-    // note off messages will often a few ms arrive late, try to prevent glitching by subtracting from the duration length
-    const duration = (hap.duration.valueOf() / cps) * 1000 - 10;
-    if (note != null) {
-      const midiNumber = typeof note === 'number' ? note : noteToMidi(note);
-      const midiNote = new Note(midiNumber, { attack: velocity, duration });
-      device.playNote(midiNote, midichan, {
-        time: timeOffsetString,
-      });
+    // Handle note
+    if (note !== undefined && !midiConfig.isController) {
+      // note off messages will often a few ms arrive late,
+      // try to prevent glitching by subtracting noteOffsetMs from the duration length
+      const duration = (hap.duration.valueOf() / cps) * 1000 - midiConfig.noteOffsetMs;
+
+      sendNote(note, velocity, duration, device, midichan, timeOffsetString);
    }
+
+    // Handle program change
+    if (progNum !== undefined) {
+      sendProgramChange(progNum, device, midichan, timeOffsetString);
+    }
+
+    // Handle sysex
+    // sysex data is consist of 2 arrays, first is sysexid, second is sysexdata
+    // sysexid is a manufacturer id it is either a number or an array of 3 numbers.
+    // list of manufacturer ids can be found here : https://midi.org/sysexidtable
+    // if sysexid is an array the first byte is 0x00
+
+    if (sysexid !== undefined && sysexdata !== undefined) {
+      sendSysex(sysexid, sysexdata, device, timeOffsetString);
+    }
+
+    // Handle control change
    if (ccv !== undefined && ccn !== undefined) {
      sendCC(ccn, ccv, device, midichan, timeOffsetString);
    }
+
+    // Handle NRPN non-registered parameter number
+    if (nrpnn !== undefined && nrpv !== undefined) {
+      sendNRPN(nrpnn, nrpv, device, midichan, timeOffsetString);
+    }
+
+    // Handle midibend
+    if (midibend !== undefined) {
+      sendPitchBend(midibend, device, midichan, timeOffsetString);
+    }
+
+    // Handle miditouch
+    if (miditouch !== undefined) {
+      sendAftertouch(miditouch, device, midichan, timeOffsetString);
+    }
+
+    // Handle midicmd
    if (hap.whole.begin + 0 === 0) {
      // we need to start here because we have the timing info
      device.sendStart({ time: timeOffsetString });
@@ -282,6 +443,19 @@ Pattern.prototype.midi = function (output) {
      device.sendStop({ time: timeOffsetString });
    } else if (['continue'].includes(midicmd)) {
      device.sendContinue({ time: timeOffsetString });
+    } else if (Array.isArray(midicmd)) {
+      if (midicmd[0] === 'progNum') {
+        sendProgramChange(midicmd[1], device, midichan, timeOffsetString);
+      } else if (midicmd[0] === 'cc') {
+        if (midicmd.length === 2) {
+          sendCC(midicmd[0], midicmd[1] / 127, device, midichan, timeOffsetString);
+        }
+      } else if (midicmd[0] === 'sysex') {
+        if (midicmd.length === 3) {
+          const [_, id, data] = midicmd;
+          sendSysex(id, data, device, timeOffsetString);
+        }
+      }
    }
  });
 };
@@ -289,6 +463,14 @@ Pattern.prototype.midi = function (output) {
 let listeners = {};
 const refs = {};

+/**
+ * MIDI input: Opens a MIDI input port to receive MIDI control change messages.
+ * @param {string | number} input MIDI device name or index defaulting to 0
+ * @returns {Function}
+ * @example
+ * let cc = await midin('IAC Driver Bus 1')
+ * note("c a f e").lpf(cc(0).range(0, 1000)).lpq(cc(1).range(0, 10)).sound("sawtooth")
+ */
 export async function midin(input) {
  if (isPattern(input)) {
    throw new Error(
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/midi",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "Midi API for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/mini",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Mini notation for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -1,38 +1,37 @@
 {
-    "name": "@strudel/motion",
-    "version": "1.1.0",
-    "description": "DeviceMotion API for strudel",
-    "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": [
-      "titdalcycles",
-      "strudel",
-      "pattern",
-      "livecoding",
-      "algorave"
-    ],
-    "author": "Yuta Nakayama <nkymut@gmail.com>",
-    "license": "AGPL-3.0-or-later",
-    "bugs": {
-      "url": "https://github.com/tidalcycles/strudel/issues"
-    },
-    "homepage": "https://github.com/tidalcycles/strudel#readme",
-    "dependencies": {
-      "@strudel/core": "workspace:*"
-    },
-    "devDependencies": {
+  "name": "@strudel/motion",
+  "version": "1.2.2",
+  "description": "DeviceMotion API for strudel",
+  "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": [
+    "titdalcycles",
+    "strudel",
+    "pattern",
+    "livecoding",
+    "algorave"
+  ],
+  "author": "Yuta Nakayama <nkymut@gmail.com>",
+  "license": "AGPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/tidalcycles/strudel/issues"
+  },
+  "homepage": "https://github.com/tidalcycles/strudel#readme",
+  "dependencies": {
+    "@strudel/core": "workspace:*"
+  },
+  "devDependencies": {
    "vite": "^6.0.11"
-    }
+  }
 }
-  
@@ -38,15 +38,10 @@ Pattern.prototype.mqtt = function (
  add_meta = true,
 ) {
  const key = host + '-' + client;
-  let connected = false;
  let password_entered = false;

-  if (!client) {
-    client = 'strudel-' + String(Math.floor(Math.random() * 1000000));
-  }
  function onConnect() {
    console.log('Connected to mqtt broker');
-    connected = true;
    if (password_entered) {
      document.cookie = 'mqtt_pass=' + password;
    }
@@ -56,6 +51,9 @@ Pattern.prototype.mqtt = function (
  if (connections[key]) {
    cx = connections[key];
  } else {
+    if (!client) {
+      client = 'strudel-' + String(Math.floor(Math.random() * 1000000));
+    }
    cx = new Paho.Client(host, client);
    connections[key] = cx;
    cx.onConnectionLost = onConnectionLost;
@@ -86,7 +84,7 @@ Pattern.prototype.mqtt = function (
  return this.withHap((hap) => {
    const onTrigger = (t_deprecate, hap, currentTime, cps, targetTime) => {
      let msg_topic = topic;
-      if (!connected) {
+      if (!cx || !cx.isConnected()) {
        return;
      }
      let message = '';
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/mqtt",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "MQTT API for strudel",
  "main": "mqtt.mjs",
  "type": "module",
@@ -37,7 +37,7 @@ function connect() {
 export function parseControlsFromHap(hap, cps) {
  hap.ensureObjectValue();
  const cycle = hap.wholeOrPart().begin.valueOf();
-  const delta = hap.duration.valueOf();
+  const delta = hap.duration.valueOf() / cps;
  const controls = Object.assign({}, { cps, cycle, delta }, hap.value);
  // make sure n and note are numbers
  controls.n && (controls.n = parseNumeral(controls.n));
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/osc",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "OSC messaging for strudel",
  "main": "osc.mjs",
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/reference",
-  "version": "1.1.0",
+  "version": "1.2.0",
  "description": "Headless reference of all strudel functions",
  "main": "index.mjs",
  "type": "module",
@@ -31,8 +31,6 @@
    "url": "https://github.com/tidalcycles/strudel/issues"
  },
  "homepage": "https://github.com/tidalcycles/strudel#readme",
-  "dependencies": {
-  },
  "devDependencies": {
    "vite": "^6.0.11"
  }
@@ -1,5 +1,4 @@
 import { defineConfig } from 'vite';
-import { dependencies } from './package.json';
 import { resolve } from 'path';

 // https://vitejs.dev/config/
@@ -11,9 +10,6 @@ export default defineConfig({
      formats: ['es'],
      fileName: (ext) => ({ es: 'index.mjs' })[ext],
    },
-    rollupOptions: {
-      external: [...Object.keys(dependencies)],
-    },
    target: 'esnext',
  },
 });
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/repl",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "Strudel REPL as a Web Component",
  "module": "index.mjs",
  "publishConfig": {
@@ -46,6 +46,7 @@
  },
  "devDependencies": {
    "@rollup/plugin-replace": "^6.0.2",
-    "vite": "^6.0.11"
+    "vite": "^6.0.11",
+    "vite-plugin-bundle-audioworklet": "workspace:*"
  }
 }
@@ -1,11 +1,12 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
 import replace from '@rollup/plugin-replace';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';

 // https://vitejs.dev/config/
 export default defineConfig({
  base: './',
-  plugins: [],
+  plugins: [bundleAudioWorkletPlugin()],
  build: {
    lib: {
      entry: resolve(__dirname, 'index.mjs'),
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/sampler",
-  "version": "0.1.0",
+  "version": "0.2.0",
  "description": "",
  "keywords": [
    "tidalcycles",
@@ -1,7 +1,7 @@
 #!/usr/bin/env node

 import cowsay from 'cowsay';
-import { createReadStream } from 'fs';
+import { createReadStream, existsSync } from 'fs';
 import { readdir } from 'fs/promises';
 import http from 'http';
 import { join, sep } from 'path';
@@ -70,12 +70,15 @@ const server = http.createServer(async (req, res) => {
    return res.end(JSON.stringify(banks));
  }
  let subpath = decodeURIComponent(req.url);
-  if (!files.includes(subpath)) {
+  const filePath = join(directory, subpath.split('/').join(sep));
+
+  //console.log('GET:', filePath);
+  const isFound = existsSync(filePath);
+  if (!isFound) {
    res.statusCode = 404;
    res.end('File not found');
    return;
  }
-  const filePath = join(directory, subpath.split('/').join(sep));
  const readStream = createReadStream(filePath);
  readStream.on('error', (err) => {
    res.statusCode = 500;
@@ -99,12 +102,6 @@ Object.keys(networkInterfaces).forEach((key) => {
  });
 });

-if (!IP) {
-  console.error("Unable to determine server's IP address.");
-  // eslint-disable-next-line
-  process.exit(1);
-}
-
 server.listen(PORT, IP_ADDRESS, () => {
  console.log(`@strudel/sampler is now serving audio files from:
 ${directory}
@@ -113,6 +110,6 @@ To use them in the Strudel REPL, run:
 samples('http://localhost:${PORT}')

 Or on a machine in the same network:
- samples('http://${IP}:${PORT}')
+ ${IP ? `samples('http://${IP}:${PORT}')` : `Unable to determine server's IP address.`}
 `);
 });
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/serial",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Webserial API for strudel",
  "main": "serial.mjs",
  "type": "module",
@@ -9,6 +9,13 @@ import {
 } from '@strudel/webaudio';
 import gm from './gm.mjs';

+let defaultSoundfontUrl = 'https://felixroos.github.io/webaudiofontdata/sound';
+let soundfontUrl = defaultSoundfontUrl;
+
+export function setSoundfontUrl(value) {
+  soundfontUrl = value;
+}
+
 let loadCache = {};
 async function loadFont(name) {
  if (loadCache[name]) {
@@ -16,7 +23,7 @@ async function loadFont(name) {
  }
  const load = async () => {
    // TODO: make soundfont source configurable
-    const url = `https://felixroos.github.io/webaudiofontdata/sound/${name}.js`;
+    const url = `${soundfontUrl}/${name}.js`;
    const preset = await fetch(url).then((res) => res.text());
    let [_, data] = preset.split('={');
    return eval('{' + data);
@@ -1,6 +1,6 @@
-import { getFontBufferSource, registerSoundfonts } from './fontloader.mjs';
+import { getFontBufferSource, registerSoundfonts, setSoundfontUrl } from './fontloader.mjs';
 import * as soundfontList from './list.mjs';
 import { startPresetNote } from 'sfumato';
 import { loadSoundfont } from './sfumato.mjs';

-export { loadSoundfont, startPresetNote, getFontBufferSource, soundfontList, registerSoundfonts };
+export { loadSoundfont, startPresetNote, getFontBufferSource, soundfontList, registerSoundfonts, setSoundfontUrl };
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/soundfonts",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "Soundsfont support for strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -212,6 +212,7 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
  constantNode.onended = () => {
    onComplete();
  };
+  return constantNode;
 }
 const mod = (freq, range = 1, type = 'sine') => {
  const ctx = getAudioContext();
@@ -1,6 +1,6 @@
 {
  "name": "superdough",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "simple web audio synth and sampler intended for live coding. inspired by superdirt and webdirt.",
  "main": "index.mjs",
  "type": "module",
@@ -32,7 +32,8 @@
  },
  "homepage": "https://github.com/tidalcycles/strudel#readme",
  "devDependencies": {
-    "vite": "^6.0.11"
+    "vite": "^6.0.11",
+    "vite-plugin-bundle-audioworklet": "workspace:*"
  },
  "dependencies": {
    "nanostores": "^0.11.3"
@@ -344,7 +344,9 @@ export async function onTriggerSample(t, value, onended, bank, resolveUrl) {
  };
  let envEnd = holdEnd + release + 0.01;
  bufferSource.stop(envEnd);
-  const stop = (endTime, playWholeBuffer) => {};
+  const stop = (endTime) => {
+    bufferSource.stop(endTime);
+  };
  const handle = { node: out, bufferSource, stop };

  // cut groups
@@ -8,16 +8,41 @@ import './feedbackdelay.mjs';
 import './reverb.mjs';
 import './vowel.mjs';
 import { clamp, nanFallback, _mod } from './util.mjs';
-import workletsUrl from './worklets.mjs?worker&url';
+import workletsUrl from './worklets.mjs?audioworklet';
 import { createFilter, gainNode, getCompressor, getWorklet } from './helpers.mjs';
 import { map } from 'nanostores';
 import { logger } from './logger.mjs';
 import { loadBuffer } from './sampler.mjs';

+export const DEFAULT_MAX_POLYPHONY = 128;
+const DEFAULT_AUDIO_DEVICE_NAME = 'System Standard';
+
+let maxPolyphony = DEFAULT_MAX_POLYPHONY;
+
+export function setMaxPolyphony(polyphony) {
+  maxPolyphony = parseInt(polyphony) ?? DEFAULT_MAX_POLYPHONY;
+}
+
+let multiChannelOrbits = false;
+export function setMultiChannelOrbits(bool) {
+  multiChannelOrbits = bool == true;
+}
+
 export const soundMap = map();

 export function registerSound(key, onTrigger, data = {}) {
-  soundMap.setKey(key.toLowerCase(), { onTrigger, data });
+  key = key.toLowerCase().replace(/\s+/g, '_');
+  soundMap.setKey(key, { onTrigger, data });
+}
+
+let gainCurveFunc = (val) => val;
+
+export function applyGainCurve(val) {
+  return gainCurveFunc(val);
+}
+
+export function setGainCurve(newGainCurveFunc) {
+  gainCurveFunc = newGainCurveFunc;
 }

 function aliasBankMap(aliasMap) {
@@ -85,6 +110,18 @@ export function getSound(s) {
  return soundMap.get()[s.toLowerCase()];
 }

+export const getAudioDevices = async () => {
+  await navigator.mediaDevices.getUserMedia({ audio: true });
+  let mediaDevices = await navigator.mediaDevices.enumerateDevices();
+  mediaDevices = mediaDevices.filter((device) => device.kind === 'audiooutput' && device.deviceId !== 'default');
+  const devicesMap = new Map();
+  devicesMap.set(DEFAULT_AUDIO_DEVICE_NAME, '');
+  mediaDevices.forEach((device) => {
+    devicesMap.set(device.label, device.deviceId);
+  });
+  return devicesMap;
+};
+
 const defaultDefaultValues = {
  s: 'triangle',
  gain: 0.8,
@@ -100,6 +137,7 @@ const defaultDefaultValues = {
  shapevol: 1,
  distortvol: 1,
  delay: 0,
+  byteBeatExpression: '0',
  delayfeedback: 0.5,
  delaytime: 0.25,
  orbit: 1,
@@ -155,18 +193,47 @@ export function getAudioContextCurrentTime() {
 let workletsLoading;
 function loadWorklets() {
  if (!workletsLoading) {
-    workletsLoading = getAudioContext().audioWorklet.addModule(workletsUrl);
+    const audioCtx = getAudioContext();
+    workletsLoading = audioCtx.audioWorklet.addModule(workletsUrl);
  }
+
  return workletsLoading;
 }

 // this function should be called on first user interaction (to avoid console warning)
 export async function initAudio(options = {}) {
-  const { disableWorklets = false } = options;
+  const {
+    disableWorklets = false,
+    maxPolyphony,
+    audioDeviceName = DEFAULT_AUDIO_DEVICE_NAME,
+    multiChannelOrbits = false,
+  } = options;
+
+  setMaxPolyphony(maxPolyphony);
+  setMultiChannelOrbits(multiChannelOrbits);
  if (typeof window === 'undefined') {
    return;
  }
-  await getAudioContext().resume();
+
+  const audioCtx = getAudioContext();
+
+  if (audioDeviceName != null && audioDeviceName != DEFAULT_AUDIO_DEVICE_NAME) {
+    try {
+      const devices = await getAudioDevices();
+      const id = devices.get(audioDeviceName);
+      const isValidID = (id ?? '').length > 0;
+      if (audioCtx.sinkId !== id && isValidID) {
+        await audioCtx.setSinkId(id);
+      }
+      logger(
+        `[superdough] Audio Device set to ${audioDeviceName}, it might take a few seconds before audio plays on all output channels`,
+      );
+    } catch {
+      logger('[superdough] failed to set audio interface', 'warning');
+    }
+  }
+
+  await audioCtx.resume();
  if (disableWorklets) {
    logger('[superdough]: AudioWorklets disabled with disableWorklets');
    return;
@@ -224,7 +291,7 @@ export const connectToDestination = (input, channels = [0, 1]) => {
  });
  stereoMix.connect(splitter);
  channels.forEach((ch, i) => {
-    splitter.connect(channelMerger, i % stereoMix.channelCount, clamp(ch, 0, ctx.destination.channelCount - 1));
+    splitter.connect(channelMerger, i % stereoMix.channelCount, ch % ctx.destination.channelCount);
  });
 };

@@ -237,7 +304,7 @@ export const panic = () => {
  channelMerger == null;
 };

-function getDelay(orbit, delaytime, delayfeedback, t) {
+function getDelay(orbit, delaytime, delayfeedback, t, channels) {
  if (delayfeedback > maxfeedback) {
    //logger(`delayfeedback was clamped to ${maxfeedback} to save your ears`);
  }
@@ -246,7 +313,7 @@ function getDelay(orbit, delaytime, delayfeedback, t) {
    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, [0, 1]);
+    connectToDestination(dly, channels);
    delays[orbit] = dly;
  }
  delays[orbit].delayTime.value !== delaytime && delays[orbit].delayTime.setValueAtTime(delaytime, t);
@@ -254,16 +321,9 @@ function getDelay(orbit, delaytime, delayfeedback, t) {
  return delays[orbit];
 }

-function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000, sweep = 2000) {
-  //gain
-  const ac = getAudioContext();
-  const lfoGain = ac.createGain();
-  lfoGain.gain.value = sweep * 2;
-  // centerFrequency = centerFrequency * 2;
-  // sweep = sweep * 1.5;
-
-  const lfo = getWorklet(ac, 'lfo-processor', {
-    frequency,
+export function getLfo(audioContext, time, end, properties = {}) {
+  return getWorklet(audioContext, 'lfo-processor', {
+    frequency: 1,
    depth: 1,
    skew: 0,
    phaseoffset: 0,
@@ -271,8 +331,13 @@ function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000
    end,
    shape: 1,
    dcoffset: -0.5,
+    ...properties,
  });
-  lfo.connect(lfoGain);
+}
+
+function getPhaser(time, end, frequency = 1, depth = 0.5, centerFrequency = 1000, sweep = 2000) {
+  const ac = getAudioContext();
+  const lfoGain = getLfo(ac, time, end, { frequency, depth: sweep * 2 });

  //filters
  const numStages = 2; //num of filters in series
@@ -303,12 +368,12 @@ function getFilterType(ftype) {

 let reverbs = {};
 let hasChanged = (now, before) => now !== undefined && now !== before;
-function getReverb(orbit, duration, fade, lp, dim, ir) {
+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, [0, 1]);
+    connectToDestination(reverb, channels);
    reverbs[orbit] = reverb;
  }
  if (
@@ -374,7 +439,14 @@ export function resetGlobalEffects() {
  analysersData = {};
 }

-export const superdough = async (value, t, hapDuration) => {
+let activeSoundSources = new Map();
+//music programs/audio gear usually increments inputs/outputs from 1, we need to subtract 1 from the input because the webaudio API channels start at 0
+
+function mapChannelNumbers(channels) {
+  return (Array.isArray(channels) ? channels : [channels]).map((ch) => ch - 1);
+}
+
+export const superdough = async (value, t, hapDuration, cps) => {
  const ac = getAudioContext();
  t = typeof t === 'string' && t.startsWith('=') ? Number(t.slice(1)) : ac.currentTime + t;
  let { stretch } = value;
@@ -435,7 +507,7 @@ export const superdough = async (value, t, hapDuration) => {
    bpsustain,
    bprelease,
    bandq = getDefaultValue('bandq'),
-    channels = getDefaultValue('channels'),
+
    //phaser
    phaserrate: phaser,
    phaserdepth = getDefaultValue('phaserdepth'),
@@ -471,16 +543,34 @@ export const superdough = async (value, t, hapDuration) => {
    compressorRelease,
  } = value;

-  gain = nanFallback(gain, 1);
-
-  //music programs/audio gear usually increments inputs/outputs from 1, so imitate that behavior
-  channels = (Array.isArray(channels) ? channels : [channels]).map((ch) => ch - 1);
+  const orbitChannels = mapChannelNumbers(
+    multiChannelOrbits && orbit > 0 ? [orbit * 2 - 1, orbit * 2] : getDefaultValue('channels'),
+  );
+  const channels = value.channels != null ? mapChannelNumbers(value.channels) : orbitChannels;

+  gain = applyGainCurve(nanFallback(gain, 1));
+  postgain = applyGainCurve(postgain);
+  shapevol = applyGainCurve(shapevol);
+  distortvol = applyGainCurve(distortvol);
+  delay = applyGainCurve(delay);
+  velocity = applyGainCurve(velocity);
  gain *= velocity; // velocity currently only multiplies with gain. it might do other things in the future
-  let toDisconnect = []; // audio nodes that will be disconnected when the source has ended
-  const onended = () => {
-    toDisconnect.forEach((n) => n?.disconnect());
-  };
+
+  const chainID = Math.round(Math.random() * 1000000);
+
+  // oldest audio nodes will be destroyed if maximum polyphony is exceeded
+  for (let i = 0; i <= activeSoundSources.size - maxPolyphony; i++) {
+    const ch = activeSoundSources.entries().next();
+    const source = ch.value[1];
+    const chainID = ch.value[0];
+    const endTime = t + 0.25;
+    source?.node?.gain?.linearRampToValueAtTime(0, endTime);
+    source?.stop?.(endTime);
+    activeSoundSources.delete(chainID);
+  }
+
+  let audioNodes = [];
+
  if (bank && s) {
    s = `${bank}_${s}`;
    value.s = s;
@@ -489,13 +579,18 @@ export const superdough = async (value, t, hapDuration) => {
  // get source AudioNode
  let sourceNode;
  if (source) {
-    sourceNode = source(t, value, hapDuration);
+    sourceNode = source(t, value, hapDuration, cps);
  } else if (getSound(s)) {
    const { onTrigger } = getSound(s);
-    const soundHandle = await onTrigger(t, value, onended);
+    const onEnded = () => {
+      audioNodes.forEach((n) => n?.disconnect());
+      activeSoundSources.delete(chainID);
+    };
+    const soundHandle = await onTrigger(t, value, onEnded);
+
    if (soundHandle) {
      sourceNode = soundHandle.node;
-      soundHandle.stop(t + hapDuration);
+      activeSoundSources.set(chainID, soundHandle);
    }
  } else {
    throw new Error(`sound ${s} not found! Is it loaded?`);
@@ -623,8 +718,9 @@ export const superdough = async (value, t, hapDuration) => {
  // delay
  let delaySend;
  if (delay > 0 && delaytime > 0 && delayfeedback > 0) {
-    const delyNode = getDelay(orbit, delaytime, delayfeedback, t);
+    const delyNode = getDelay(orbit, delaytime, delayfeedback, t, orbitChannels);
    delaySend = effectSend(post, delyNode, delay);
+    audioNodes.push(delaySend);
  }
  // reverb
  let reverbSend;
@@ -640,8 +736,9 @@ export const superdough = async (value, t, hapDuration) => {
      }
      roomIR = await loadBuffer(url, ac, ir, 0);
    }
-    const reverbNode = getReverb(orbit, roomsize, roomfade, roomlp, roomdim, roomIR);
+    const reverbNode = getReverb(orbit, roomsize, roomfade, roomlp, roomdim, roomIR, orbitChannels);
    reverbSend = effectSend(post, reverbNode, room);
+    audioNodes.push(reverbSend);
  }

  // analyser
@@ -649,14 +746,12 @@ export const superdough = async (value, t, hapDuration) => {
  if (analyze) {
    const analyserNode = getAnalyserById(analyze, 2 ** (fft + 5));
    analyserSend = effectSend(post, analyserNode, 1);
+    audioNodes.push(analyserSend);
  }

  // connect chain elements together
  chain.slice(1).reduce((last, current) => last.connect(current), chain[0]);
-
-  // toDisconnect = all the node that should be disconnected in onended callback
-  // this is crucial for performance
-  toDisconnect = chain.concat([delaySend, reverbSend, analyserSend]);
+  audioNodes = audioNodes.concat(chain);
 };

 export const superdoughTrigger = (t, hap, ct, cps) => {
@@ -1,5 +1,5 @@
 import { clamp, midiToFreq, noteToMidi } from './util.mjs';
-import { registerSound, getAudioContext } from './superdough.mjs';
+import { registerSound, getAudioContext, getLfo } from './superdough.mjs';
 import {
  applyFM,
  gainNode,
@@ -25,6 +25,13 @@ const getFrequencyFromValue = (value) => {

  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 noises = ['pink', 'white', 'brown', 'crackle'];
@@ -63,7 +70,9 @@ export function registerSynthSounds() {
        stop(envEnd);
        return {
          node,
-          stop: (releaseTime) => {},
+          stop: (endTime) => {
+            stop(endTime);
+          },
        };
      },
      { type: 'synth', prebake: true },
@@ -110,10 +119,12 @@ export function registerSynthSounds() {
      let envGain = gainNode(1);
      envGain = o.connect(envGain);

-      webAudioTimeout(
+      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3 * gainAdjustment, begin, holdend, 'linear');
+
+      let timeoutNode = webAudioTimeout(
        ac,
        () => {
-          o.disconnect();
+          destroyAudioWorkletNode(o);
          envGain.disconnect();
          onended();
          fm?.stop();
@@ -123,11 +134,164 @@ export function registerSynthSounds() {
        end,
      );

-      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 0.3 * gainAdjustment, begin, holdend, 'linear');
+      return {
+        node: envGain,
+        stop: (time) => {
+          timeoutNode.stop(time);
+        },
+      };
+    },
+    { prebake: true, type: 'synth' },
+  );
+
+  registerSound(
+    'bytebeat',
+    (begin, value, onended) => {
+      const defaultBeats = [
+        '(t%255 >= t/255%255)*255',
+        '(t*(t*8%60 <= 300)|(-t)*(t*4%512 < 256))+t/400',
+        't',
+        't*(t >> 10^t)',
+        't&128',
+        't&t>>8',
+        '((t%255+t%128+t%64+t%32+t%16+t%127.8+t%64.8+t%32.8+t%16.8)/3)',
+        '((t%64+t%63.8+t%64.15+t%64.35+t%63.5)/1.25)',
+        '(t&(t>>7)-t)',
+        '(sin(t*PI/128)*127+127)',
+        '((t^t/2+t+64*(sin((t*PI/64)+(t*PI/32768))+64))%128*2)',
+        '((t^t/2+t+64*(cos >> 0))%127.85*2)',
+        '((t^t/2+t+64)%128*2)',
+        '(((t * .25)^(t * .25)/100+(t * .25))%128)*2',
+        '((t^t/2+t+64)%7 * 24)',
+      ];
+      const { n = 0 } = value;
+      const frequency = getFrequencyFromValue(value);
+      const { byteBeatExpression = defaultBeats[n % defaultBeats.length], byteBeatStartTime } = value;
+
+      const ac = getAudioContext();
+
+      let { duration } = value;
+      const [attack, decay, sustain, release] = getADSRValues(
+        [value.attack, value.decay, value.sustain, value.release],
+        'linear',
+        [0.001, 0.05, 0.6, 0.01],
+      );
+      const holdend = begin + duration;
+      const end = holdend + release + 0.01;
+
+      let o = getWorklet(
+        ac,
+        'byte-beat-processor',
+        {
+          frequency,
+          begin,
+          end,
+        },
+        {
+          outputChannelCount: [2],
+        },
+      );
+
+      o.port.postMessage({ codeText: byteBeatExpression, byteBeatStartTime, frequency });
+
+      let envGain = gainNode(1);
+      envGain = o.connect(envGain);
+
+      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 1, begin, holdend, 'linear');
+
+      let timeoutNode = webAudioTimeout(
+        ac,
+        () => {
+          destroyAudioWorkletNode(o);
+          envGain.disconnect();
+          onended();
+        },
+        begin,
+        end,
+      );

      return {
        node: envGain,
-        stop: (time) => {},
+        stop: (time) => {
+          timeoutNode.stop(time);
+        },
+      };
+    },
+    { prebake: true, type: 'synth' },
+  );
+
+  registerSound(
+    'pulse',
+    (begin, value, onended) => {
+      const ac = getAudioContext();
+      let { pwrate, pwsweep } = value;
+      if (pwsweep == null) {
+        if (pwrate != null) {
+          pwsweep = 0.3;
+        } else {
+          pwsweep = 0;
+        }
+      }
+
+      if (pwrate == null && pwsweep != null) {
+        pwrate = 1;
+      }
+
+      let { duration, pw: pulsewidth = 0.5 } = value;
+      const frequency = getFrequencyFromValue(value);
+
+      const [attack, decay, sustain, release] = getADSRValues(
+        [value.attack, value.decay, value.sustain, value.release],
+        'linear',
+        [0.001, 0.05, 0.6, 0.01],
+      );
+      const holdend = begin + duration;
+      const end = holdend + release + 0.01;
+      let o = getWorklet(
+        ac,
+        'pulse-oscillator',
+        {
+          frequency,
+          begin,
+          end,
+          pulsewidth,
+        },
+        {
+          outputChannelCount: [2],
+        },
+      );
+
+      getPitchEnvelope(o.parameters.get('detune'), value, begin, holdend);
+      const vibratoOscillator = getVibratoOscillator(o.parameters.get('detune'), value, begin);
+      const fm = applyFM(o.parameters.get('frequency'), value, begin);
+      let envGain = gainNode(1);
+      envGain = o.connect(envGain);
+
+      getParamADSR(envGain.gain, attack, decay, sustain, release, 0, 1, begin, holdend, 'linear');
+      let lfo;
+      if (pwsweep != 0) {
+        lfo = getLfo(ac, begin, end, { frequency: pwrate, depth: pwsweep });
+        lfo.connect(o.parameters.get('pulsewidth'));
+      }
+      let timeoutNode = webAudioTimeout(
+        ac,
+        () => {
+          destroyAudioWorkletNode(o);
+          destroyAudioWorkletNode(lfo);
+          envGain.disconnect();
+          onended();
+          fm?.stop();
+          vibratoOscillator?.stop();
+        },
+        begin,
+        end,
+      );
+
+      return {
+        node: envGain,
+        stop: (time) => {
+          timeoutNode.stop(time);
+        },
      };
    },
    { prebake: true, type: 'synth' },
@@ -170,7 +334,9 @@ export function registerSynthSounds() {
        stop(envEnd);
        return {
          node,
-          stop: (releaseTime) => {},
+          stop: (endTime) => {
+            stop(endTime);
+          },
        };
      },
      { type: 'synth', prebake: true },
@@ -1,10 +1,11 @@
 import { defineConfig } from 'vite';
 import { dependencies } from './package.json';
 import { resolve } from 'path';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';

 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [],
+  plugins: [bundleAudioWorkletPlugin()],
  build: {
    lib: {
      entry: resolve(__dirname, 'index.mjs'),
@@ -75,7 +75,12 @@ const waveshapes = {
    return v - polyBlep(phase, dt);
  },
 };
-
+function getParamValue(block, param) {
+  if (param.length > 1) {
+    return param[block];
+  }
+  return param[0];
+}
 const waveShapeNames = Object.keys(waveshapes);
 class LFOProcessor extends AudioWorkletProcessor {
  static get parameterDescriptors() {
@@ -290,7 +295,7 @@ class LadderProcessor extends AudioWorkletProcessor {
    cutoff = (cutoff * 2 * _PI) / sampleRate;
    cutoff = cutoff > 1 ? 1 : cutoff;

-    const k = Math.min(8, resonance * 0.4);
+    const k = Math.min(8, resonance * 0.13);
    //               drive makeup  * resonance volume loss makeup
    let makeupgain = (1 / drive) * Math.min(1.75, 1 + k);

@@ -362,6 +367,11 @@ function getUnisonDetune(unison, detune, voiceIndex) {
  }
  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();
@@ -438,7 +448,7 @@ class SuperSawOscillatorProcessor extends AudioWorkletProcessor {
      const isOdd = (n & 1) == 1;

      //applies unison "spread" detune in semitones
-      const freq = frequency * Math.pow(2, getUnisonDetune(voices, freqspread, n) / 12);
+      const freq = applySemitoneDetuneToFrequency(frequency, getUnisonDetune(voices, freqspread, n));
      let gainL = gain1;
      let gainR = gain2;
      // invert right and left gain
@@ -648,3 +658,240 @@ class PhaseVocoderProcessor extends OLAProcessor {
 }

 registerProcessor('phase-vocoder-processor', PhaseVocoderProcessor);
+
+// Adapted from https://www.musicdsp.org/en/latest/Effects/221-band-limited-pwm-generator.html
+class PulseOscillatorProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.pi = _PI;
+    this.phi = -this.pi; // phase
+    this.Y0 = 0; // feedback memories
+    this.Y1 = 0;
+    this.PW = this.pi; // pulse width
+    this.B = 2.3; // feedback coefficient
+    this.dphif = 0; // filtered phase increment
+    this.envf = 0; // filtered envelope
+  }
+
+  static get parameterDescriptors() {
+    return [
+      {
+        name: 'begin',
+        defaultValue: 0,
+        max: Number.POSITIVE_INFINITY,
+        min: 0,
+      },
+
+      {
+        name: 'end',
+        defaultValue: 0,
+        max: Number.POSITIVE_INFINITY,
+        min: 0,
+      },
+
+      {
+        name: 'frequency',
+        defaultValue: 440,
+        min: Number.EPSILON,
+      },
+      {
+        name: 'detune',
+        defaultValue: 0,
+        min: Number.NEGATIVE_INFINITY,
+        max: Number.POSITIVE_INFINITY,
+      },
+      {
+        name: 'pulsewidth',
+        defaultValue: 1,
+        min: 0,
+        max: Number.POSITIVE_INFINITY,
+      },
+    ];
+  }
+
+  process(inputs, outputs, params) {
+    if (this.disconnected) {
+      return false;
+    }
+    if (currentTime <= params.begin[0]) {
+      return true;
+    }
+    if (currentTime >= params.end[0]) {
+      return false;
+    }
+    const output = outputs[0];
+    let env = 1,
+      dphi;
+
+    for (let i = 0; i < (output[0].length ?? 0); i++) {
+      const pw = (1 - clamp(getParamValue(i, params.pulsewidth), -0.99, 0.99)) * this.pi;
+      const detune = getParamValue(i, params.detune);
+      const freq = applySemitoneDetuneToFrequency(getParamValue(i, params.frequency), detune / 100);
+
+      dphi = freq * (this.pi / (sampleRate * 0.5)); // phase increment
+      this.dphif += 0.1 * (dphi - this.dphif);
+
+      env *= 0.9998; // exponential decay envelope
+      this.envf += 0.1 * (env - this.envf);
+
+      // Feedback coefficient control
+      this.B = 2.3 * (1 - 0.0001 * freq); // feedback limitation
+      if (this.B < 0) this.B = 0;
+
+      // Waveform generation (half-Tomisawa oscillators)
+      this.phi += this.dphif; // phase increment
+      if (this.phi >= this.pi) this.phi -= 2 * this.pi; // phase wrapping
+
+      // First half-Tomisawa generator
+      let out0 = Math.cos(this.phi + this.B * this.Y0); // self-phase modulation
+      this.Y0 = 0.5 * (out0 + this.Y0); // anti-hunting filter
+
+      // Second half-Tomisawa generator (with phase offset for pulse width)
+      let out1 = Math.cos(this.phi + this.B * this.Y1 + pw);
+      this.Y1 = 0.5 * (out1 + this.Y1); // anti-hunting filter
+
+      for (let o = 0; o < output.length; o++) {
+        // Combination of both oscillators with envelope applied
+        output[o][i] = 0.15 * (out0 - out1) * this.envf;
+      }
+    }
+
+    return true; // keep the audio processing going
+  }
+}
+
+registerProcessor('pulse-oscillator', PulseOscillatorProcessor);
+
+/**  BYTE BEATS */
+const chyx = {
+  /*bit*/ bitC: function (x, y, z) {
+    return x & y ? z : 0;
+  },
+  /*bit reverse*/ br: function (x, size = 8) {
+    if (size > 32) {
+      throw new Error('br() Size cannot be greater than 32');
+    } else {
+      let result = 0;
+      for (let idx = 0; idx < size - 0; idx++) {
+        result += chyx.bitC(x, 2 ** idx, 2 ** (size - (idx + 1)));
+      }
+      return result;
+    }
+  },
+  /*sin that loops every 128 "steps", instead of every pi steps*/ sinf: function (x) {
+    return Math.sin(x / (128 / Math.PI));
+  },
+  /*cos that loops every 128 "steps", instead of every pi steps*/ cosf: function (x) {
+    return Math.cos(x / (128 / Math.PI));
+  },
+  /*tan that loops every 128 "steps", instead of every pi steps*/ tanf: function (x) {
+    return Math.tan(x / (128 / Math.PI));
+  },
+  /*converts t into a string composed of it's bits, regex's that*/ regG: function (t, X) {
+    return X.test(t.toString(2));
+  },
+};
+
+// Create shortened Math functions
+let mathParams, byteBeatHelperFuncs;
+function getByteBeatFunc(codetext) {
+  if ((mathParams || byteBeatHelperFuncs) == null) {
+    mathParams = Object.getOwnPropertyNames(Math);
+    byteBeatHelperFuncs = mathParams.map((k) => Math[k]);
+    const chyxNames = Object.getOwnPropertyNames(chyx);
+    const chyxFuncs = chyxNames.map((k) => chyx[k]);
+    mathParams.push('int', 'window', ...chyxNames);
+    byteBeatHelperFuncs.push(Math.floor, globalThis, ...chyxFuncs);
+  }
+  return new Function(...mathParams, 't', `return 0,\n${codetext || 0};`).bind(globalThis, ...byteBeatHelperFuncs);
+}
+
+class ByteBeatProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.port.onmessage = (event) => {
+      let { codeText } = event.data;
+      const { byteBeatStartTime } = event.data;
+      if (byteBeatStartTime != null) {
+        this.t = 0;
+        this.initialOffset = Math.floor(byteBeatStartTime);
+      }
+
+      //Optimization pulled from dollchan.net: https://github.com/Chasyxx/EnBeat_NEW, it seemed important
+      //Optimize code like eval(unescape(escape`XXXX`.replace(/u(..)/g,"$1%")))
+      codeText = codeText
+        .trim()
+        .replace(
+          /^eval\(unescape\(escape(?:`|\('|\("|\(`)(.*?)(?:`|'\)|"\)|`\)).replace\(\/u\(\.\.\)\/g,["'`]\$1%["'`]\)\)\)$/,
+          (match, m1) => unescape(escape(m1).replace(/u(..)/g, '$1%')),
+        );
+
+      this.func = getByteBeatFunc(codeText);
+    };
+    this.initialOffset = null;
+    this.t = null;
+    this.func = null;
+  }
+
+  static get parameterDescriptors() {
+    return [
+      {
+        name: 'begin',
+        defaultValue: 0,
+        max: Number.POSITIVE_INFINITY,
+        min: 0,
+      },
+      {
+        name: 'frequency',
+        defaultValue: 440,
+        min: Number.EPSILON,
+      },
+      {
+        name: 'detune',
+        defaultValue: 0,
+        min: Number.NEGATIVE_INFINITY,
+        max: Number.POSITIVE_INFINITY,
+      },
+      {
+        name: 'end',
+        defaultValue: 0,
+        max: Number.POSITIVE_INFINITY,
+        min: 0,
+      },
+    ];
+  }
+
+  process(inputs, outputs, params) {
+    if (this.disconnected) {
+      return false;
+    }
+    if (currentTime <= params.begin[0]) {
+      return true;
+    }
+    if (currentTime >= params.end[0]) {
+      return false;
+    }
+    if (this.t == null) {
+      this.t = params.begin[0] * sampleRate;
+    }
+    const output = outputs[0];
+    for (let i = 0; i < output[0].length; i++) {
+      const detune = getParamValue(i, params.detune);
+      const freq = applySemitoneDetuneToFrequency(getParamValue(i, params.frequency), detune / 100);
+      let local_t = (this.t / (sampleRate / 256)) * freq + this.initialOffset;
+      const funcValue = this.func(local_t);
+      let signal = (funcValue & 255) / 127.5 - 1;
+      const out = signal * 0.2;
+
+      for (let c = 0; c < output.length; c++) {
+        //prevent speaker blowout via clipping if threshold exceeds
+        output[c][i] = clamp(out, -0.4, 0.4);
+      }
+      this.t = this.t + 1;
+    }
+
+    return true; // keep the audio processing going
+  }
+}
+
+registerProcessor('byte-beat-processor', ByteBeatProcessor);
@@ -1,11 +1,12 @@
 {
  "name": "@strudel/tidal",
-  "version": "0.1.0",
+  "version": "0.2.0",
+  "private": true,
  "description": "Experimental Tidal Code interpreter",
  "module": "tidal.mjs",
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/felixroos/hs2js.git"
+    "url": "git+https://github.com/tidalcycles/strudel/tree/main/packages/tidal"
  },
  "keywords": [
    "haskell",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/tonal",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Tonal functions for strudel",
  "main": "index.mjs",
  "publishConfig": {
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/transpiler",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Transpiler for strudel user code. Converts syntactically correct but semantically meaningless JS into evaluatable strudel code.",
  "main": "index.mjs",
  "type": "module",
@@ -0,0 +1,16 @@
+{
+  "name": "vite-plugin-bundle-audioworklet",
+  "main": "./vite-plugin-bundle-audioworklet.js",
+  "version": "0.1.1",
+  "description": "",
+  "keywords": [
+    "vite",
+    "audioworklet"
+  ],
+  "author": "Felix Roos <flix91@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "vite": "^6.0.11"
+  }
+}
@@ -0,0 +1,48 @@
+import { createLogger, build } from 'vite';
+
+const end = '?audioworklet';
+
+function bundleAudioWorkletPlugin() /* : PluginOption */ {
+  let viteConfig /* : UserConfig */;
+
+  return {
+    name: 'vite-plugin-bundle-audioworklet',
+    /* apply: 'build', */
+    enforce: 'post',
+
+    config(config) {
+      viteConfig = config;
+    },
+
+    async transform(_code, id) {
+      if (!id.endsWith(end)) {
+        return;
+      }
+      const entry = id.replace(end, '');
+      const quietLogger = createLogger();
+      quietLogger.info = () => undefined;
+
+      const output = await build({
+        configFile: false,
+        clearScreen: false,
+        customLogger: quietLogger,
+        build: {
+          lib: {
+            entry,
+            name: '_',
+            formats: ['iife'],
+          },
+          write: false,
+        },
+      });
+      if (!(output instanceof Array)) {
+        throw new Error('Expected output to be Array');
+      }
+      const iife = output[0].output[0].code;
+      const encoded = Buffer.from(iife, 'utf8').toString('base64');
+      return `export default "data:text/javascript;base64,${encoded}";`;
+    },
+  };
+}
+
+export default bundleAudioWorkletPlugin;
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/web",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "Easy to setup, opiniated bundle of Strudel for the browser.",
  "module": "web.mjs",
  "publishConfig": {
@@ -41,6 +41,7 @@
  },
  "devDependencies": {
    "@rollup/plugin-replace": "^6.0.2",
-    "vite": "^6.0.11"
+    "vite": "^6.0.11",
+    "vite-plugin-bundle-audioworklet": "workspace:*"
  }
 }
@@ -2,11 +2,12 @@ import { defineConfig } from 'vite';
 import { dependencies } from './package.json';
 import { resolve } from 'path';
 import replace from '@rollup/plugin-replace';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';

 // https://vitejs.dev/config/
 export default defineConfig({
  base: './',
-  plugins: [],
+  plugins: [bundleAudioWorkletPlugin()],
  build: {
    lib: {
      entry: resolve(__dirname, 'web.mjs'),
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/webaudio",
-  "version": "1.1.0",
+  "version": "1.2.3",
  "description": "Web Audio helpers for Strudel",
  "main": "index.mjs",
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@strudel/xen",
-  "version": "1.1.0",
+  "version": "1.2.2",
  "description": "Xenharmonic API for strudel",
  "main": "index.mjs",
  "type": "module",
@@ -39,6 +39,9 @@ importers:
      '@tauri-apps/cli':
        specifier: ^2.2.7
        version: 2.2.7
+      '@vitest/coverage-v8':
+        specifier: 3.0.4
+        version: 3.0.4(vitest@3.0.4)
      '@vitest/ui':
        specifier: ^3.0.4
        version: 3.0.4(vitest@3.0.4)
@@ -72,6 +75,9 @@ importers:
      prettier:
        specifier: ^3.4.2
        version: 3.4.2
+      vite-plugin-bundle-audioworklet:
+        specifier: workspace:*
+        version: link:packages/vite-plugin-bundle-audioworklet
      vitest:
        specifier: ^3.0.4
        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
@@ -267,6 +273,16 @@ importers:

  packages/embed: {}

+  packages/gamepad:
+    dependencies:
+      '@strudel/core':
+        specifier: workspace:*
+        version: link:../core
+    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)
+
  packages/hs2js:
    dependencies:
      web-tree-sitter:
@@ -415,6 +431,9 @@ importers:
      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

  packages/sampler:
    dependencies:
@@ -463,6 +482,9 @@ importers:
      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

  packages/tidal:
    dependencies:
@@ -527,6 +549,12 @@ importers:
        specifier: ^3.0.4
        version: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)

+  packages/vite-plugin-bundle-audioworklet:
+    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)
+
  packages/web:
    dependencies:
      '@strudel/core':
@@ -551,6 +579,9 @@ importers:
      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

  packages/webaudio:
    dependencies:
@@ -640,6 +671,9 @@ importers:
      '@strudel/draw':
        specifier: workspace:*
        version: link:../packages/draw
+      '@strudel/gamepad':
+        specifier: workspace:*
+        version: link:../packages/gamepad
      '@strudel/hydra':
        specifier: workspace:*
        version: link:../packages/hydra
@@ -764,6 +798,9 @@ importers:
      sharp:
        specifier: ^0.33.5
        version: 0.33.5
+      vite-plugin-bundle-audioworklet:
+        specifier: workspace:*
+        version: link:../packages/vite-plugin-bundle-audioworklet
      workbox-window:
        specifier: ^7.3.0
        version: 7.3.0
@@ -1412,6 +1449,10 @@ packages:
    resolution: {integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg==}
    engines: {node: '>=6.9.0'}

+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
  '@codemirror/autocomplete@6.18.4':
    resolution: {integrity: sha512-sFAphGQIqyQZfP2ZBsSHV7xQvo9Py0rV0dW7W3IMRdS+zDuNb2l3no78CvUaWKGfzFjI4FTrLdUSj86IGb2hRA==}

@@ -1834,6 +1875,10 @@ packages:
  '@isaacs/string-locale-compare@1.1.0':
    resolution: {integrity: sha512-SQ7Kzhh9+D+ZW9MA0zkYv3VXhIDNx+LzM6EJ+/65I3QY+enU6Itte7E5XX7EWrqLW2FN4n06GWzBnPoC3th2aQ==}

+  '@istanbuljs/schema@0.1.3':
+    resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
+    engines: {node: '>=8'}
+
  '@jest/schemas@29.6.3':
    resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -2818,6 +2863,15 @@ packages:
    peerDependencies:
      vite: ^4.2.0 || ^5.0.0 || ^6.0.0

+  '@vitest/coverage-v8@3.0.4':
+    resolution: {integrity: sha512-f0twgRCHgbs24Dp8cLWagzcObXMcuKtAwgxjJV/nnysPAJJk1JiKu/W0gIehZLmkljhJXU/E0/dmuQzsA/4jhA==}
+    peerDependencies:
+      '@vitest/browser': 3.0.4
+      vitest: 3.0.4
+    peerDependenciesMeta:
+      '@vitest/browser':
+        optional: true
+
  '@vitest/expect@3.0.4':
    resolution: {integrity: sha512-Nm5kJmYw6P2BxhJPkO3eKKhGYKRsnqJqf+r0yOGRKpEP+bSCBDsjXgiu1/5QFrnPMEgzfC38ZEjvCFgaNBC0Eg==}

@@ -4487,6 +4541,9 @@ packages:
  hs2js@0.1.0:
    resolution: {integrity: sha512-THlUIMX8tZf6gtbz5RUZ8xQUyKJEItsx7bxEBcouFIEWjeo90376WMocj3JEz6qTv5nM+tjo3vNvLf89XruMvg==}

+  html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
+
  html-escaper@3.0.3:
    resolution: {integrity: sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==}

@@ -4837,6 +4894,22 @@ packages:
    resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
    engines: {node: '>=0.10.0'}

+  istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+
+  istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+
+  istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
+
+  istanbul-reports@3.1.7:
+    resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==}
+    engines: {node: '>=8'}
+
  jackspeak@3.4.3:
    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}

@@ -6887,6 +6960,10 @@ packages:
    engines: {node: '>=10'}
    hasBin: true

+  test-exclude@7.0.1:
+    resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}
+    engines: {node: '>=18'}
+
  text-encoding-shim@1.0.5:
    resolution: {integrity: sha512-H7yYW+jRn4yhu60ygZ2f/eMhXPITRt4QSUTKzLm+eCaDsdX8avmgWpmtmHAzesjBVUTAypz9odu5RKUjX5HNYA==}

@@ -8568,6 +8645,8 @@ snapshots:
      '@babel/helper-string-parser': 7.25.9
      '@babel/helper-validator-identifier': 7.25.9

+  '@bcoe/v8-coverage@1.0.2': {}
+
  '@codemirror/autocomplete@6.18.4':
    dependencies:
      '@codemirror/language': 6.10.8
@@ -8934,6 +9013,8 @@ snapshots:

  '@isaacs/string-locale-compare@1.1.0': {}

+  '@istanbuljs/schema@0.1.3': {}
+
  '@jest/schemas@29.6.3':
    dependencies:
      '@sinclair/typebox': 0.27.8
@@ -10187,6 +10268,24 @@ snapshots:
    transitivePeerDependencies:
      - supports-color

+  '@vitest/coverage-v8@3.0.4(vitest@3.0.4)':
+    dependencies:
+      '@ampproject/remapping': 2.3.0
+      '@bcoe/v8-coverage': 1.0.2
+      debug: 4.4.0
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-lib-source-maps: 5.0.6
+      istanbul-reports: 3.1.7
+      magic-string: 0.30.17
+      magicast: 0.3.5
+      std-env: 3.8.0
+      test-exclude: 7.0.1
+      tinyrainbow: 2.0.0
+      vitest: 3.0.4(@types/debug@4.1.12)(@types/node@22.10.10)(@vitest/ui@3.0.4)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
+    transitivePeerDependencies:
+      - supports-color
+
  '@vitest/expect@3.0.4':
    dependencies:
      '@vitest/spy': 3.0.4
@@ -12202,6 +12301,8 @@ snapshots:
    dependencies:
      web-tree-sitter: 0.20.8

+  html-escaper@2.0.2: {}
+
  html-escaper@3.0.3: {}

  html-void-elements@3.0.0: {}
@@ -12540,6 +12641,27 @@ snapshots:

  isobject@3.0.1: {}

+  istanbul-lib-coverage@3.2.2: {}
+
+  istanbul-lib-report@3.0.1:
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+
+  istanbul-lib-source-maps@5.0.6:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.25
+      debug: 4.4.0
+      istanbul-lib-coverage: 3.2.2
+    transitivePeerDependencies:
+      - supports-color
+
+  istanbul-reports@3.1.7:
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+
  jackspeak@3.4.3:
    dependencies:
      '@isaacs/cliui': 8.0.2
@@ -15262,6 +15384,12 @@ snapshots:
      commander: 2.20.3
      source-map-support: 0.5.21

+  test-exclude@7.0.1:
+    dependencies:
+      '@istanbuljs/schema': 0.1.3
+      glob: 10.4.5
+      minimatch: 9.0.5
+
  text-encoding-shim@1.0.5: {}

  text-extensions@1.9.0: {}
@@ -11,7 +11,7 @@ import * as webaudio from '@strudel/webaudio';
 import { mini, m } from '@strudel/mini/mini.mjs';
 // import * as voicingHelpers from '@strudel/tonal/voicings.mjs';
 // import euclid from '@strudel/core/euclid.mjs';
-// import '@strudel/midi/midi.mjs';
+//import '@strudel/midi/midi.mjs';
 import * as tonalHelpers from '@strudel/tonal';
 import '@strudel/xen/xen.mjs';
 // import '@strudel/xen/tune.mjs';
@@ -21,6 +21,9 @@ import '@strudel/xen/xen.mjs';
 // import '@strudel/webaudio/webaudio.mjs';
 // import '@strudel/serial/serial.mjs';
 import '../website/src/repl/piano';
+//import * as motionHelpers from '../packages/motion/index.mjs';
+//import * as geolocationHelpers from '../packages/geolocation/index.mjs';
+import * as gamepadHelpers from '../packages/gamepad/index.mjs';

 class MockedNode {
  chain() {
@@ -123,6 +126,12 @@ const loadCsound = () => {};
 const loadCSound = () => {};
 const loadcsound = () => {};

+const midin = () => {
+  return (ccNum) => strudel.ref(() => 0); // returns ref with default value 0
+};
+
+const sysex = ([id, data]) => {};
+
 // TODO: refactor to evalScope
 evalScope(
  // Tone,
@@ -131,6 +140,7 @@ evalScope(
  uiHelpersMocked,
  webaudio,
  tonalHelpers,
+  gamepadHelpers,
  /*
  toneHelpers,
  voicingHelpers,
@@ -138,6 +148,8 @@ evalScope(
  uiHelpers,
  */
  {
+    midin,
+    sysex,
    // gist,
    // euclid,
    csound: id,
@@ -1,7 +1,9 @@
-import { configDefaults, defineConfig } from 'vitest/config';
+import { defineConfig } from 'vitest/config';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';

 /// <reference types="vitest" />
 export default defineConfig({
+  plugins: [bundleAudioWorkletPlugin()],
  test: {
    reporters: 'verbose',
    isolate: false,
@@ -5,6 +5,7 @@ import remarkToc from 'remark-toc';
 import rehypeSlug from 'rehype-slug';
 import rehypeAutolinkHeadings from 'rehype-autolink-headings';
 import rehypeUrls from 'rehype-urls';
+import bundleAudioWorkletPlugin from 'vite-plugin-bundle-audioworklet';

 import tailwind from '@astrojs/tailwind';
 import AstroPWA from '@vite-pwa/astro';
@@ -134,6 +135,7 @@ export default defineConfig({
  site,
  base,
  vite: {
+    plugins: [bundleAudioWorkletPlugin()],
    ssr: {
      // Example: Force a broken package to skip SSR processing, if needed
      // external: ['fraction.js'], // https://github.com/infusion/Fraction.js/issues/51
@@ -29,6 +29,7 @@
    "@strudel/csound": "workspace:*",
    "@strudel/desktopbridge": "workspace:*",
    "@strudel/draw": "workspace:*",
+    "@strudel/gamepad": "workspace:*",
    "@strudel/hydra": "workspace:*",
    "@strudel/midi": "workspace:*",
    "@strudel/mini": "workspace:*",
@@ -72,6 +73,7 @@
    "@vite-pwa/astro": "^0.5.0",
    "html-escaper": "^3.0.3",
    "sharp": "^0.33.5",
-    "workbox-window": "^7.3.0"
+    "workbox-window": "^7.3.0",
+    "vite-plugin-bundle-audioworklet": "workspace:*"
  }
 }
@@ -0,0 +1,7 @@
+
+100% free for personal and commercial use. 
+However it's limited on basic latin only, 
+contact riedjal@gmail.com for full glyph (based on ANSI encoding)
+and OTF features (alternates).
+
+src: https://www.dafont.com/cute-aurora.font?text=%24%3A+s%28%22bd%285%2C8%29%22%29.superimpose%28x+%3D%3E+x.note%28%22c2%22%29.midi%28device%29%29
@@ -36,8 +36,6 @@ export function Showcase() {
 }

 let _videos = [
-  { title: 'Coding Music With Strudel Workhop by Dan Gorelick and Viola He', id: 'oqyAJ4WeKoU' },
-  { title: 'Hexe - playing w strudel live coding music', id: '03m3F5xVOMg' },
  { title: 'DJ_Dave - Array [Lil Data Edit]', id: 'KUujFuTcuKc' },
  { title: 'DJ_Dave - Bitrot [v10101a Edit]', id: 'z_cJMdBp67Q' },
  { title: 'you will not steve reich your way out of it', id: 'xpILnXcWyuo' },
@@ -58,7 +56,6 @@ let _videos = [
  },
  { title: 'letSeaTstrudeL @ solstice stream 2023', id: 'fTiX6dVtdWQ' },
  { title: 'totalgee (Glen F) @ solstice stream 2023', id: 'IvI6uaE3nLU' },
-  { title: 'Dan Gorelick @ solstice stream 2023', id: 'qMJEljJyPi0' },
  //
  /* { // not sure if this is copyrighted ...
    title: 'Creative Coding @ Chalmers University of Technology, video by svt.se',
@@ -126,6 +123,11 @@ let _videos = [
      'A first foray into combining (an early version) strudel and hydra, using flok for collaborative coding.',
  },
  { title: 'froos @ Algorave 10th Birthday stream', id: 'IcMSocdKwvw' },
+  { title: 'todepasta 1.5', id: 'gCwaVu1Mijg' },
+  { title: 'Djenerative Music by Bogdan Vera @ TOPLAP solstice Dec 2024', id: 'LtMX4Lr1nzY' },
+  { title: 'La musique by BuboBubo @ TOPLAP solstice Dec 2024', id: 'Oz00Y_f80wU' },
+  { title: 'Livecode and vocal breaks by Switch Angel @ TOPLAP solstice Dec 2024', id: '2kzjOIsL6CM' },
+  { title: 'Eddyflux algorave set @ rudolf5', id: 'MXz8131Ut0A' },
 ];

 _shuffled = shuffleArray(_videos);
@@ -9,11 +9,11 @@ import UserFacingErrorMessage from '@src/repl/components/UserFacingErrorMessage'
 // }

 export default function UdelsEditor(Props) {
-  const { context } = Props;
+  const { context, ...editorProps } = Props;
  const { containerRef, editorRef, error, init, pending, started, handleTogglePlay } = context;

  return (
-    <div className={'h-full flex w-full flex-col relative'}>
+    <div className={'h-full flex w-full flex-col relative'} {...editorProps}>
      <Loader active={pending} />
      <BigPlayButton started={started} handleTogglePlay={handleTogglePlay} />
      <div className="grow flex relative overflow-hidden">
@@ -4,7 +4,7 @@ export default function UdelsHeader(Props) {
  const { numWindows, setNumWindows } = Props;

  return (
-    <header id="header" className="flex text-white  z-[100] text-lg select-none bg-neutral-900">
+    <header id="header" className="flex text-white  z-[100] text-lg select-none bg-neutral-800">
      <div className="px-4 items-center gap-2  flex space-x-2 md:pt-0 select-none">
        <h1 onClick={() => {}} className={'text-l cursor-pointer flex gap-4'}>
          <div className={'mt-[1px] cursor-pointer'}>🌀</div>
@@ -84,6 +84,7 @@ export const SIDEBAR: Sidebar = {
      { text: 'Music metadata', link: 'learn/metadata' },
      { text: 'CSound', link: 'learn/csound' },
      { text: 'Hydra', link: 'learn/hydra' },
+      { text: 'Input Devices', link: 'learn/input-devices' },
      { text: 'Device Motion', link: 'learn/devicemotion' },
    ],
    'Pattern Functions': [
@@ -1,6 +1,10 @@
 const ALLOW_MANY = ['by', 'url', 'genre', 'license'];

 export function getMetadata(raw_code) {
+  if (raw_code == null) {
+    console.error('could not extract metadata from missing pattern code');
+    raw_code = '';
+  }
  const comment_regexp = /\/\*([\s\S]*?)\*\/|\/\/(.*)$/gm;
  const comments = [...raw_code.matchAll(comment_regexp)].map((c) => (c[1] || c[2] || '').trim());
  const tags = {};
@@ -23,7 +23,7 @@ is equivalent to this Pattern without Mini Notation:
 Similarly, there is an equivalent function for every aspect of the mini notation.

 Which representation to use is a matter of context. As a rule of thumb, functions
-are better suited in a larger context, while mini notation is more practical for individiual rhythms.
+are better suited in a larger context, while mini notation is more practical for individual rhythms.

 ## Limits of Mini Notation

@@ -5,6 +5,6 @@ layout: ../../layouts/MainLayout.astro

 import { MiniRepl } from '../../docs/MiniRepl';
 import { JsDoc } from '../../docs/JsDoc';
-import DeviceMotion from '../../../../packages/motion/docs/devicemotion.mdx';
+import DeviceMotion from '@strudel/motion/docs/devicemotion.mdx';

 <DeviceMotion />
@@ -293,8 +293,6 @@ global effects use the same chain for all events of the same orbit:

 <JsDoc client:idle name="iresponse" h={0} />

-Next, we'll look at strudel's support for [Csound](/learn/csound).
-
 ## Phaser

 ### phaser
@@ -312,3 +310,5 @@ Next, we'll look at strudel's support for [Csound](/learn/csound).
 ### phasersweep

 <JsDoc client:idle name="phasersweep" h={0} />
+
+Next, we'll look at input / output via [MIDI, OSC and other methods](/learn/input-output).
@@ -0,0 +1,15 @@
+---
+title: Input Devices
+layout: ../../layouts/MainLayout.astro
+---
+
+import { MiniRepl } from '../../docs/MiniRepl';
+import { JsDoc } from '../../docs/JsDoc';
+
+import Gamepad from '@strudel/gamepad/docs/gamepad.mdx';
+
+# Input Devices
+
+Strudel supports various input devices like Gamepads and MIDI controllers to manipulate patterns in real-time.
+
+<Gamepad />
@@ -16,24 +16,97 @@ It is also possible to pattern other things with Strudel, such as software and h

 Strudel supports MIDI without any additional software (thanks to [webmidi](https://npmjs.com/package/webmidi)), just by adding methods to your pattern:

-## midi(outputName?)
+## midiin(inputName?)
+
+<JsDoc client:idle name="midin" h={0} />
+
+## midi(outputName?,options?)

 Either connect a midi device or use the IAC Driver (Mac) or Midi Through Port (Linux) for internal midi messages.
 If no outputName is given, it uses the first midi output it finds.

-<MiniRepl client:idle tune={`chord("<C^7 A7 Dm7 G7>").voicing().midi()`} />
+<MiniRepl
+  client:idle
+  tune={`
+$: chord("<C^7 A7 Dm7 G7>").voicing().midi('IAC Driver')
+`}
+/>

-In the console, you will see a log of the available MIDI devices as soon as you run the code, e.g. `Midi connected! Using "Midi Through Port-0".`
+In the console, you will see a log of the available MIDI devices as soon as you run the code,
+e.g.
+
+```
+ `Midi connected! Using "Midi Through Port-0".`
+```
+
+The `.midi()` function accepts an options object with the following properties:
+
+<MiniRepl
+  client:idle
+  tune={`$: note("d e c a f").midi('IAC Driver', { isController: true, midimap: 'default'})
+`}
+/>
+
+<details>
+<summary>Available Options</summary>
+
+| Option       | Type          | Default   | Description                                                            |
+| ------------ | ------------- | --------- | ---------------------------------------------------------------------- |
+| isController | boolean       | false     | When true, disables sending note messages. Useful for MIDI controllers |
+| latencyMs    | number        | 34        | Latency in milliseconds to align MIDI with audio engine                |
+| noteOffsetMs | number        | 10        | Offset in milliseconds for note-off messages to prevent glitching      |
+| midichannel  | number        | 1         | Default MIDI channel (1-16)                                            |
+| velocity     | number        | 0.9       | Default note velocity (0-1)                                            |
+| gain         | number        | 1         | Default gain multiplier for velocity (0-1)                             |
+| midimap      | string        | 'default' | Name of MIDI mapping to use for control changes                        |
+| midiport     | string/number | -         | MIDI device name or index                                              |
+
+</details>
+
+### midiport(outputName)
+
+Selects the MIDI output device to use, pattern can be used to switch between devices.
+
+```javascript
+$: midiport('IAC Driver');
+$: note('c a f e').midiport('<0 1 2 3>').midi();
+```
+
+<JsDoc client:idle name="midiport" h={0} />

 ## midichan(number)

 Selects the MIDI channel to use. If not used, `.midi` will use channel 1 by default.

-## ccn && ccv
+## midicmd(command)

+`midicmd` sends MIDI system real-time messages to control timing and transport on MIDI devices.
+
+It supports the following commands:
+
+- `clock`/`midiClock` - Sends MIDI timing clock messages
+- `start` - Sends MIDI start message
+- `stop` - Sends MIDI stop message
+- `continue` - Sends MIDI continue message
+
+// You can control the clock with a pattern and ensure it starts in sync when the repl begins.
+// Note: It might act unexpectedly if MIDI isn't set up initially.
+
+<MiniRepl
+  client:idle
+  tune={`$:stack(
+  midicmd("clock*48,<start stop>/2").midi('IAC Driver')
+)`}
+/>
+
+## control, ccn && ccv
+
+- `control` sends MIDI control change messages to your MIDI device.
 - `ccn` sets the cc number. Depends on your synths midi mapping
 - `ccv` sets the cc value. normalized from 0 to 1.

+<MiniRepl client:idle tune={`note("c a f e").control([74, sine.slow(4)]).midi()`} />
+
 <MiniRepl client:idle tune={`note("c a f e").ccn(74).ccv(sine.slow(4)).midi()`} />

 In the above snippet, `ccn` is set to 74, which is the filter cutoff for many synths. `ccv` is controlled by a saw pattern.
@@ -56,6 +129,48 @@ Instead of setting `ccn` and `ccv` directly, you can also create mappings with `

 <JsDoc client:idle name="defaultmidimap" h={0} />

+## progNum (Program Change)
+
+`progNum` sends MIDI program change messages to switch between different presets/patches on your MIDI device.
+Program change values should be numbers between 0 and 127.
+
+<MiniRepl client:idle tune={`// Switch between programs 0 and 1 every cycle
+progNum("<0 1>").midi()
+
+// Play notes while changing programs
+note("c3 e3 g3").progNum("<0 1 2>").midi()`} />
+
+Program change messages are useful for switching between different instrument sounds or presets during a performance.
+The exact sound that each program number maps to depends on your MIDI device's configuration.
+
+## sysex, sysexid && sysexdata (System Exclusive Message)
+
+`sysex` sends MIDI System Exclusive (SysEx) messages to your MIDI device.
+ysEx messages are device-specific commands that allow deeper control over synthesizer parameters.
+The value should be an array of numbers between 0-255 representing the SysEx data bytes.
+
+<MiniRepl
+  client:idle
+  tune={`// Send a simple SysEx message
+let id = 0x43; //Yamaha
+//let id = "0x00:0x20:0x32"; //Behringer ID can be an array of numbers
+let data = "0x79:0x09:0x11:0x0A:0x00:0x00"; // Set NSX-39 voice to say "Aa"
+$: note("c a f e").sysex(id, data).midi();
+$: note("c a f e").sysexid(id).sysexdata(data).midi();`}
+/>
+
+The exact format of SysEx messages depends on your MIDI device's specification.
+Consult your device's MIDI implementation guide for details on supported SysEx messages.
+
+## midibend && miditouch
+
+`midibend` sets MIDI pitch bend (-1 - 1)
+`miditouch` sets MIDI key after touch (0-1)
+
+<MiniRepl client:idle tune={`note("c a f e").midibend(sine.slow(4).range(-0.4,0.4)).midi()`} />
+
+<MiniRepl client:idle tune={`note("c a f e").miditouch(sine.slow(4).range(0,1)).midi()`} />
+
 # OSC/SuperDirt/StrudelDirt

 In TidalCycles, sound is usually generated using [SuperDirt](https://github.com/musikinformatik/SuperDirt/), which runs inside SuperCollider. Strudel also supports using SuperDirt, although it requires installing some additional software.
@@ -118,8 +233,8 @@ The following example shows how to send a pattern to an MQTT broker:
  client:only="react"
  tune={`"hello world"
    .mqtt(undefined, // username (undefined for open/public servers)
-          undefined, // password 
-          '/strudel-pattern', // mqtt 'topic' 
+          undefined, // password
+          '/strudel-pattern', // mqtt 'topic'
          'wss://mqtt.eclipseprojects.io:443/mqtt', // MQTT server address
          'mystrudel', // MQTT client id - randomly generated if not supplied
          0 // latency / delay before sending messages (0 = no delay)
@@ -130,12 +245,14 @@ The following example shows how to send a pattern to an MQTT broker:
 Other software can then receive the messages. For example using the [mosquitto](https://mosquitto.org/) commandline client tools:

 ```
-> mosquitto_sub  -h mqtt.eclipseprojects.io -p 1883  -t "/strudel-pattern"
-hello
-world
-hello
-world
-...
+
+> mosquitto_sub -h mqtt.eclipseprojects.io -p 1883 -t "/strudel-pattern"
+> hello
+> world
+> hello
+> world
+> ...
+
 ```

 Control patterns will be encoded as JSON, for example:
@@ -155,11 +272,17 @@ Control patterns will be encoded as JSON, for example:
 Will send messages like the following:

 ```
+
 {"s":"sax","speed":2}
 {"s":"sax","speed":2}
 {"s":"sax","speed":3}
 {"s":"sax","speed":2}
 ...
+
 ```

 Libraries for receiving MQTT are available for many programming languages.
+
+```
+
+```
@@ -66,7 +66,7 @@ While it saves resources, it can also lead to sounds not being audible the first

 # Sound Banks

-If we open the `sounds` tab and then `drum machines`, we can see that the drum samples are all prefixed with drum machine names: `RolandTR808_bd`, `RolandTR808_sd`, `RolandTR808_hh` etc..
+If we open the `sounds` tab and then `drum-machines`, we can see that the drum samples are all prefixed with drum machine names: `RolandTR808_bd`, `RolandTR808_sd`, `RolandTR808_hh` etc..

 We _could_ use them like this:

@@ -180,11 +180,12 @@ It assumes a `strudel.json` file to be present at the root of the repository:
 https://raw.githubusercontent.com/<user>/<repo>/<branch>/strudel.json
 ```

-## From Disk via "Import Sounds"
+## From Disk via "Import Sounds Folder"

 If you don't want to upload your samples to the internet, you can also load them from your local disk.
-Go to the `sounds` tab in the REPL and press "import sounds".
-Then you can select a folder that contains audio files. The folder you select can also contain subfolders with audio files.
+Go to the `sounds` tab in the REPL and open the `import-sounds` tab below the search bar.
+Press the "import sounds folder" button and select a folder that contains audio files.
+The folder you select can also contain subfolders with audio files.
 Example:

 ```
@@ -200,12 +201,13 @@ Example:
 ```

 In the above example the folder `samples` contains 2 subfolders `swoop` and `smash`, which contain audio files.
-If you select that `samples` folder, the `user` tab (next to the import sounds button) will then contain 2 new sounds: `swoop(3) smash(3)`
+If you select that `samples` folder, the `user` tab (next to the `import-sounds` tab) will then contain 2 new sounds: `swoop(3) smash(3)`
 The individual samples can the be played normally like `s("swoop:0 swoop:1 smash:2")`.
+The samples within each sound use zero-based indexing in alphabetical order.

 ## From Disk via @strudel/sampler

-Instead of loading your samples into your browser with the "import sounds" button, you can also serve the samples from a local file server.
+Instead of loading your samples into your browser with the "import sounds folder" button, you can also serve the samples from a local file server.
 The easiest way to do this is using [@strudel/sampler](https://www.npmjs.com/package/@strudel/sampler):

 ```sh
@@ -24,7 +24,7 @@ With the new stepwise `stepcat` function, the steps of the two patterns will be

 By default, steps are counted according to the 'top level' in mini-notation. For example `"a [b c] d e"` has five events in it per cycle, but is counted as four steps, where `[b c]` is counted as a single step.

-However, you can mark a different metrical level to count steps relative to, using a `^` at the start of a sub-pattern. If we do this to the subpattern in our example: `"a [^b c] d e"`, then the pattern is now counted as having _eight_ steps. This is because 'b' and 'c' are each counted as single steps, and the events in the pattenr are twice as long, and so counted as two steps each.
+However, you can mark a different metrical level to count steps relative to, using a `^` at the start of a sub-pattern. If we do this to the subpattern in our example: `"a [^b c] d e"`, then the pattern is now counted as having _eight_ steps. This is because 'b' and 'c' are each counted as single steps, and the events in the pattern are twice as long, and so counted as two steps each.

 ## Pacing the steps

@@ -100,9 +100,9 @@ Earlier versions of many of these functions had `s_` prefixes, and the `pace` fu

 <JsDoc client:idle name="contract" h={0} />

-### repeat
+### extend

-<JsDoc client:idle name="repeat" h={0} />
+<JsDoc client:idle name="extend" h={0} />

 ### take

@@ -116,10 +116,6 @@ Earlier versions of many of these functions had `s_` prefixes, and the `pace` fu

 <JsDoc client:idle name="polymeter" h={0} />

-### polymeterSteps
-
-<JsDoc client:idle name="polymeterSteps" h={0} />
-
 ### shrink

 <JsDoc client:idle name="shrink" h={0} />
@@ -1,12 +1,14 @@
 ---
+import HeadCommon from '@components/HeadCommon.astro';
 import { Udels } from '../../components/Udels/Udels.jsx';
-
-
-const { BASE_URL } = import.meta.env;
-const baseNoTrailing = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL;
 ---

-
-<body class="m-0">
-  <Udels client:only="react" />
-</body>
+<html lang="en" class="m-0">
+  <head>
+    <HeadCommon />
+    <title>Strudel UDELS</title>
+  </head>
+  <body class="m-0">
+    <Udels client:only="react" />
+  </body>
+</html>
@@ -69,3 +69,40 @@
  text-decoration: underline 0.18rem;
  text-underline-offset: 0.22rem;
 }
+
+/* Drag and drop styles */
+#code .cm-editor.cm-drag-over {
+  outline: 2px dashed #4caf50;
+  outline-offset: -2px;
+  background-color: rgba(76, 175, 80, 0.05) !important;
+}
+
+/* Download button styles */
+.download-button {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  z-index: 100;
+  background: rgba(0, 0, 0, 0.3);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 4px;
+  padding: 6px;
+  cursor: pointer;
+  color: rgba(255, 255, 255, 0.6);
+  transition: all 0.2s ease;
+  pointer-events: auto;
+}
+
+.download-button:hover {
+  background: rgba(0, 0, 0, 0.5);
+  color: rgba(255, 255, 255, 0.9);
+  border-color: rgba(255, 255, 255, 0.2);
+}
+
+.download-button:active {
+  transform: scale(0.95);
+}
+
+.download-button svg {
+  display: block;
+}
--- a/Show More
+++ b/Show More