Merge remote-tracking branch 'origin/main' into lu/synonyms

2026-01-25 20:27:52 +01:00 · 2026-01-25 20:27:52 +01:00 · f5e21a220b
commit f5e21a220b
parent 65dd79e374 f6e6df78a8
189 changed files with 8973 additions and 1862 deletions
--- a/packages/codemirror/codemirror.mjs
+++ b/packages/codemirror/codemirror.mjs
@ -24,10 +24,11 @@ import { sliderPlugin, updateSliderWidgets } from './slider.mjs';
 import { activateTheme, initTheme, theme } from './themes.mjs';
 import { isTooltipEnabled } from './tooltip.mjs';
 import { updateWidgets, widgetPlugin } from './widget.mjs';
+import { jumpToCharacter } from './labelJump.mjs';

 export { toggleBlockComment, toggleBlockCommentByLine, toggleComment, toggleLineComment } from '@codemirror/commands';

-const extensions = {
+export const extensions = {
  isLineWrappingEnabled: (on) => (on ? EditorView.lineWrapping : []),
  isBracketMatchingEnabled: (on) => (on ? bracketMatching({ brackets: '()[]{}<>' }) : []),
  isBracketClosingEnabled: (on) => (on ? closeBrackets() : []),
@ -48,7 +49,7 @@ const extensions = {
        ]
      : [],
 };
-const compartments = Object.fromEntries(Object.keys(extensions).map((key) => [key, new Compartment()]));
+export const compartments = Object.fromEntries(Object.keys(extensions).map((key) => [key, new Compartment()]));

 export const defaultSettings = {
  keybindings: 'codemirror',
@ -119,6 +120,14 @@ export function initEditor({ initialCode = '', onChange, onEvaluate, onStop, roo
            preventDefault: true,
            run: () => onStop?.(),
          },
+          {
+            key: 'Alt-w',
+            run: (view) => jumpToCharacter(view, '$', 1),
+          },
+          {
+            key: 'Alt-q',
+            run: (view) => jumpToCharacter(view, '$', -1),
+          },
          /* {
            key: 'Ctrl-Shift-.',
            run: () => (onPanic ? onPanic() : onStop?.()),
@ -293,9 +302,9 @@ export class StrudelMirror {
      console.warn('first frame could not be painted');
    }
  }
-  async evaluate() {
+  async evaluate(autostart = true) {
    this.flash();
-    await this.repl.evaluate(this.code);
+    await this.repl.evaluate(this.code, autostart);
  }
  async stop() {
    this.repl.scheduler.stop();
@ -411,7 +420,7 @@ export class StrudelMirror {
  }
 }

-function parseBooleans(value) {
+export function parseBooleans(value) {
  return { true: true, false: false }[value] ?? value;
 }

@ -425,6 +434,7 @@ function s4() {
 /**
 * Overrides the css of highlighted events. Make sure to use single quotes!
 * @name markcss
+ * @tag visualization
 * @example
 * note("c a f e")
 * .markcss('text-decoration:underline')
--- a/packages/codemirror/index.mjs
+++ b/packages/codemirror/index.mjs
@ -4,3 +4,4 @@ export * from './flash.mjs';
 export * from './slider.mjs';
 export * from './themes.mjs';
 export * from './widget.mjs';
+export { Vim } from './keybindings.mjs';
--- a/packages/codemirror/keybindings.mjs
+++ b/packages/codemirror/keybindings.mjs
@ -1,5 +1,5 @@
 import { defaultKeymap } from '@codemirror/commands';
-import { Prec } from '@codemirror/state';
+import { Prec, EditorState } from '@codemirror/state';
 import { keymap, ViewPlugin } from '@codemirror/view';
 // import { searchKeymap } from '@codemirror/search';
 import { emacs } from '@replit/codemirror-emacs';
@ -131,7 +131,13 @@ const keymaps = {
  vscode: vscodeExtension,
 };

+export { Vim } from '@replit/codemirror-vim';
+
 export function keybindings(name) {
  const active = keymaps[name];
-  return [active ? Prec.high(active()) : []];
+  const extensions = active ? [Prec.high(active())] : [];
+  if (name === 'vim') {
+    extensions.push(EditorState.allowMultipleSelections.of(true));
+  }
+  return extensions;
 }
--- a/packages/codemirror/labelJump.mjs
+++ b/packages/codemirror/labelJump.mjs
@ -0,0 +1,31 @@
+import { EditorSelection } from '@codemirror/state';
+import { SearchCursor } from '@codemirror/search';
+
+export function jumpToCharacter(view, character, direction = 1) {
+  const { state, dispatch } = view;
+  const pos = state.selection.main.head;
+  const cursor = new SearchCursor(state.doc, character);
+
+  let characterPositions = [];
+  let jumpPos;
+  while (!cursor.next().done) {
+    characterPositions.push(cursor.value.to);
+  }
+  if (!characterPositions.length) {
+    return false;
+  }
+  if (direction > 0) {
+    jumpPos = characterPositions.find((x) => x > pos + 1) ?? characterPositions.at(0); // Loop back around for convenience
+  } else {
+    jumpPos = characterPositions.reverse().find((x) => x < pos + 1) ?? characterPositions.at(0);
+  }
+
+  if (jumpPos == null) {
+    return false;
+  }
+  dispatch({
+    selection: EditorSelection.cursor(jumpPos - 1),
+    scrollIntoView: true,
+  });
+  return true;
+}
--- a/packages/codemirror/package.json
+++ b/packages/codemirror/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/codemirror",
-  "version": "1.2.6",
+  "version": "1.3.0",
  "description": "Codemirror Extensions for Strudel",
  "main": "index.mjs",
  "publishConfig": {
--- a/packages/codemirror/slider.mjs
+++ b/packages/codemirror/slider.mjs
@ -117,6 +117,7 @@ export const sliderPlugin = ViewPlugin.fromClass(
 * Displays a slider widget to allow the user manipulate a value
 *
 * @name slider
+ * @tags external_io, visualization
 * @param {number} value Initial value
 * @param {number} min Minimum value - optional, defaults to 0
 * @param {number} max Maximum value - optional, defaults to 1
--- a/packages/codemirror/themes.mjs
+++ b/packages/codemirror/themes.mjs
@ -198,6 +198,7 @@ export function activateTheme(name) {
  const themeSettings = settings[name] || settings.strudelTheme;
  // set css variables
  themeStyle.innerHTML = `:root {
+      color-scheme: ${themeSettings.light ? 'light' : 'dark'};
      ${Object.entries(themeSettings)
        // important to override fallback
        .map(([key, value]) => `--${key}: ${value} !important;`)
--- a/packages/codemirror/themes/CutiePi.mjs
+++ b/packages/codemirror/themes/CutiePi.mjs
@ -17,13 +17,15 @@ export const settings = {
  background: 'white',
  lineBackground: 'transparent',
  foreground: deepPurple,
+  muted: deepPurple + '50',
  caret: '#797977',
  selection: yellowPink,
  selectionMatch: '#2B323D',
-  gutterBackground: grey,
+  gutterBackground: pinkAccent,
  gutterForeground: lightGrey,
  gutterBorder: 'transparent',
  lineHighlight: pinkAccent,
+  light: true,
 };

 export default createTheme({
--- a/packages/codemirror/themes/algoboy.mjs
+++ b/packages/codemirror/themes/algoboy.mjs
@ -31,6 +31,7 @@ const palette = palettes['Sour Watermelon B'];
 export const settings = {
  background: palette[3],
  foreground: palette[1],
+  muted: palette[1] + '50',
  caret: palette[0],
  selection: palette[0],
  selectionMatch: palette[1],
--- a/packages/codemirror/themes/androidstudio.mjs
+++ b/packages/codemirror/themes/androidstudio.mjs
@ -8,6 +8,7 @@ export const settings = {
  background: '#282b2e',
  lineBackground: '#282b2e99',
  foreground: '#a9b7c6',
+  muted: '#a9b7c650',
  caret: '#00FF00',
  selection: '#343739',
  selectionMatch: '#343739',
@ -19,6 +20,7 @@ export default createTheme({
  settings: {
    background: '#282b2e',
    foreground: '#a9b7c6',
+    muted: '#a9b7c650',
    caret: '#00FF00',
    selection: '#4e5254',
    selectionMatch: '#4e5254',
--- a/packages/codemirror/themes/archBtw.mjs
+++ b/packages/codemirror/themes/archBtw.mjs
@ -12,6 +12,7 @@ export const settings = {
  background: hex[0],
  lineBackground: 'transparent',
  foreground: hex[1],
+  muted: hex[2],
  selection: hex[2],
  selectionMatch: hex[0],
  gutterBackground: hex[0],
--- a/packages/codemirror/themes/atomone.mjs
+++ b/packages/codemirror/themes/atomone.mjs
@ -11,6 +11,7 @@ export const settings = {
  background: '#272C35',
  lineBackground: '#272C3599',
  foreground: 'hsl(220, 14%, 71%)',
+  muted: 'hsl(220, 14%, 41%)',
  caret: '#797977',
  selection: '#ffffff30',
  selectionMatch: '#2B323D',
@ -25,6 +26,7 @@ export default createTheme({
  settings: {
    background: '#272C35',
    foreground: '#9d9b97',
+    muted: 'hsl(220, 14%, 41%)',
    caret: '#797977',
    selection: '#3d4c64',
    selectionMatch: '#3d4c64',
--- a/packages/codemirror/themes/aura.mjs
+++ b/packages/codemirror/themes/aura.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#21202e',
  lineBackground: '#21202e99',
  foreground: '#edecee',
+  muted: '#edecee50',
  caret: '#a277ff',
  selection: '#3d375e7f',
  selectionMatch: '#3d375e7f',
@ -18,6 +19,7 @@ export default createTheme({
  settings: {
    background: '#21202e',
    foreground: '#edecee',
+    muted: '#edecee50',
    caret: '#a277ff',
    selection: '#5a51898f',
    selectionMatch: '#5a51898f',
--- a/packages/codemirror/themes/bbedit.mjs
+++ b/packages/codemirror/themes/bbedit.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#FFFFFF',
  lineBackground: '#FFFFFF99',
  foreground: '#000000',
+  muted: '#00000050',
  caret: '#FBAC52',
  selection: '#FFD420',
  selectionMatch: '#FFD420',
@ -20,6 +21,7 @@ export default createTheme({
  settings: {
    background: '#FFFFFF',
    foreground: '#000000',
+    muted: '#00000050',
    caret: '#FBAC52',
    selection: '#FFD420',
    selectionMatch: '#FFD420',
--- a/packages/codemirror/themes/blackscreen.mjs
+++ b/packages/codemirror/themes/blackscreen.mjs
@ -2,7 +2,8 @@ import { tags as t } from '@lezer/highlight';
 import { createTheme } from './theme-helper.mjs';
 export const settings = {
  background: 'black',
-  foreground: 'white', // whats that?
+  foreground: 'white',
+  muted: '#ffffff50',
  caret: 'white',
  selection: '#ffffff20',
  selectionMatch: '#036dd626',
--- a/packages/codemirror/themes/bluescreen.mjs
+++ b/packages/codemirror/themes/bluescreen.mjs
@ -3,7 +3,8 @@ import { createTheme } from './theme-helper.mjs';
 export const settings = {
  background: '#051DB5',
  lineBackground: '#051DB550',
-  foreground: 'white', // whats that?
+  foreground: 'white',
+  muted: '#ffffff50',
  caret: 'white',
  selection: 'rgba(128, 203, 196, 0.5)',
  selectionMatch: '#036dd626',
--- a/packages/codemirror/themes/bluescreenlight.mjs
+++ b/packages/codemirror/themes/bluescreenlight.mjs
@ -11,6 +11,7 @@ export const settings = {
  background: hex[0],
  lineBackground: 'transparent',
  foreground: hex[2],
+  muted: hex[3],
  selection: hex[3],
  selectionMatch: hex[0],
  gutterBackground: hex[0],
--- a/packages/codemirror/themes/darcula.mjs
+++ b/packages/codemirror/themes/darcula.mjs
@ -9,6 +9,7 @@ export const settings = {
  background: '#242424',
  lineBackground: '#24242499',
  foreground: '#f8f8f2',
+  muted: '#f8f8f250',
  caret: '#FFFFFF',
  selection: 'rgba(255, 255, 255, 0.1)',
  selectionMatch: 'rgba(255, 255, 255, 0.2)',
@ -23,6 +24,7 @@ export default createTheme({
  settings: {
    background: '#242424',
    foreground: '#f8f8f2',
+    muted: '#f8f8f250',
    caret: '#FFFFFF',
    selection: 'rgba(255, 255, 255, 0.1)',
    selectionMatch: 'rgba(255, 255, 255, 0.2)',
--- a/packages/codemirror/themes/dracula.mjs
+++ b/packages/codemirror/themes/dracula.mjs
@ -11,6 +11,7 @@ export const settings = {
  background: '#282a36',
  lineBackground: '#282a3699',
  foreground: '#f8f8f2',
+  muted: '#f8f8f250',
  caret: '#f8f8f0',
  selection: 'rgba(255, 255, 255, 0.1)',
  selectionMatch: 'rgba(255, 255, 255, 0.2)',
@ -27,6 +28,7 @@ export default createTheme({
  settings: {
    background: '#282a36',
    foreground: '#f8f8f2',
+    muted: '#f8f8f250',
    caret: '#f8f8f0',
    selection: 'rgba(255, 255, 255, 0.1)',
    selectionMatch: 'rgba(255, 255, 255, 0.2)',
--- a/packages/codemirror/themes/duotoneDark.mjs
+++ b/packages/codemirror/themes/duotoneDark.mjs
@ -10,6 +10,7 @@ export const settings = {
  background: '#2a2734',
  lineBackground: '#2a273499',
  foreground: '#eeebff',
+  muted: '#eeebff50',
  caret: '#ffad5c',
  selection: 'rgba(255, 255, 255, 0.1)',
  gutterBackground: '#2a2734',
@ -22,6 +23,7 @@ export default createTheme({
  settings: {
    background: '#2a2734',
    foreground: '#6c6783',
+    muted: '#eeebff50',
    caret: '#ffad5c',
    selection: '#9a86fd',
    selectionMatch: '#9a86fd',
--- a/packages/codemirror/themes/eclipse.mjs
+++ b/packages/codemirror/themes/eclipse.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#fff',
  lineBackground: '#ffffff99',
  foreground: '#000',
+  muted: '#00000050',
  caret: '#FFFFFF',
  selection: '#d7d4f0',
  selectionMatch: '#d7d4f0',
@ -20,6 +21,7 @@ export default createTheme({
  settings: {
    background: '#fff',
    foreground: '#000',
+    muted: '#00000050',
    caret: '#FFFFFF',
    selection: '#d7d4f0',
    selectionMatch: '#d7d4f0',
--- a/packages/codemirror/themes/fruitDaw.mjs
+++ b/packages/codemirror/themes/fruitDaw.mjs
@ -23,6 +23,7 @@ export const settings = {
  background: hex[0],
  lineBackground: 'transparent',
  foreground: hex[10],
+  muted: hex[7],
  selection: hex[8],
  selectionMatch: hex[0],
  gutterBackground: hex[3],
--- a/packages/codemirror/themes/githubDark.mjs
+++ b/packages/codemirror/themes/githubDark.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#0d1117',
  lineBackground: '#0d111799',
  foreground: '#c9d1d9',
+  muted: '#c9d1d950',
  caret: '#c9d1d9',
  selection: '#003d73',
  selectionMatch: '#003d73',
@ -16,6 +17,7 @@ export default createTheme({
  settings: {
    background: '#0d1117',
    foreground: '#c9d1d9',
+    muted: '#c9d1d950',
    caret: '#c9d1d9',
    selection: '#003d73',
    selectionMatch: '#003d73',
--- a/packages/codemirror/themes/githubLight.mjs
+++ b/packages/codemirror/themes/githubLight.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#fff',
  lineBackground: '#ffffff99',
  foreground: '#24292e',
+  muted: '#24292e50',
  selection: '#BBDFFF',
  selectionMatch: '#BBDFFF',
  gutterBackground: '#fff',
@ -17,6 +18,7 @@ export default createTheme({
  settings: {
    background: '#fff',
    foreground: '#24292e',
+    muted: '#24292e50',
    selection: '#BBDFFF',
    selectionMatch: '#BBDFFF',
    gutterBackground: '#fff',
--- a/packages/codemirror/themes/green-text.mjs
+++ b/packages/codemirror/themes/green-text.mjs
@ -13,6 +13,7 @@ export const settings = {
  background: hex[0],
  lineBackground: 'transparent',
  foreground: hex[2],
+  muted: hex[2] + '50',
  selection: hex[4],
  selectionMatch: hex[0],
  gutterBackground: hex[0],
--- a/packages/codemirror/themes/gruvboxDark.mjs
+++ b/packages/codemirror/themes/gruvboxDark.mjs
@ -10,6 +10,7 @@ export const settings = {
  background: '#282828',
  lineBackground: '#28282899',
  foreground: '#ebdbb2',
+  muted: '#ebdbb250',
  caret: '#ebdbb2',
  selection: '#bdae93',
  selectionMatch: '#bdae93',
@ -23,6 +24,7 @@ export default createTheme({
  settings: {
    background: '#282828',
    foreground: '#ebdbb2',
+    muted: '#ebdbb250',
    caret: '#ebdbb2',
    selection: '#b99d555c',
    selectionMatch: '#b99d555c',
--- a/packages/codemirror/themes/gruvboxLight.mjs
+++ b/packages/codemirror/themes/gruvboxLight.mjs
@ -11,6 +11,7 @@ export const settings = {
  background: '#fbf1c7',
  lineBackground: '#fbf1c799',
  foreground: '#3c3836',
+  muted: '#3c383650',
  caret: '#af3a03',
  selection: '#ebdbb2',
  selectionMatch: '#bdae93',
@ -25,6 +26,7 @@ export default createTheme({
  settings: {
    background: '#fbf1c7',
    foreground: '#3c3836',
+    muted: '#3c383650',
    caret: '#af3a03',
    selection: '#bdae9391',
    selectionMatch: '#bdae9391',
--- a/packages/codemirror/themes/materialDark.mjs
+++ b/packages/codemirror/themes/materialDark.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#212121',
  lineBackground: '#21212199',
  foreground: '#bdbdbd',
+  muted: '#bdbdbd50',
  caret: '#a0a4ae',
  selection: '#d7d4f0',
  selectionMatch: '#d7d4f0',
@ -19,6 +20,7 @@ export default createTheme({
  settings: {
    background: '#212121',
    foreground: '#bdbdbd',
+    muted: '#bdbdbd50',
    caret: '#a0a4ae',
    selection: '#d7d4f063',
    selectionMatch: '#d7d4f063',
--- a/packages/codemirror/themes/materialLight.mjs
+++ b/packages/codemirror/themes/materialLight.mjs
@ -5,7 +5,8 @@ export const settings = {
  light: true,
  background: '#FAFAFA',
  lineBackground: '#FAFAFA99',
-  foreground: '#90A4AE',
+  foreground: '#6182B8',
+  muted: '#6182B850',
  caret: '#272727',
  selection: '#80CBC440',
  selectionMatch: '#FAFAFA',
@ -19,6 +20,7 @@ export default createTheme({
  settings: {
    background: '#FAFAFA',
    foreground: '#90A4AE',
+    muted: '#6182B850',
    caret: '#272727',
    selection: '#80CBC440',
    selectionMatch: '#80CBC440',
--- a/packages/codemirror/themes/monokai.mjs
+++ b/packages/codemirror/themes/monokai.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#272822',
  lineBackground: '#27282299',
  foreground: '#FFFFFF',
+  muted: '#FFFFFF50',
  caret: '#FFFFFF',
  selection: '#49483E',
  selectionMatch: '#49483E',
@ -18,6 +19,7 @@ export default createTheme({
  settings: {
    background: '#272822',
    foreground: '#FFFFFF',
+    muted: '#FFFFFF50',
    caret: '#FFFFFF',
    selection: '#49483E',
    selectionMatch: '#49483E',
--- a/packages/codemirror/themes/noctisLilac.mjs
+++ b/packages/codemirror/themes/noctisLilac.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#f2f1f8',
  lineBackground: '#f2f1f899',
  foreground: '#0c006b',
+  muted: '#0c006b50',
  caret: '#5c49e9',
  selection: '#d5d1f2',
  selectionMatch: '#d5d1f2',
@ -19,6 +20,7 @@ export default createTheme({
  settings: {
    background: '#f2f1f8',
    foreground: '#0c006b',
+    muted: '#0c006b50',
    caret: '#5c49e9',
    selection: '#d5d1f2',
    selectionMatch: '#d5d1f2',
--- a/packages/codemirror/themes/nord.mjs
+++ b/packages/codemirror/themes/nord.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#2e3440',
  lineBackground: '#2e344099',
  foreground: '#FFFFFF',
+  muted: '#FFFFFF50',
  caret: '#FFFFFF',
  selection: '#3b4252',
  selectionMatch: '#e5e9f0',
@ -20,6 +21,7 @@ export default createTheme({
  settings: {
    background: '#2e3440',
    foreground: '#FFFFFF',
+    muted: '#FFFFFF50',
    caret: '#FFFFFF',
    selection: '#00000073',
    selectionMatch: '#00000073',
--- a/packages/codemirror/themes/red-text.mjs
+++ b/packages/codemirror/themes/red-text.mjs
@ -13,6 +13,7 @@ export const settings = {
  background: hex[0],
  lineBackground: 'transparent',
  foreground: hex[2],
+  muted: hex[2] + '50',
  selection: hex[4],
  selectionMatch: hex[0],
  gutterBackground: hex[0],
--- a/packages/codemirror/themes/solarizedDark.mjs
+++ b/packages/codemirror/themes/solarizedDark.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#002b36',
  lineBackground: '#002b3699',
  foreground: '#93a1a1',
+  muted: '#93a1a150',
  caret: '#839496',
  selection: '#173541',
  selectionMatch: '#aafe661a',
@ -45,6 +46,7 @@ export default createTheme({
  settings: {
    background: c.background,
    foreground: c.foreground,
+    muted: c.muted,
    caret: c.cursor,
    selection: c.selection,
    selectionMatch: c.selection,
--- a/packages/codemirror/themes/solarizedLight.mjs
+++ b/packages/codemirror/themes/solarizedLight.mjs
@ -8,6 +8,7 @@ export const settings = {
  background: '#fdf6e3',
  lineBackground: '#fdf6e399',
  foreground: '#657b83',
+  muted: '#657b8350',
  caret: '#586e75',
  selection: '#dfd9c8',
  selectionMatch: '#dfd9c8',
@ -19,6 +20,7 @@ export const settings = {
 const c = {
  background: '#FDF6E3',
  foreground: '#657B83',
+  muted: '#657b8350',
  selection: '#EEE8D5',
  selectionMatch: '#EEE8D5',
  cursor: '#657B83',
--- a/packages/codemirror/themes/sonic-pink.mjs
+++ b/packages/codemirror/themes/sonic-pink.mjs
@ -13,6 +13,7 @@ export const settings = {
  background: '#000000',
  lineBackground: 'transparent',
  foreground: hex[4],
+  muted: hex[6],
  selection: hex[6],
  gutterBackground: hex[0],
  gutterForeground: hex[5],
--- a/packages/codemirror/themes/strudel-theme.mjs
+++ b/packages/codemirror/themes/strudel-theme.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#222',
  lineBackground: '#22222299',
  foreground: '#fff',
+  muted: '#8a919966',
  caret: '#ffcc00',
  selection: 'rgba(128, 203, 196, 0.5)',
  selectionMatch: '#036dd626',
--- a/packages/codemirror/themes/sublime.mjs
+++ b/packages/codemirror/themes/sublime.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#303841',
  lineBackground: '#30384199',
  foreground: '#FFFFFF',
+  muted: '#FFFFFF50',
  caret: '#FBAC52',
  selection: '#4C5964',
  selectionMatch: '#3A546E',
@ -18,6 +19,7 @@ export default createTheme({
  settings: {
    background: '#303841',
    foreground: '#FFFFFF',
+    muted: '#FFFFFF50',
    caret: '#FBAC52',
    selection: '#4C5964',
    selectionMatch: '#3A546E',
--- a/packages/codemirror/themes/teletext.mjs
+++ b/packages/codemirror/themes/teletext.mjs
@ -9,7 +9,8 @@ let colorD = '#f8fc55';

 export const settings = {
  background: '#000000',
-  foreground: colorA, // whats that?
+  foreground: colorA,
+  muted: colorA + '50',
  caret: colorC,
  selection: colorD,
  selectionMatch: colorA,
--- a/packages/codemirror/themes/tokioNightStorm.mjs
+++ b/packages/codemirror/themes/tokioNightStorm.mjs
@ -4,7 +4,8 @@ import { createTheme } from './theme-helper.mjs';
 export const settings = {
  background: '#24283b',
  lineBackground: '#24283b99',
-  foreground: '#7982a9',
+  foreground: '#f9f2f9',
+  muted: '#f9f2f950',
  caret: '#c0caf5',
  selection: '#6f7bb630',
  selectionMatch: '#1f2335',
@ -18,7 +19,8 @@ export default createTheme({
  theme: 'dark',
  settings: {
    background: '#24283b',
-    foreground: '#7982a9',
+    foreground: '#f9f2f9',
+    muted: '#f9f2f950',
    caret: '#c0caf5',
    selection: '#6f7bb630',
    selectionMatch: '#343b5f',
--- a/packages/codemirror/themes/tokyoNight.mjs
+++ b/packages/codemirror/themes/tokyoNight.mjs
@ -4,7 +4,8 @@ import { createTheme } from './theme-helper.mjs';
 export const settings = {
  background: '#1a1b26',
  lineBackground: '#1a1b2699',
-  foreground: '#787c99',
+  foreground: '#f8fcf9',
+  muted: '#f8fcf950',
  caret: '#c0caf5',
  selection: '#515c7e40',
  selectionMatch: '#16161e',
@ -18,7 +19,8 @@ export default createTheme({
  theme: 'dark',
  settings: {
    background: '#1a1b26',
-    foreground: '#787c99',
+    foreground: '#f8fcf9',
+    muted: '#f8fcf950',
    caret: '#c0caf5',
    selection: '#515c7e40',
    selectionMatch: '#16161e',
--- a/packages/codemirror/themes/tokyoNightDay.mjs
+++ b/packages/codemirror/themes/tokyoNightDay.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#e1e2e7',
  lineBackground: '#e1e2e799',
  foreground: '#3760bf',
+  muted: '#3760bf50',
  caret: '#3760bf',
  selection: '#99a7df',
  selectionMatch: '#99a7df',
@ -20,6 +21,7 @@ export default createTheme({
  settings: {
    background: '#e1e2e7',
    foreground: '#3760bf',
+    muted: '#3760bf50',
    caret: '#3760bf',
    selection: '#99a7df',
    selectionMatch: '#99a7df',
--- a/packages/codemirror/themes/vscodeDark.mjs
+++ b/packages/codemirror/themes/vscodeDark.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#1e1e1e',
  lineBackground: '#1e1e1e99',
  foreground: '#fff',
+  muted: '#ffffff50',
  caret: '#c6c6c6',
  selection: '#6199ff2f',
  selectionMatch: '#72a1ff59',
@ -19,6 +20,7 @@ export default createTheme({
  settings: {
    background: '#1e1e1e',
    foreground: '#fff',
+    muted: '#ffffff50',
    caret: '#c6c6c6',
    selection: '#6199ff2f',
    selectionMatch: '#72a1ff59',
--- a/packages/codemirror/themes/vscodeLight.mjs
+++ b/packages/codemirror/themes/vscodeLight.mjs
@ -5,6 +5,7 @@ export const settings = {
  background: '#ffffff',
  lineBackground: '#ffffff50',
  foreground: '#383a42',
+  muted: '#383a4250',
  caret: '#000',
  selection: '#add6ff',
  selectionMatch: '#a8ac94',
@ -20,6 +21,7 @@ export default createTheme({
  settings: {
    background: '#ffffff',
    foreground: '#383a42',
+    muted: '#383a4250',
    caret: '#000',
    selection: '#add6ff',
    selectionMatch: '#a8ac94',
--- a/packages/codemirror/themes/whitescreen.mjs
+++ b/packages/codemirror/themes/whitescreen.mjs
@ -2,7 +2,8 @@ import { tags as t } from '@lezer/highlight';
 import { createTheme } from './theme-helper.mjs';
 export const settings = {
  background: 'white',
-  foreground: 'black', // whats that?
+  foreground: 'black',
+  muted: '#00000050',
  caret: 'black',
  selection: 'rgba(128, 203, 196, 0.5)',
  selectionMatch: '#ffffff26',
--- a/packages/codemirror/themes/xcodeLight.mjs
+++ b/packages/codemirror/themes/xcodeLight.mjs
@ -6,6 +6,7 @@ export const settings = {
  background: '#fff',
  lineBackground: '#ffffff99',
  foreground: '#3D3D3D',
+  muted: '#3D3D3D50',
  selection: '#BBDFFF',
  selectionMatch: '#BBDFFF',
  gutterBackground: '#fff',
@ -18,6 +19,7 @@ export default createTheme({
  settings: {
    background: '#fff',
    foreground: '#3D3D3D',
+    muted: '#3D3D3D50',
    selection: '#BBDFFF',
    selectionMatch: '#BBDFFF',
    gutterBackground: '#fff',
--- a/packages/core/bench/signal.bench.mjs
+++ b/packages/core/bench/signal.bench.mjs
@ -0,0 +1,49 @@
+import { describe, bench } from 'vitest';
+
+import { calculateSteps, rand, useRNG } from '../index.mjs';
+
+const testingResolution = 128;
+
+const _generateRandomPattern = () => rand.iter(testingResolution).fast(testingResolution).firstCycle();
+
+describe('old random', () => {
+  calculateSteps(true);
+  bench(
+    '+tactus',
+    () => {
+      useRNG('legacy');
+      _generateRandomPattern();
+    },
+    {
+      time: 1000,
+      teardown() {
+        useRNG('legacy');
+      },
+    },
+  );
+
+  calculateSteps(false);
+  bench(
+    '-tactus',
+    () => {
+      useRNG('precise');
+      _generateRandomPattern();
+    },
+    {
+      time: 1000,
+      teardown() {
+        useRNG('legacy');
+      },
+    },
+  );
+});
+
+describe('random', () => {
+  calculateSteps(true);
+  bench('+tactus', _generateRandomPattern, { time: 1000 });
+
+  calculateSteps(false);
+  bench('-tactus', _generateRandomPattern, { time: 1000 });
+});
+
+calculateSteps(true);
--- a/packages/core/controls.mjs
+++ b/packages/core/controls.mjs
--- a/packages/core/drawLine.mjs
+++ b/packages/core/drawLine.mjs
@ -15,6 +15,7 @@ import Fraction, { gcd } from './fraction.mjs';
 * - "-" hold previous value
 * - "." silence
 *
+ * @tags visualization
 * @param {Pattern} pattern the pattern to use
 * @param {number} chars max number of characters (approximately)
 * @returns string
--- a/packages/core/euclid.mjs
+++ b/packages/core/euclid.mjs
@ -61,6 +61,7 @@ export const bjorklund = function (ons, steps) {
 *
 * @memberof Pattern
 * @name euclid
+ * @tags temporal
 * @param {number} pulses the number of onsets/beats
 * @param {number} steps the number of steps to fill
 * @returns Pattern
@ -73,6 +74,7 @@ export const bjorklund = function (ons, steps) {
 * Like `euclid`, but has an additional parameter for 'rotating' the resulting sequence.
 * @memberof Pattern
 * @name euclidRot
+ * @tags temporal
 * @param {number} pulses the number of onsets/beats
 * @param {number} steps the number of steps to fill
 * @param {number} rotation offset in steps
@ -156,6 +158,7 @@ export const { euclidrot, euclidRot } = register(['euclidrot', 'euclidRot'], fun
 * so there will be no gaps.
 * @name euclidLegato
 * @memberof Pattern
+ * @tags temporal
 * @param {number} pulses the number of onsets/beats
 * @param {number} steps the number of steps to fill
 * @param rotation offset in steps
@ -187,6 +190,7 @@ export const euclidLegato = register(['euclidLegato'], function (pulses, steps,
 * the resulting sequence
 * @name euclidLegatoRot
 * @memberof Pattern
+ * @tags temporal
 * @param {number} pulses the number of onsets/beats
 * @param {number} steps the number of steps to fill
 * @param {number} rotation offset in steps
@ -208,6 +212,7 @@ export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, s
 * @name euclidish
 * @synonyms eish
 * @memberof Pattern
+ * @tags temporal
 * @param {number} pulses the number of onsets
 * @param {number} steps the number of steps to fill
 * @param {number} groove exists between the extremes of 0 (straight euclidian) and 1 (straight pulse)
--- a/packages/core/impure.mjs
+++ b/packages/core/impure.mjs
@ -0,0 +1,90 @@
+/*
+stateful.mjs - File of shame for stateful, impure and otherwise illegal pattern methods
+Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/index.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/>.
+*/
+
+import { register, reify, Pattern } from './pattern.mjs';
+
+let timelines = {};
+
+export const reset_state = function () {
+  reset_timelines();
+};
+
+export const reset_timelines = function () {
+  timelines = {};
+};
+
+/***
+ * Allows you to switch a pattern between different 'timelines'. This is particularly useful when
+ * live coding, for example when you want to cue a pattern up to play from its start.
+ *
+ * Timelines are specified by number, so that if you had a pattern like
+ * `n("<0 1 2 3>").s("num").timeline(1)` playing, then changed the '1'
+ * to '2', it would always align '0' to the nearest cycle. You will likely want to trigger
+ * an evaluation a little bit before the cycle starts, to avoid missing events.
+ *
+ * After the first use, a timeline will continue with the same 'offset'. That is, if you change
+ * a pattern without changing its timeline number, it will stay on that timeline without resetting.
+ *
+ * Rather than incrementing a timeline to reset it, it's easier to negate it, e.g. by switching between `-2`
+ * and `2`. This is because when you negate a timeline it will always reset.
+ *
+ * You can also pattern the timeline if you want, to create strange resetting patterns.
+ * @param {number | Pattern} timeline The timeline that the pattern should play on.
+ * @example
+ * n("<0 1 2 3>(3,8)")
+ *   .sound("num")
+ *   // resets the timeline every two cycles, by negating the timeline.
+ *   // in a lot of cases this will be edited by a human live coder
+ *   // rather than patterned!
+ *   .timeline("<2 -2>".slow(2))
+ */
+
+export const timeline = register(
+  'timeline',
+  function (tpat, pat) {
+    tpat = reify(tpat);
+    const f = function (state) {
+      // Is this called from the scheduler? (rather than from e.g. the visualiser)
+      const scheduler = !!state.controls.cyclist;
+      const timehaps = tpat.query(state);
+      const result = [];
+      for (const timehap of timehaps) {
+        const tlid = timehap.value;
+        let offset;
+        if (tlid === 0) {
+          offset = 0;
+        } else if (tlid in timelines) {
+          offset = timelines[tlid];
+        } else {
+          const timearc = timehap.wholeOrPart();
+          if (!scheduler || state.span.begin.lt(timearc.midpoint())) {
+            offset = timearc.begin;
+          } else {
+            // Sync to end of timearc if we first see it over halfway into its
+            // timespan. Allows 'cuing up' next timeline when live coding.
+            offset = timearc.end;
+          }
+        }
+        if (scheduler) {
+          // update state
+          timelines[tlid] = offset;
+          if (tlid !== 0) {
+            delete timelines[-tlid];
+          }
+        }
+
+        const pathaps = pat
+          .late(offset)
+          .query(state.setSpan(timehap.part))
+          .map((h) => h.setContext(h.combineContext(timehap)));
+        result.push(...pathaps);
+      }
+      return result;
+    };
+    return new Pattern(f, pat._steps);
+  },
+  false,
+);
--- a/packages/core/index.mjs
+++ b/packages/core/index.mjs
@ -1,6 +1,6 @@
 /*
 index.mjs - <short description TODO>
-Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/index.mjs>
+Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/index.mjs>
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

@ -11,20 +11,21 @@ import createClock from './zyklus.mjs';
 import { logger } from './logger.mjs';
 export { Fraction, controls, createClock };
 export * from './controls.mjs';
-export * from './hap.mjs';
-export * from './pattern.mjs';
-export * from './signal.mjs';
-export * from './pick.mjs';
-export * from './state.mjs';
-export * from './timespan.mjs';
-export * from './util.mjs';
-export * from './speak.mjs';
-export * from './evaluate.mjs';
-export * from './repl.mjs';
 export * from './cyclist.mjs';
+export * from './evaluate.mjs';
+export * from './hap.mjs';
+export * from './impure.mjs';
 export * from './logger.mjs';
-export * from './time.mjs';
+export * from './pattern.mjs';
+export * from './pick.mjs';
+export * from './repl.mjs';
+export * from './signal.mjs';
+export * from './speak.mjs';
+export * from './state.mjs';
+export * from './schedulerState.mjs';
+export * from './timespan.mjs';
 export * from './ui.mjs';
+export * from './util.mjs';
 export { default as drawLine } from './drawLine.mjs';
 // below won't work with runtime.mjs (json import fails)
 /* import * as p from './package.json';
--- a/packages/core/package.json
+++ b/packages/core/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/core",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Port of Tidal Cycles to JavaScript",
  "main": "index.mjs",
  "type": "module",
--- a/packages/core/pattern.mjs
+++ b/packages/core/pattern.mjs
--- a/packages/core/pick.mjs
+++ b/packages/core/pick.mjs
@ -28,6 +28,7 @@ const _pick = function (lookup, pat, modulo = true) {

 /** * Picks patterns (or plain values) either from a list (by index) or a lookup table (by name).
 * Similar to `inhabit`, but maintains the structure of the original patterns.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -57,6 +58,7 @@ const __pick = register('pick', function (lookup, pat) {
 * it wraps around, rather than sticking at the maximum value.
 * For example, if you pick the fifth pattern of a list of three, you'll get the
 * second one.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -67,6 +69,7 @@ export const pickmod = register('pickmod', function (lookup, pat) {
 });

 /** * pickF lets you use a pattern of numbers to pick which function to apply to another pattern.
+ * @tags combiners, functional
 * @param {Pattern} pat
 * @param {Pattern} lookup a pattern of indices
 * @param {function[]} funcs the array of functions from which to pull
@ -75,7 +78,7 @@ export const pickmod = register('pickmod', function (lookup, pat) {
 * s("bd [rim hh]").pickF("<0 1 2>", [rev,jux(rev),fast(2)])
 * @example
 * note("<c2 d2>(3,8)").s("square")
- *     .pickF("<0 2> 1", [jux(rev),fast(2),x=>x.lpf(800)])
+ * .pickF("<0 2> 1", [jux(rev), fast(2), x=>x.lpf(800)])
 */
 export const pickF = register('pickF', function (lookup, funcs, pat) {
  return pat.apply(pick(lookup, funcs));
@ -83,6 +86,7 @@ export const pickF = register('pickF', function (lookup, funcs, pat) {

 /** * The same as `pickF`, but if you pick a number greater than the size of the functions list,
 * it wraps around, rather than sticking at the maximum value.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {Pattern} lookup a pattern of indices
 * @param {function[]} funcs the array of functions from which to pull
@ -93,6 +97,7 @@ export const pickmodF = register('pickmodF', function (lookup, funcs, pat) {
 });

 /** * Similar to `pick`, but it applies an outerJoin instead of an innerJoin.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -103,6 +108,7 @@ export const pickOut = register('pickOut', function (lookup, pat) {

 /** * The same as `pickOut`, but if you pick a number greater than the size of the list,
 * it wraps around, rather than sticking at the maximum value.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -112,6 +118,7 @@ export const pickmodOut = register('pickmodOut', function (lookup, pat) {
 });

 /** * Similar to `pick`, but the choosen pattern is restarted when its index is triggered.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -122,6 +129,7 @@ export const pickRestart = register('pickRestart', function (lookup, pat) {

 /** * The same as `pickRestart`, but if you pick a number greater than the size of the list,
   * it wraps around, rather than sticking at the maximum value.
+   * @tags combiners
   * @param {Pattern} pat
   * @param {*} xs
   * @returns {Pattern}
@ -138,6 +146,7 @@ export const pickmodRestart = register('pickmodRestart', function (lookup, pat)
 });

 /** * Similar to `pick`, but the choosen pattern is reset when its index is triggered.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -148,6 +157,7 @@ export const pickReset = register('pickReset', function (lookup, pat) {

 /** * The same as `pickReset`, but if you pick a number greater than the size of the list,
 * it wraps around, rather than sticking at the maximum value.
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -157,19 +167,22 @@ export const pickmodReset = register('pickmodReset', function (lookup, pat) {
 });

 /** 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
-   * @param {Pattern} pat
-   * @param {*} xs
-   * @returns {Pattern}
-   * @example
-   * "<a b [a,b]>".inhabit({a: s("bd(3,8)"),
-                            b: s("cp sd")
-                           })
-   * @example
-   * s("a@2 [a b] a".inhabit({a: "bd(3,8)", b: "sd sd"})).slow(4)
-   */
+ * Similar to `pick`, but cycles are squeezed into the target ('inhabited') pattern.
+ * @name inhabit
+ * @tags combiners
+ * @synonyms pickSqueeze
+ * @param {Pattern} pat
+ * @param {*} xs
+ * @returns {Pattern}
+ * @example
+ * let a = s("bd(3,8)")
+ * let b = s("cp sd")
+ * "<a b [a,b]>".inhabit({ a, b })
+ * @example
+ * s("a@2 [a b] a"
+ * .inhabit({a: "bd(3,8)", b: "sd sd"}))
+ * .slow(4)
+ */
 export const { inhabit, pickSqueeze } = register(['inhabit', 'pickSqueeze'], function (lookup, pat) {
  return _pick(lookup, pat, false).squeezeJoin();
 });
@ -180,6 +193,7 @@ export const { inhabit, pickSqueeze } = register(['inhabit', 'pickSqueeze'], fun
 * second one.
 * @name inhabitmod
 * @synonyms pickmodSqueeze
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -192,6 +206,7 @@ export const { inhabitmod, pickmodSqueeze } = register(['inhabitmod', 'pickmodSq
 /**
 * Pick from the list of values (or patterns of values) via the index using the given
 * pattern of integers. The selected pattern will be compressed to fit the duration of the selecting event
+ * @tags combiners
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
--- a/packages/core/repl.mjs
+++ b/packages/core/repl.mjs
@ -2,9 +2,16 @@ import { NeoCyclist } from './neocyclist.mjs';
 import { Cyclist } from './cyclist.mjs';
 import { evaluate as _evaluate } from './evaluate.mjs';
 import { errorLogger, logger } from './logger.mjs';
-import { setTime } from './time.mjs';
+import {
+  setCpsFunc,
+  setIsStarted,
+  setPattern as exposeSchedulerPattern,
+  setTime,
+  setTriggerFunc,
+} from './schedulerState.mjs';
 import { evalScope } from './evaluate.mjs';
 import { register, Pattern, isPattern, silence, stack } from './pattern.mjs';
+import { reset_state } from './impure.mjs';

 export function repl({
  defaultOutput,
@ -51,7 +58,11 @@ export function repl({
    getTime,
    onToggle: (started) => {
      updateState({ started });
+      setIsStarted(started);
      onToggle?.(started);
+      if (!started) {
+        reset_state();
+      }
    },
    setInterval,
    clearInterval,
@ -61,6 +72,8 @@ export function repl({
  // NeoCyclist uses a shared worker to communicate between instances, which is not supported on mobile chrome
  const scheduler =
    sync && typeof SharedWorker != 'undefined' ? new NeoCyclist(schedulerOptions) : new Cyclist(schedulerOptions);
+  setTriggerFunc(schedulerOptions.onTrigger);
+  setCpsFunc(() => scheduler.cps);
  let pPatterns = {};
  let anonymousIndex = 0;
  let allTransform;
@ -85,6 +98,7 @@ export function repl({
  const setPattern = async (pattern, autostart = true) => {
    pattern = editPattern?.(pattern) || pattern;
    await scheduler.setPattern(pattern, autostart);
+    exposeSchedulerPattern(pattern);
    return pattern;
  };
  setTime(() => scheduler.now()); // TODO: refactor?
@ -102,6 +116,7 @@ export function repl({
   * Changes the global tempo to the given cycles per minute
   *
   * @name setcpm
+   * @tags temporal
   * @alias setCpm
   * @param {number} cpm cycles per minute
   * @example
@ -115,7 +130,9 @@ export function repl({

  // TODO - not documented as jsdoc examples as the test framework doesn't simulate enough context for `each` and `all`..

-  /** Applies a function to all the running patterns. Note that the patterns are groups together into a single `stack` before the function is applied. This is probably what you want, but see `each` for
+  let allTransforms = [];
+  /**
+   * Applies a function to all the running patterns. Note that the patterns are groups together into a single `stack` before the function is applied. This is probably what you want, but see `each` for
   * a version that applies the function to each pattern separately.
   * ```
   * $: sound("bd - cp sd")
@ -127,18 +144,21 @@ export function repl({
   * $: sound("hh*8")
   * all(x => x.pianoroll())
   * ```
+   *
+   * @tags combiners
   */
-  let allTransforms = [];
  const all = function (transform) {
    allTransforms.push(transform);
    return silence;
  };
  /** Applies a function to each of the running patterns separately. This is intended for future use with upcoming 'stepwise' features. See `all` for a version that applies the function to all the patterns stacked together into a single pattern.
+   *
   * ```
   * $: sound("bd - cp sd")
   * $: sound("hh*8")
   * each(fast("<2 3>"))
   * ```
+   * @tags combiners
   */
  const each = function (transform) {
    eachTransform = transform;
--- a/packages/core/schedulerState.mjs
+++ b/packages/core/schedulerState.mjs
@ -0,0 +1,53 @@
+/*
+schedulerState.mjs - Module to pipe out various parameters from the scheduler for global consumption
+Copyright (C) 2026 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/schedulerState.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/>.
+*/
+
+let time;
+let cpsFunc;
+let pattern;
+let triggerFunc;
+let isStarted;
+export function getTime() {
+  if (!time) {
+    throw new Error('no time set! use setTime to define a time source');
+  }
+  return time();
+}
+
+export function setTime(func) {
+  time = func;
+}
+
+export function setCpsFunc(func) {
+  cpsFunc = func;
+}
+
+export function getCps() {
+  return cpsFunc?.();
+}
+
+export function setPattern(pat) {
+  pattern = pat;
+}
+
+export function getPattern() {
+  return pattern;
+}
+
+export function setTriggerFunc(func) {
+  triggerFunc = func;
+}
+
+export function getTriggerFunc() {
+  return triggerFunc;
+}
+
+export function setIsStarted(val) {
+  isStarted = !!val;
+}
+
+export function getIsStarted() {
+  return isStarted;
+}
--- a/packages/core/signal.mjs
+++ b/packages/core/signal.mjs
@ -16,7 +16,7 @@ export function steady(value) {
 }

 export const signal = (func) => {
-  const query = (state) => [new Hap(undefined, state.span, func(state.span.begin))];
+  const query = (state) => [new Hap(undefined, state.span, func(state.span.begin, state.controls))];
  return new Pattern(query);
 };

@ -24,6 +24,7 @@ export const signal = (func) => {
 *  A sawtooth signal between 0 and 1.
 *
 * @return {Pattern}
+ * @tags generators
 * @example
 * note("<c3 [eb3,g3] g2 [g3,bb3]>*8")
 * .clip(saw.slow(2))
@ -38,6 +39,7 @@ export const saw = signal((t) => t % 1);
 *  A sawtooth signal between -1 and 1 (like `saw`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const saw2 = saw.toBipolar();

@ -45,6 +47,7 @@ export const saw2 = saw.toBipolar();
 *  A sawtooth signal between 1 and 0 (like `saw`, but flipped).
 *
 * @return {Pattern}
+ * @tags generators
 * @example
 * note("<c3 [eb3,g3] g2 [g3,bb3]>*8")
 * .clip(isaw.slow(2))
@ -59,6 +62,7 @@ export const isaw = signal((t) => 1 - (t % 1));
 *  A sawtooth signal between 1 and -1 (like `saw2`, but flipped).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const isaw2 = isaw.toBipolar();

@ -66,12 +70,14 @@ export const isaw2 = isaw.toBipolar();
 *  A sine signal between -1 and 1 (like `sine`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));

 /**
 *  A sine signal between 0 and 1.
 * @return {Pattern}
+ * @tags generators
 * @example
 * n(sine.segment(16).range(0,15))
 * .scale("C:minor")
@ -83,6 +89,7 @@ export const sine = sine2.fromBipolar();
 *  A cosine signal between 0 and 1.
 *
 * @return {Pattern}
+ * @tags generators
 * @example
 * n(stack(sine,cosine).segment(16).range(0,15))
 * .scale("C:minor")
@ -94,12 +101,14 @@ export const cosine = sine._early(Fraction(1).div(4));
 *  A cosine signal between -1 and 1 (like `cosine`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const cosine2 = sine2._early(Fraction(1).div(4));

 /**
 *  A square signal between 0 and 1.
 * @return {Pattern}
+ * @tags generators
 * @example
 * n(square.segment(4).range(0,7)).scale("C:minor")
 *
@ -110,6 +119,7 @@ export const square = signal((t) => Math.floor((t * 2) % 2));
 *  A square signal between -1 and 1 (like `square`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const square2 = square.toBipolar();

@ -117,6 +127,7 @@ export const square2 = square.toBipolar();
 *  A triangle signal between 0 and 1.
 *
 * @return {Pattern}
+ * @tags generators
 * @example
 * n(tri.segment(8).range(0,7)).scale("C:minor")
 *
@ -127,6 +138,7 @@ export const tri = fastcat(saw, isaw);
 *  A triangle signal between -1 and 1 (like `tri`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const tri2 = fastcat(saw2, isaw2);

@ -134,6 +146,7 @@ export const tri2 = fastcat(saw2, isaw2);
 *  An inverted triangle signal between 1 and 0 (like `tri`, but flipped).
 *
 * @return {Pattern}
+ * @tags generators
 * @example
 * n(itri.segment(8).range(0,7)).scale("C:minor")
 *
@ -144,6 +157,7 @@ export const itri = fastcat(isaw, saw);
 *  An inverted triangle signal between -1 and 1 (like `itri`, but bipolar).
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const itri2 = fastcat(isaw2, saw2);

@ -151,6 +165,7 @@ export const itri2 = fastcat(isaw2, saw2);
 *  A signal representing the cycle time.
 *
 * @return {Pattern}
+ * @tags generators
 */
 export const time = signal(id);

@ -158,6 +173,7 @@ export const time = signal(id);
 *  The mouse's x position value ranges from 0 to 1.
 * @name mousex
 * @return {Pattern}
+ * @tags external_io
 * @example
 * n(mousex.segment(4).range(0,7)).scale("C:minor")
 *
@ -167,6 +183,7 @@ export const time = signal(id);
 *  The mouse's y position value ranges from 0 to 1.
 * @name mousey
 * @return {Pattern}
+ * @tags external_io
 * @example
 * n(mousey.segment(4).range(0,7)).scale("C:minor")
 *
@ -186,41 +203,102 @@ export const mouseY = signal(() => _mouseY);
 export const mousex = signal(() => _mouseX);
 export const mouseX = signal(() => _mouseX);

-// random signals
+// Random number generators

-const xorwise = (x) => {
+// Produce "Avalanche effect" where flipping a single bit of x
+// results in all output bits flipping with probability 0.5
+// See e.g. https://github.com/aappleby/smhasher/blob/0ff96f7835817a27d0487325b6c16033e2992eb5/src/MurmurHash3.cpp#L68-L77
+const _murmurHashFinalizer = (x) => {
+  x |= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 0x85ebca6b);
+  x ^= x >>> 13;
+  x = Math.imul(x, 0xc2b2ae35);
+  x ^= x >>> 16;
+  return x >>> 0; // unsigned
+};
+
+// Convert t to a 32 bit integer, preserving temporal resolution down to 1/2^29
+const _tToT = (t) => {
+  return Math.floor(t * 536870912);
+};
+
+// Used to decorrelate nearby T, i, and seed prior to hashing
+const _decorrelate = (T, i = 0, seed = 0) => {
+  const lowBits = (T >>> 0) >>> 0;
+  const highBits = Math.floor(T / 4294967296) >>> 0; // 2^32
+  let key = lowBits ^ Math.imul(highBits ^ 0x85ebca6b, 0xc2b2ae35);
+  key ^= Math.imul(i ^ 0x7f4a7c15, 0x9e3779b9);
+  key ^= Math.imul(seed ^ 0x165667b1, 0x27d4eb2d);
+  return key >>> 0;
+};
+
+const randAt = (T, i = 0, seed = 0) => {
+  return _murmurHashFinalizer(_decorrelate(T, i, seed)) / 4294967296; // 2^32
+};
+
+// n samples at time t
+const timeToRands = (t, n, seed = 0) => {
+  const T = _tToT(t);
+  if (n === 1) {
+    return randAt(T, 0, seed);
+  }
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = randAt(T, i, seed);
+  return out;
+};
+
+// Old random signals. Currently the default, but can also be chosen via
+// `useRNG('legacy')`
+
+// stretch 300 cycles over the range of [0,2**29 == 536870912) then apply the xorshift algorithm
+const __xorwise = (x) => {
  const a = (x << 13) ^ x;
  const b = (a >> 17) ^ a;
  return (b << 5) ^ b;
 };
-
-// stretch 300 cycles over the range of [0,2**29 == 536870912) then apply the xorshift algorithm
-const _frac = (x) => x - Math.trunc(x);
-
-const timeToIntSeed = (x) => xorwise(Math.trunc(_frac(x / 300) * 536870912));
-
-const intSeedToRand = (x) => (x % 536870912) / 536870912;
-
-const timeToRand = (x) => Math.abs(intSeedToRand(timeToIntSeed(x)));
-
-const timeToRandsPrime = (seed, n) => {
+const __frac = (x) => x - Math.trunc(x);
+const __timeToIntSeed = (x) => __xorwise(Math.trunc(__frac(x / 300) * 536870912));
+const __intSeedToRand = (x) => (x % 536870912) / 536870912;
+const __timeToRandsPrime = (seed, n) => {
+  if (n === 1) {
+    return Math.abs(__intSeedToRand(seed));
+  }
  const result = [];
-  // eslint-disable-next-line
-  for (let i = 0; i < n; ++i) {
-    result.push(intSeedToRand(seed));
-    seed = xorwise(seed);
+  for (let i = 0; i < n; i++) {
+    result.push(__intSeedToRand(seed));
+    seed = __xorwise(seed);
  }
  return result;
 };
+const __timeToRands = (t, n) => __timeToRandsPrime(__timeToIntSeed(t), n);

-const timeToRands = (t, n) => timeToRandsPrime(timeToIntSeed(t), n);
+// End old random
+
+let RNG_MODE = 'legacy';
+export const getRandsAtTime = (t, n = 1, seed = 0) => {
+  return RNG_MODE === 'legacy' ? __timeToRands(t + seed, n) : timeToRands(t, n, seed);
+};

 /**
+ * Sets which random number generator to use. Historically Strudel would
+ * use `useRNG('legacy')`, which remains the default. To use a new more statistically
+ * precise RNG, try `useRNG('precise')`.
 *
+ * @name useRNG
+ * @tags generators, math
+ * @param {string} mod - Mode. One of 'legacy', 'precise'
+ * @example
+ * useRNG('legacy')
+ * // Repeats every 300 cycles
+ * $: n(irand(50)).seg(16).scale("C:minor").ribbon(88, 32)
+ * $: n(irand(50)).seg(16).scale("C:minor").ribbon(388, 32)
 */
+export const useRNG = (mode = 'legacy') => (RNG_MODE = mode);

 /**
 * A discrete pattern of numbers from 0 to n-1
+ * @tags generators
 * @example
 * n(run(4)).scale("C4:pentatonic")
 * // n("0 1 2 3").scale("C4:pentatonic")
@ -231,6 +309,7 @@ export const run = (n) => saw.range(0, n).round().segment(n);
 * Creates a binary pattern from a number.
 *
 * @name binary
+ * @tags generators
 * @param {number} n - input number to convert to binary
 * @example
 * "hh".s().struct(binary(5))
@ -245,6 +324,7 @@ export const binary = (n) => {
 * Creates a binary pattern from a number, padded to n bits long.
 *
 * @name binaryN
+ * @tags generators
 * @param {number} n - input number to convert to binary
 * @param {number} nBits - pattern length, defaults to 16
 * @example
@ -262,6 +342,7 @@ export const binaryN = (n, nBits = 16) => {
 * Creates a binary list pattern from a number.
 *
 * @name binaryL
+ * @tags generators
 * @param {number} n - input number to convert to binary
 * s("saw").seg(8)
 *   .partials(binaryL(irand(4096).add(1)))
@ -275,6 +356,7 @@ export const binaryL = (n) => {
 * Creates a binary list pattern from a number, padded to n bits long.
 *
 * @name binaryNL
+ * @tags generators
 * @param {number} n - input number to convert to binary
 * @param {number} nBits - pattern length, defaults to 16
 */
@ -294,19 +376,20 @@ export const binaryNL = (n, nBits = 16) => {
 * Creates a list of random numbers of the given length
 *
 * @name randL
+ * @tags generators
 * @param {number} n Number of random numbers to sample
 * @example
 * s("saw").seg(16).n(irand(12)).scale("F1:minor")
 *   .partials(randL(8))
 */
 export const randL = (n) => {
-  return signal((t) => (nVal) => timeToRands(t, nVal).map(Math.abs)).appLeft(reify(n));
+  return signal((t) => (nVal) => getRandsAtTime(t, nVal).map(Math.abs)).appLeft(reify(n));
 };

 export const randrun = (n) => {
-  return signal((t) => {
+  return signal((t, controls) => {
    // Without adding 0.5, the first cycle is always 0,1,2,3,...
-    const rands = timeToRands(t.floor().add(0.5), n);
+    const rands = getRandsAtTime(t.floor().add(0.5), n, controls.randSeed);
    const nums = rands
      .map((n, i) => [n, i])
      .sort((a, b) => (a[0] > b[0]) - (a[0] < b[0]))
@ -325,6 +408,7 @@ const _rearrangeWith = (ipat, n, pat) => {
 * 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
+ * @tags temporal
 * @example
 * note("c d e f").sound("piano").shuffle(4)
 * @example
@ -338,6 +422,7 @@ export const shuffle = register('shuffle', (n, pat) => {
 * 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
+ * @tags temporal
 * @example
 * note("c d e f").sound("piano").scramble(4)
 * @example
@ -347,18 +432,53 @@ export const scramble = register('scramble', (n, pat) => {
  return _rearrangeWith(_irand(n)._segment(n), n, pat);
 });

+/**
+ * Modify a pattern by applying a function to the `randomSeed` control if present
+ *
+ * @tags math
+ * @param {Function} func Function from seed (or undefined) to seed (or undefined)
+ * @param {Pattern} pat Pattern to update
+ * @returns Pattern
+ */
+export const withSeed = (func, pat) => {
+  return new Pattern((state) => {
+    let { randSeed, ...controls } = state.controls;
+    randSeed = func(randSeed);
+    return pat.query(state.setControls({ ...controls, randSeed }));
+  }, pat._steps);
+};
+
+/**
+ * Change the seed for random signals. Normally, random signals depend on time,
+ * so two patterns at the same time will have the same random values. Specifying
+ * a new seed changes the signal output by `rand`. This also affects other functions
+ * that use randomness, like `shuffle` and `sometimes`.
+ *
+ * @name seed
+ * @tags math
+ * @param {number} n A new seed. Can be any number.
+ * @example
+ * $: s("hh*4").degrade();
+ * $: s("bd*4").degrade().seed(1); // Will degrade different events from the hi-hat
+ */
+export const seed = register('seed', (n, pat) => {
+  return withSeed(() => n, pat);
+});
+
 /**
 * A continuous pattern of random numbers, between 0 and 1.
 *
 * @name rand
+ * @tags generators
 * @example
 * // randomly change the cutoff
 * s("bd*4,hh*8").cutoff(rand.range(500,8000))
 *
 */
-export const rand = signal(timeToRand);
+export const rand = signal((t, controls) => getRandsAtTime(t, 1, controls.randSeed));
 /**
 * A continuous pattern of random numbers, between -1 and 1
+ * @tags generators
 */
 export const rand2 = rand.toBipolar();

@ -368,6 +488,7 @@ export const _brandBy = (p) => rand.fmap((x) => x < p);
 * A continuous pattern of 0 or 1 (binary random), with a probability for the value being 1
 *
 * @name brandBy
+ * @tags generators
 * @param {number} probability - a number between 0 and 1
 * @example
 * s("hh*10").pan(brandBy(0.2))
@ -378,6 +499,7 @@ export const brandBy = (pPat) => reify(pPat).fmap(_brandBy).innerJoin();
 * A continuous pattern of 0 or 1 (binary random)
 *
 * @name brand
+ * @tags generators
 * @example
 * s("hh*10").pan(brand)
 */
@ -389,6 +511,7 @@ export const _irand = (i) => rand.fmap((x) => Math.trunc(x * i));
 * A continuous pattern of random integers, between 0 and n-1.
 *
 * @name irand
+ * @tags generators
 * @param {number} n max value (exclusive)
 * @example
 * // randomly select scale notes from 0 - 7 (= C to C)
@ -411,6 +534,7 @@ export const __chooseWith = (pat, xs) => {
 /**
 * Choose from the list of values (or patterns of values) using the given
 * pattern of numbers, which should be in the range of 0..1
+ * @tags temporal
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -424,6 +548,7 @@ export const chooseWith = (pat, xs) => {
 /**
 * As with {chooseWith}, but the structure comes from the chosen values, rather
 * than the pattern you're using to choose with.
+ * @tags temporal
 * @param {Pattern} pat
 * @param {*} xs
 * @returns {Pattern}
@ -434,6 +559,7 @@ export const chooseInWith = (pat, xs) => {

 /**
 * Chooses randomly from the given list of elements.
+ * @tags temporal
 * @param  {...any} xs values / patterns to choose from.
 * @returns {Pattern} - a continuous pattern.
 * @example
@ -449,6 +575,7 @@ export const chooseOut = choose;
 * Chooses from the given list of values (or patterns of values), according
 * to the pattern that the method is called on. The pattern should be in
 * the range 0 .. 1.
+ * @tags temporal
 * @param  {...any} xs
 * @returns {Pattern}
 */
@ -459,6 +586,7 @@ Pattern.prototype.choose = function (...xs) {
 /**
 * As with choose, but the pattern that this method is called on should be
 * in the range -1 .. 1
+ * @tags temporal
 * @param  {...any} xs
 * @returns {Pattern}
 */
@ -468,6 +596,7 @@ Pattern.prototype.choose2 = function (...xs) {

 /**
 * Picks one of the elements at random each cycle.
+ * @tags temporal
 * @synonyms randcat
 * @returns {Pattern}
 * @example
@ -510,6 +639,7 @@ const wchooseWith = (...args) => _wchooseWith(...args).outerJoin();

 /**
 * Chooses randomly from the given list of elements by giving a probability to each element
+ * @tags temporal
 * @param {...any} pairs arrays of value and weight
 * @returns {Pattern} - a continuous pattern.
 * @example
@ -519,6 +649,7 @@ export const wchoose = (...pairs) => wchooseWith(rand, ...pairs);

 /**
 * Picks one of the elements at random each cycle by giving a probability to each element
+ * @tags temporal
 * @synonyms wrandcat
 * @returns {Pattern}
 * @example
@ -533,58 +664,56 @@ export const wchooseCycles = (...pairs) => _wchooseWith(rand.segment(1), ...pair

 export const wrandcat = wchooseCycles;

-function _perlin(t) {
+function _perlin(t, seed = 0) {
  let ta = Math.floor(t);
  let tb = ta + 1;
  const smootherStep = (x) => 6.0 * x ** 5 - 15.0 * x ** 4 + 10.0 * x ** 3;
  const interp = (x) => (a) => (b) => a + smootherStep(x) * (b - a);
-  const v = interp(t - ta)(timeToRand(ta))(timeToRand(tb));
+  const ra = getRandsAtTime(ta, 1, seed);
+  const rb = getRandsAtTime(tb, 1, seed);
+  const v = interp(t - ta)(ra)(rb);
  return v;
 }
-export const perlinWith = (tpat) => {
-  return tpat.fmap(_perlin);
-};

-function _berlin(t) {
+function _berlin(t, seed = 0) {
  const prevRidgeStartIndex = Math.floor(t);
  const nextRidgeStartIndex = prevRidgeStartIndex + 1;

-  const prevRidgeBottomPoint = timeToRand(prevRidgeStartIndex);
-  const nextRidgeTopPoint = timeToRand(nextRidgeStartIndex) + prevRidgeBottomPoint;
+  const prevRidgeBottomPoint = getRandsAtTime(prevRidgeStartIndex, 1, seed);
+  const height = getRandsAtTime(nextRidgeStartIndex, 1, seed);
+  const nextRidgeTopPoint = prevRidgeBottomPoint + height;

  const currentPercent = (t - prevRidgeStartIndex) / (nextRidgeStartIndex - prevRidgeStartIndex);
  const interp = (a, b, t) => {
-    return a + (b - a) * t;
+    return a + t * (b - a);
  };
  return interp(prevRidgeBottomPoint, nextRidgeTopPoint, currentPercent) / 2;
 }

-export const berlinWith = (tpat) => {
-  return tpat.fmap(_berlin);
-};
-
 /**
 * Generates a continuous pattern of [perlin noise](https://en.wikipedia.org/wiki/Perlin_noise), in the range 0..1.
 *
+ * @tags generators
 * @name perlin
 * @example
 * // randomly change the cutoff
 * s("bd*4,hh*8").cutoff(perlin.range(500,8000))
 *
 */
-export const perlin = perlinWith(time.fmap((v) => Number(v)));
+export const perlin = signal((t, controls) => _perlin(t, controls.randSeed));

 /**
 * Generates a continuous pattern of [berlin noise](conceived by Jame Coyne and Jade Rowland as a joke but turned out to be surprisingly cool and useful,
 * like perlin noise but with sawtooth waves), in the range 0..1.
 *
+ * @tags generators
 * @name berlin
 * @example
 * // ascending arpeggios
 * n("0!16".add(berlin.fast(4).mul(14))).scale("d:minor")
 *
 */
-export const berlin = berlinWith(time.fmap((v) => Number(v)));
+export const berlin = signal((t, controls) => _berlin(t, controls.randSeed));

 export const degradeByWith = register(
  'degradeByWith',
@ -598,6 +727,7 @@ export const degradeByWith = register(
 * 0 = 0% chance of removal
 * 1 = 100% chance of removal
 *
+ * @tags temporal
 * @name degradeBy
 * @memberof Pattern
 * @param {number} amount - a number between 0 and 1
@ -623,6 +753,7 @@ export const degradeBy = register(
 *
 * Randomly removes 50% of events from the pattern. Shorthand for `.degradeBy(0.5)`
 *
+ * @tags temporal
 * @name degrade
 * @memberof Pattern
 * @returns Pattern
@ -639,6 +770,7 @@ export const degrade = register('degrade', (pat) => pat._degradeBy(0.5), true, t
 * 1 = 0% chance of removal
 * Events that would be removed by degradeBy are let through by undegradeBy and vice versa (see second example).
 *
+ * @tags temporal
 * @name undegradeBy
 * @memberof Pattern
 * @param {number} amount - a number between 0 and 1
@ -667,6 +799,7 @@ export const undegradeBy = register(
 * Inverse of `degrade`: Randomly removes 50% of events from the pattern. Shorthand for `.undegradeBy(0.5)`
 * Events that would be removed by degrade are let through by undegrade and vice versa (see second example).
 *
+ * @tags temporal
 * @name undegrade
 * @memberof Pattern
 * @returns Pattern
@ -685,6 +818,7 @@ export const undegrade = register('undegrade', (pat) => pat._undegradeBy(0.5), t
 * Randomly applies the given function by the given probability.
 * Similar to `someCyclesBy`
 *
+ * @tags temporal
 * @name sometimesBy
 * @memberof Pattern
 * @param {number | Pattern} probability - a number between 0 and 1
@ -704,6 +838,7 @@ export const sometimesBy = register('sometimesBy', function (patx, func, pat) {
 *
 * Applies the given function with a 50% chance
 *
+ * @tags temporal
 * @name sometimes
 * @memberof Pattern
 * @param {function} function - the transformation to apply
@ -725,6 +860,7 @@ export const sometimes = register('sometimes', function (func, pat) {
 * @param {number | Pattern} probability - a number between 0 and 1
 * @param {function} function - the transformation to apply
 * @returns Pattern
+ * @tags temporal
 * @example
 * s("bd,hh*8").someCyclesBy(.3, x=>x.speed("0.5"))
 */
@ -747,6 +883,7 @@ export const someCyclesBy = register('someCyclesBy', function (patx, func, pat)
 * @name someCycles
 * @memberof Pattern
 * @returns Pattern
+ * @tags temporal
 * @example
 * s("bd,hh*8").someCycles(x=>x.speed("0.5"))
 */
@ -761,6 +898,7 @@ export const someCycles = register('someCycles', function (func, pat) {
 * @name often
 * @memberof Pattern
 * @returns Pattern
+ * @tags temporal
 * @example
 * s("hh*8").often(x=>x.speed("0.5"))
 */
@ -775,6 +913,7 @@ export const often = register('often', function (func, pat) {
 * @name rarely
 * @memberof Pattern
 * @returns Pattern
+ * @tags temporal
 * @example
 * s("hh*8").rarely(x=>x.speed("0.5"))
 */
@ -786,6 +925,7 @@ export const rarely = register('rarely', function (func, pat) {
 *
 * Shorthand for `.sometimesBy(0.1, fn)`
 *
+ * @tags temporal
 * @name almostNever
 * @memberof Pattern
 * @returns Pattern
@ -800,6 +940,7 @@ export const almostNever = register('almostNever', function (func, pat) {
 *
 * Shorthand for `.sometimesBy(0.9, fn)`
 *
+ * @tags temporal
 * @name almostAlways
 * @memberof Pattern
 * @returns Pattern
@ -814,6 +955,7 @@ export const almostAlways = register('almostAlways', function (func, pat) {
 *
 * Shorthand for `.sometimesBy(0, fn)` (never calls fn)
 *
+ * @tags temporal
 * @name never
 * @memberof Pattern
 * @returns Pattern
@ -828,6 +970,7 @@ export const never = register('never', function (_, pat) {
 *
 * Shorthand for `.sometimesBy(1, fn)` (always calls fn)
 *
+ * @tags temporal
 * @name always
 * @memberof Pattern
 * @returns Pattern
@ -856,6 +999,7 @@ export function _keyDown(keyname) {
 * Do something on a keypress, or array of keypresses
 * [Key name reference](https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values)
 *
+ * @tags external_io
 * @name whenKey
 * @memberof Pattern
 * @returns Pattern
@ -872,6 +1016,7 @@ export const whenKey = register('whenKey', function (input, func, pat) {
 * returns true when a key or array of keys is held
 * [Key name reference](https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values)
 *
+ * @tags external_io
 * @name keyDown
 * @memberof Pattern
 * @returns Pattern
@ -882,3 +1027,54 @@ export const whenKey = register('whenKey', function (input, func, pat) {
 export const keyDown = register('keyDown', function (pat) {
  return pat.fmap(_keyDown);
 });
+
+/**
+ * A pattern measuring the duration of events,
+ * in cycles per event. `cyclesPer` doesn't have structure itself, but takes structure, and therefore
+ * event durations, from the pattern that it is combined with.
+ * For example `cyclesPer.struct("1 1 [1 1] 1")` would give the same as `"0.25 0.25 [0.125 0.125] 0.25"`.
+ * See also its reciprocal, `per`, also known as `perCycle`.
+ *
+ * @tags temporal
+ * @example
+ * // Shorter events are lower in pitch
+ * sound("saw saw [saw saw] saw")
+ *   .note(cyclesPer.range(50, 100))
+ * @example
+ * sound("bd sd [bd bd] sd*4 [- sd] [bd [bd bd]]")
+ *   .note(cyclesPer.add(20))
+ */
+export const cyclesPer = new Pattern(function (state) {
+  return [new Hap(undefined, state.span, state.span.duration)];
+});
+
+/**
+ * A pattern measuring the 'shortness' of events, or in other words, the duration of pattern events,
+ * in events per cycle. `per` doesn't have structure itself, but takes structure, and therefore
+ * event durations, from the pattern that it is combined with.
+ * For example `per.struct("1 1 [1 1] 1")` would give the same as `"4 4 [8 8] 4"`.
+ * See also its reciprocal, `cyclesPer`.
+ * @tags temporal
+ * @synonyms perCycle
+ * @example
+ * // Shorter events are more distorted
+ * n("0 0*2 0 0*2 0 [0 0 0]@2").sound("bd")
+ *  .distort(per.div(2))
+ */
+export const per = new Pattern(function (state) {
+  return [new Hap(undefined, state.span, Fraction(1).div(state.span.duration))];
+});
+
+export const perCycle = per;
+
+/**
+ * Like `per` but measures the shortness of events according to an exponential curve. In
+ * particular, where the event duration halves, the
+ * returned value increases by one. `perx.struct("1 1 [1 [1 1]] 1")` would therefore be
+ * the same as `"3 3 [4 [5 5]] 3"`.
+ * @tags temporal
+ */
+export const perx = new Pattern(function (state) {
+  const n = Fraction(1).div(state.span.duration);
+  return [new Hap(undefined, state.span, Math.log(n) / Math.log(2) + 1)];
+});
--- a/packages/core/test/pattern.test.mjs
+++ b/packages/core/test/pattern.test.mjs
@ -740,20 +740,6 @@ describe('Pattern', () => {
      );
    });
  });
-  describe('signal()', () => {
-    it('Can make saw/saw2', () => {
-      expect(saw.struct(true, true, true, true).firstCycle()).toStrictEqual(
-        sequence(0, 1 / 4, 1 / 2, 3 / 4).firstCycle(),
-      );
-
-      expect(saw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, -0.5, 0, 0.5).firstCycle());
-    });
-    it('Can make isaw/isaw2', () => {
-      expect(isaw.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.75, 0.5, 0.25).firstCycle());
-
-      expect(isaw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.5, 0, -0.5).firstCycle());
-    });
-  });
  describe('_setContext()', () => {
    it('Can set the hap context', () => {
      expect(
--- a/packages/core/test/signal.test.mjs
+++ b/packages/core/test/signal.test.mjs
@ -0,0 +1,61 @@
+/*
+signal.test.mjs - <short description TODO>
+Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/core/test/pattern.test.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/>.
+*/
+
+import Fraction from 'fraction.js';
+
+import { describe, it, expect, vi } from 'vitest';
+
+import { saw, saw2, isaw, isaw2, per, perx, cyclesPer } from '../signal.mjs';
+import { fastcat, sequence, State, TimeSpan, Hap } from '../index.mjs';
+
+const st = (begin, end) => new State(ts(begin, end));
+const ts = (begin, end) => new TimeSpan(Fraction(begin), Fraction(end));
+const hap = (whole, part, value, context = {}) => new Hap(whole, part, value, context);
+
+const third = Fraction(1, 3);
+const twothirds = Fraction(2, 3);
+
+const sameFirst = (a, b) => {
+  return expect(a.sortHapsByPart().firstCycle()).toStrictEqual(b.sortHapsByPart().firstCycle());
+};
+
+describe('signal()', () => {
+  it('Can make saw/saw2', () => {
+    expect(saw.struct(true, true, true, true).firstCycle()).toStrictEqual(
+      sequence(0, 1 / 4, 1 / 2, 3 / 4).firstCycle(),
+    );
+
+    expect(saw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, -0.5, 0, 0.5).firstCycle());
+  });
+  it('Can make isaw/isaw2', () => {
+    expect(isaw.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.75, 0.5, 0.25).firstCycle());
+
+    expect(isaw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.5, 0, -0.5).firstCycle());
+  });
+});
+
+describe('cyclesPer', () => {
+  it('gives cycles per hap', () => {
+    sameFirst(
+      cyclesPer.struct(true, true, true, fastcat(true, true)),
+      sequence(0.25, 0.25, 0.25, fastcat(0.125, 0.125)).fmap(Fraction),
+    );
+  });
+});
+describe('per', () => {
+  it('gives haps per cycle', () => {
+    sameFirst(per.struct(true, true, true, fastcat(true, true)), sequence(4, 4, 4, fastcat(8, 8)).fmap(Fraction));
+  });
+});
+
+describe('perx', () => {
+  it('gives exponential haps per cycle', () => {
+    sameFirst(
+      perx.struct(true, true, true, fastcat(true, fastcat(true, true))),
+      sequence(3, 3, 3, fastcat(4, fastcat(5, 5))),
+    );
+  });
+});
--- a/packages/core/time.mjs
+++ b/packages/core/time.mjs
@ -1,11 +0,0 @@
-let time;
-export function getTime() {
-  if (!time) {
-    throw new Error('no time set! use setTime to define a time source');
-  }
-  return time();
-}
-
-export function setTime(func) {
-  time = func;
-}
--- a/packages/csound/index.mjs
+++ b/packages/csound/index.mjs
@ -135,6 +135,8 @@ export async function loadOrc(url) {
 *  p4 -- MIDI key number (as a real number, not an integer but in [0, 127].
 *  p5 -- MIDI velocity (as a real number, not an integer but in [0, 127].
 *  p6 -- Strudel controls, as a string.
+ *
+ * @tags external_io
 */
 export const csoundm = register('csoundm', (instrument, pat) => {
  let p1 = instrument;
--- a/packages/csound/package.json
+++ b/packages/csound/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/csound",
-  "version": "1.2.6",
+  "version": "1.3.0",
  "description": "csound bindings for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/draw/package.json
+++ b/packages/draw/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/draw",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Helpers for drawing with Strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/draw/pianoroll.mjs
+++ b/packages/draw/pianoroll.mjs
@ -42,6 +42,7 @@ const getValue = (e) => {
 *
 * @name pianoroll
 * @synonyms punchcard
+ * @tags visualization
 * @param {Object} options Object containing all the optional following parameters as key value pairs:
 * @param {integer} cycles number of cycles to be displayed at the same time - defaults to 4
 * @param {number} playhead location of the active notes on the time axis - 0 to 1, defaults to 0.5
@ -299,6 +300,7 @@ Pattern.prototype.punchcard = function (options) {
 * Supports all the same options as pianoroll.
 *
 * @name wordfall
+ * @tags visualization
 */
 Pattern.prototype.wordfall = function (options) {
  return this.punchcard({ vertical: 1, labels: 1, stroke: 0, fillActive: 1, active: 'white', ...options });
--- a/packages/draw/pitchwheel.mjs
+++ b/packages/draw/pitchwheel.mjs
@ -116,6 +116,7 @@ export function pitchwheel({
 /**
 * Renders a pitch circle to visualize frequencies within one octave
 * @name pitchwheel
+ * @tags visualization
 * @param {number} hapcircles
 * @param {number} circle
 * @param {number} edo
--- a/packages/draw/spiral.mjs
+++ b/packages/draw/spiral.mjs
@ -129,6 +129,7 @@ function drawSpiral(options) {
 * Displays a spiral visual.
 *
 * @name spiral
+ * @tags visualization
 * @param {Object} options Object containing all the optional following parameters as key value pairs:
 * @param {number} stretch controls the rotations per cycle ratio, where 1 = 1 cycle / 360 degrees
 * @param {number} size the diameter of the spiral
--- a/packages/embed/package.json
+++ b/packages/embed/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/embed",
-  "version": "1.1.1",
+  "version": "1.1.2",
  "description": "Embeddable Web Component to load a Strudel REPL into an iframe",
  "main": "embed.js",
  "type": "module",
--- a/packages/gamepad/package.json
+++ b/packages/gamepad/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/gamepad",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Gamepad Inputs for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/hydra/package.json
+++ b/packages/hydra/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/hydra",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Hydra integration for strudel",
  "main": "hydra.mjs",
  "type": "module",
--- a/packages/midi/midi.mjs
+++ b/packages/midi/midi.mjs
@ -5,9 +5,23 @@ This program is free software: you can redistribute it and/or modify it under th
 */

 import * as _WebMidi from 'webmidi';
-import { Pattern, isPattern, logger, ref } from '@strudel/core';
+import {
+  Hap,
+  Pattern,
+  TimeSpan,
+  getCps,
+  getIsStarted,
+  getPattern,
+  getTime,
+  getTriggerFunc,
+  isPattern,
+  logger,
+  ref,
+  reify,
+} from '@strudel/core';
 import { noteToMidi, getControlName } from '@strudel/core';
 import { Note } from 'webmidi';
+import { getAudioContext } from '@strudel/webaudio';
 import { scheduleAtTime } from '../superdough/helpers.mjs';

 // if you use WebMidi from outside of this package, make sure to import that instance:
@ -124,6 +138,7 @@ function githubPath(base, subpath = '') {

 /**
 * configures the default midimap, which is used when no "midimap" port is set
+ * @tags external_io, midi
 * @example
 * defaultmidimap({ lpf: 74 })
 * $: note("c a f e").midi();
@ -137,6 +152,7 @@ let loadCache = {};

 /**
 * Adds midimaps to the registry. Inside each midimap, control names (e.g. lpf) are mapped to cc numbers.
+ * @tags external_io, midi
 * @example
 * midimaps({ mymap: { lpf: 74 } })
 * $: note("c a f e")
@ -291,6 +307,7 @@ function sendNote(note, velocity, duration, device, midichan, targetTime) {

 /**
 * MIDI output: Opens a MIDI output port.
+ * @tags external_io
 * @param {string | number} midiport MIDI device name or index defaulting to 0
 * @param {object} options Additional MIDI configuration options
 * @example
@ -477,21 +494,13 @@ Pattern.prototype.midi = function (midiport, options = {}) {
  });
 };

-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")
+ * Initialize a midi device
 */
-export async function midin(input) {
+async function _initialize(input) {
  if (isPattern(input)) {
    throw new Error(
-      `midin: does not accept Pattern as input. Make sure to pass device name with single quotes. Example: midin('${
+      `[midi] Midi input cannot be a pattern. Make sure to pass device name with single quotes. Example: midin('${
        WebMidi.outputs?.[0]?.name || 'IAC Driver Bus 1'
      }')`,
    );
@ -500,29 +509,193 @@ export async function midin(input) {
  const device = getDevice(input, WebMidi.inputs);
  if (!device) {
    throw new Error(
-      `midiin: device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
+      `[midi] Midi device "${input}" not found.. connected devices: ${getMidiDeviceNamesString(WebMidi.inputs)}`,
    );
  }
  if (initial) {
    const otherInputs = WebMidi.inputs.filter((o) => o.name !== device.name);
    logger(
-      `Midi enabled! Using "${device.name}". ${
+      `[midi] Midi enabled! Using "${device.name}". ${
        otherInputs?.length ? `Also available: ${getMidiDeviceNamesString(otherInputs)}` : ''
      }`,
    );
  }
-  // ensure refs for this input are initialized
-  if (!refs[input]) {
-    refs[input] = {};
-  }
-  const cc = (cc) => ref(() => refs[input][cc] || 0);
+  return device;
+}
+
+/**
+ * MIDI input: Opens a MIDI input port to receive MIDI control change messages.
+ *
+ * The output is a function that accepts a midi cc value to query as well as (optionally) a midi channel
+ *
+ * @name midin
+ * @tags external_io, midi
+ * @param {string | number} input MIDI device name or index defaulting to 0
+ * @returns {function(number, number=): Pattern} A function from (cc, channel?) to a pattern.
+ *   When queried, the pattern will produces the most recently received midi value (normalized to 0 to 1)
+ *   that came through that cc number (and channel, if provided)
+ * @example
+ * const cc = await midin('IAC Driver Bus 1')
+ * note("c a f e").lpf(cc(0).range(0, 1000)).lpq(cc(1).range(0, 10)).sound("sawtooth")
+ * @example
+ * const allCC = await midin('IAC Driver Bus 1')
+ * const cc = (ccNum) => allCC(ccNum, 2) // just channel 2
+ * note("c a f e").s("saw")
+ *   .when(cc(0).gt(0), x => x.postgain(0))
+ */
+let listeners = {};
+const refs = {};
+const refsByChan = {};
+export async function midin(input) {
+  const device = await _initialize(input);
+  refs[input] ??= {};
+  refsByChan[input] ??= {};
+  const cc = (cc, chan) => {
+    if (chan !== undefined) {
+      return ref(() => refsByChan[input][cc]?.[chan] || 0);
+    }
+    return ref(() => refs[input][cc] || 0);
+  };

  listeners[input] && device.removeListener('midimessage', listeners[input]);
  listeners[input] = (e) => {
-    const cc = e.dataBytes[0];
-    const v = e.dataBytes[1];
-    refs[input] && (refs[input][cc] = v / 127);
+    const [ccNum, v] = e.dataBytes;
+    const chan = e.message.channel;
+    const scaled = v / 127;
+    refsByChan[input][ccNum] ??= {};
+    refsByChan[input][ccNum][chan] = scaled;
+    refs[input][ccNum] = scaled;
  };
  device.addListener('midimessage', listeners[input]);
  return cc;
 }
+
+/**
+ * MIDI keyboard: Opens a MIDI input port to receive MIDI keyboard messages.
+ *
+ * The note length is fixed as Superdough is not currently set up for undetermined
+ * note durations
+ *
+ * @name midikeys
+ * @tags external_io, midi
+ * @param {string | number} input MIDI device name or index defaulting to 0
+ * @returns {function((number | Pattern)=): Pattern} A function that produces a pattern.
+ *   When queried, the pattern will produces the most recently played midi notes and velocities,
+ *   lasting for the specified duration
+ * @example
+ * const kb = await midikeys('Arturia KeyStep 32')
+ * kb().s("tri").lpf(80).lpe(6).lpd(0.1).room(2).delay(0.35)
+ * @example
+ * const kb = await midikeys('Arturia KeyStep 32')
+ * kb("0.5 1")
+ *   .s("saw")
+ *   .add(note(rand.mul(0.3)))
+ *   .lpf(1000).lpe(2).room(0.5)
+ */
+const kHaps = {};
+const kListeners = {};
+
+function _triggerKeyboard(input, cps, now, latencyCycles) {
+  const pattern = getPattern();
+  const trigger = getTriggerFunc();
+  if (!pattern || !trigger) {
+    return false;
+  }
+  const t = now + latencyCycles;
+  const eps = 1e-6;
+  const haps = pattern.queryArc(t - eps, t + eps, { _cps: cps });
+  // Only keep haps coming from `midikeys`
+  const kbHaps = haps.filter((hap) => hap.value?.midikey?.startsWith(`${input}_`));
+  const ctxNow = getAudioContext().currentTime;
+  if (!kbHaps.length) {
+    return false;
+  }
+  kbHaps.forEach((hap) => {
+    if (!hap.hasOnset()) {
+      return;
+    }
+    const t = ctxNow + (hap.whole.begin - now) / cps;
+    const duration = hap.duration / cps;
+    trigger(hap, t - ctxNow, duration, cps, t);
+  });
+
+  return true;
+}
+export async function midikeys(input) {
+  const device = await _initialize(input);
+  if (!kHaps[input]) {
+    kHaps[input] = [];
+  }
+  kListeners[input] && device.removeListener('midimessage', kListeners[input]);
+  kListeners[input] = (e) => {
+    const { dataBytes, message } = e;
+    const noteon = message.command === 9;
+    let noteoff = message.command === 8;
+    // Don't enqueue or trigger midi notes if scheduler is not started
+    const notStarted = !getIsStarted();
+    // Ignore non-note messages (e.g. CC, pitchbend, modwheel, etc.)
+    const notANote = !noteon && !noteoff;
+    if (notStarted || notANote) {
+      return;
+    }
+    const [note, velocity] = dataBytes;
+    noteoff ||= noteon && velocity === 0; // handle devices which may use velocity = 0 to signal noteoff
+    const key = `${input}_${note}`;
+    const cps = getCps() ?? 0.5;
+    const triggerAvailable = !!(getPattern() && getTriggerFunc());
+    const latencySeconds = triggerAvailable ? 0.01 : 0.06; // avoid missing notes due to cyclist / trigger latency
+    const now = getTime();
+    const t = now + latencySeconds * cps;
+    const span = new TimeSpan(t, t);
+    let value = { midikey: key };
+    if (noteoff) {
+      /* TODO: It's a big effort, but we could modify superdough to allow for situations where
+      we don't know the hap duration in advance. This would mean, for example, that if the hap
+      is flagged as such a special note-on event, we have all effects be persistent & all ADSR
+      envelopes stop at the S stage [and store references to them by `midikey`]
+      If this is implemented, then getting full keyboard functionality should be as simple
+      as sending the corresponding note-off event below and triggering `release` on each of those
+      referenced effects/envelopes
+      
+      value = { ...value, noteoff: true };
+  
+      If this is achieved, we can remove the noteLength parameter
+      */
+      return;
+    } else {
+      value = { ...value, note: Math.round(note), velocity: velocity / 127 };
+    }
+    kHaps[input].push(new Hap(span, span, value, {}));
+    if (!noteoff && triggerAvailable) {
+      // If we have access to a trigger function, we call it to immediately
+      // dispatch to the audio engine, rather than waiting for cyclist to catch these haps
+      const triggered = _triggerKeyboard(input, cps, now, latencySeconds * cps);
+      if (triggered) {
+        kHaps[input] = [];
+      }
+    }
+  };
+  device.addListener('midimessage', kListeners[input]);
+  const kb = (noteLength = 0.5) => {
+    const nlPat = reify(noteLength);
+    const query = (state) => {
+      const haps = kHaps[input].flatMap((hap) => {
+        const lenHaps = nlPat.query(state.setSpan(hap.wholeOrPart()));
+        return lenHaps.map((lenHap) => {
+          const nl = lenHap.value ?? 0.5;
+          const whole = new TimeSpan(hap.whole.begin, hap.whole.begin.add(nl));
+          const part = new TimeSpan(hap.part.begin, hap.part.begin.add(nl));
+          const context = hap.combineContext(lenHap);
+          return new Hap(whole, part, hap.value, context);
+        });
+      });
+      if (state.controls.cyclist) {
+        // Notes have been sent; clear them
+        kHaps[input] = [];
+      }
+      return haps;
+    };
+    return new Pattern(query);
+  };
+  return kb;
+}
--- a/packages/midi/package.json
+++ b/packages/midi/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/midi",
-  "version": "1.2.6",
+  "version": "1.3.0",
  "description": "Midi API for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mini/package.json
+++ b/packages/mini/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mini",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Mini notation for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mondo/package.json
+++ b/packages/mondo/package.json
@ -1,6 +1,6 @@
 {
  "name": "mondolang",
-  "version": "1.1.1",
+  "version": "1.1.2",
  "description": "a language for functional composition that translates to js",
  "main": "mondo.mjs",
  "type": "module",
--- a/packages/mondough/package.json
+++ b/packages/mondough/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mondo",
-  "version": "1.1.5",
+  "version": "1.1.6",
  "description": "mondo notation for strudel",
  "main": "mondough.mjs",
  "type": "module",
--- a/packages/motion/motion.mjs
+++ b/packages/motion/motion.mjs
@ -7,6 +7,7 @@ import { signal } from '../core/signal.mjs';
 * @name accelerationX
 * @return {Pattern}
 * @synonyms accX
+ * @tags external_io
 * @example
 * n(accelerationX.segment(4).range(0,7)).scale("C:minor")
 *
@ -17,6 +18,7 @@ import { signal } from '../core/signal.mjs';
 * @name accelerationY
 * @return {Pattern}
 * @synonyms accY
+ * @tags external_io
 * @example
 * n(accelerationY.segment(4).range(0,7)).scale("C:minor")
 *
@ -27,6 +29,7 @@ import { signal } from '../core/signal.mjs';
 * @name accelerationZ
 * @return {Pattern}
 * @synonyms accZ
+ * @tags external_io
 * @example
 * n(accelerationZ.segment(4).range(0,7)).scale("C:minor")
 *
@ -37,6 +40,7 @@ import { signal } from '../core/signal.mjs';
 * @name gravityX
 * @return {Pattern}
 * @synonyms gravX
+ * @tags external_io
 * @example
 * n(gravityX.segment(4).range(0,7)).scale("C:minor")
 *
@ -47,6 +51,7 @@ import { signal } from '../core/signal.mjs';
 * @name gravityY
 * @return {Pattern}
 * @synonyms gravY
+ * @tags external_io
 * @example
 * n(gravityY.segment(4).range(0,7)).scale("C:minor")
 *
@ -57,6 +62,7 @@ import { signal } from '../core/signal.mjs';
 * @name gravityZ
 * @return {Pattern}
 * @synonyms gravZ
+ * @tags external_io
 * @example
 * n(gravityZ.segment(4).range(0,7)).scale("C:minor")
 *
@ -67,6 +73,7 @@ import { signal } from '../core/signal.mjs';
 * @name rotationAlpha
 * @return {Pattern}
 * @synonyms rotA, rotZ, rotationZ
+ * @tags external_io
 * @example
 * n(rotationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
@ -77,6 +84,7 @@ import { signal } from '../core/signal.mjs';
 * @name rotationBeta
 * @return {Pattern}
 * @synonyms rotB, rotX, rotationX
+ * @tags external_io
 * @example
 * n(rotationBeta.segment(4).range(0,7)).scale("C:minor")
 *
@ -87,6 +95,7 @@ import { signal } from '../core/signal.mjs';
 * @name rotationGamma
 * @return {Pattern}
 * @synonyms rotG, rotY, rotationY
+ * @tags external_io
 * @example
 * n(rotationGamma.segment(4).range(0,7)).scale("C:minor")
 *
@ -97,6 +106,7 @@ import { signal } from '../core/signal.mjs';
 * @name orientationAlpha
 * @return {Pattern}
 * @synonyms oriA, oriZ, orientationZ
+ * @tags external_io
 * @example
 * n(orientationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
@ -107,6 +117,7 @@ import { signal } from '../core/signal.mjs';
 * @name orientationBeta
 * @return {Pattern}
 * @synonyms oriB, oriX, orientationX
+ * @tags external_io
 * @example
 * n(orientationBeta.segment(4).range(0,7)).scale("C:minor")
 *
@ -117,6 +128,7 @@ import { signal } from '../core/signal.mjs';
 * @name orientationGamma
 * @return {Pattern}
 * @synonyms oriG, oriY, orientationY
+ * @tags external_io
 * @example
 * n(orientationGamma.segment(4).range(0,7)).scale("C:minor")
 *
@ -127,6 +139,7 @@ import { signal } from '../core/signal.mjs';
 * @name absoluteOrientationAlpha
 * @return {Pattern}
 * @synonyms absOriA, absOriZ, absoluteOrientationZ
+ * @tags external_io
 * @example
 * n(absoluteOrientationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
@ -137,6 +150,7 @@ import { signal } from '../core/signal.mjs';
 * @name absoluteOrientationBeta
 * @return {Pattern}
 * @synonyms absOriB, absOriX, absoluteOrientationX
+ * @tags external_io
 * @example
 * n(absoluteOrientationBeta.segment(4).range(0,7)).scale("C:minor")
 *
@ -147,6 +161,7 @@ import { signal } from '../core/signal.mjs';
 * @name absoluteOrientationGamma
 * @return {Pattern}
 * @synonyms absOriG, absOriY, absoluteOrientationY
+ * @tags external_io
 * @example
 * n(absoluteOrientationGamma.segment(4).range(0,7)).scale("C:minor")
 *
--- a/packages/motion/package.json
+++ b/packages/motion/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/motion",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "DeviceMotion API for strudel",
  "main": "index.mjs",
  "type": "module",
--- a/packages/mqtt/package.json
+++ b/packages/mqtt/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/mqtt",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "MQTT API for strudel",
  "main": "mqtt.mjs",
  "type": "module",
--- a/packages/osc/README.md
+++ b/packages/osc/README.md
@ -46,4 +46,4 @@ all(osc)

 [open in repl](https://strudel.cc/#JDogcygiYmQqNCIpCgphbGwob3NjKQ%3D%3D)

-You can read more about [how to use Superdirt with Strudel the Tutorial](https://strudel.cc/learn/input-output/#superdirt-api)
+You can read more about [how to use Superdirt with Strudel](https://strudel.cc/learn/input-output/#oscsuperdirtstrudeldirt) in  the tutorial.
--- a/packages/osc/osc.mjs
+++ b/packages/osc/osc.mjs
@ -79,6 +79,7 @@ export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
 * For more info, read [MIDI & OSC in the docs](https://strudel.cc/learn/input-output/)
 *
 * @name osc
+ * @tags external_io
 * @memberof Pattern
 * @returns Pattern
 */
--- a/packages/osc/package.json
+++ b/packages/osc/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/osc",
-  "version": "1.3.0",
+  "version": "1.3.2",
  "description": "OSC messaging for strudel",
  "main": "osc.mjs",
  "bin": "./server.js",
--- a/packages/reference/package.json
+++ b/packages/reference/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/reference",
-  "version": "1.2.1",
+  "version": "1.2.2",
  "description": "Headless reference of all strudel functions",
  "main": "index.mjs",
  "type": "module",
--- a/packages/repl/package.json
+++ b/packages/repl/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/repl",
-  "version": "1.2.7",
+  "version": "1.3.0",
  "description": "Strudel REPL as a Web Component",
  "module": "index.mjs",
  "publishConfig": {
--- a/packages/repl/repl-component.mjs
+++ b/packages/repl/repl-component.mjs
@ -1,11 +1,12 @@
 import { silence } from '@strudel/core';
 import { getDrawContext } from '@strudel/draw';
 import { transpiler } from '@strudel/transpiler';
-import { getAudioContext, webaudioOutput } from '@strudel/webaudio';
+import { getAudioContext, webaudioOutput, initAudioOnFirstClick } from '@strudel/webaudio';
 import { StrudelMirror, codemirrorSettings } from '@strudel/codemirror';
 import { prebake } from './prebake.mjs';

 if (typeof HTMLElement !== 'undefined') {
+  initAudioOnFirstClick();
  class StrudelRepl extends HTMLElement {
    static observedAttributes = ['code'];
    settings = codemirrorSettings.get();
--- a/packages/sampler/package.json
+++ b/packages/sampler/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/sampler",
-  "version": "0.2.3",
+  "version": "0.2.4",
  "description": "",
  "keywords": [
    "tidalcycles",
--- a/packages/serial/package.json
+++ b/packages/serial/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/serial",
-  "version": "1.2.5",
+  "version": "1.2.6",
  "description": "Webserial API for strudel",
  "main": "serial.mjs",
  "type": "module",
--- a/packages/serial/serial.mjs
+++ b/packages/serial/serial.mjs
@ -68,7 +68,7 @@ Pattern.prototype.serial = function (br = 115200, sendcrc = false, singlecharids
    if (!(name in writeMessagers)) {
      getWriter(name, br);
    }
-    const onTrigger = (t_deprecate, hap, currentTime, cps, targetTime) => {
+    const onTrigger = (hap, currentTime, _cps, targetTime) => {
      var message = '';
      var chk = 0;
      if (typeof hap.value === 'object') {
--- a/packages/soundfonts/fontloader.mjs
+++ b/packages/soundfonts/fontloader.mjs
@ -6,6 +6,8 @@ import {
  getADSRValues,
  getPitchEnvelope,
  getVibratoOscillator,
+  onceEnded,
+  releaseAudioNode,
 } from '@strudel/webaudio';
 import gm from './gm.mjs';

@ -164,19 +166,18 @@ export function registerSoundfonts() {
        let envEnd = holdEnd + release + 0.01;

        // vibrato
-        let vibratoOscillator = getVibratoOscillator(bufferSource.detune, value, time);
+        const vibratoHandle = getVibratoOscillator(bufferSource.detune, value, time);
        // pitch envelope
        getPitchEnvelope(bufferSource.detune, value, time, holdEnd);

        bufferSource.stop(envEnd);
        const stop = (releaseTime) => {};
-        bufferSource.onended = () => {
-          bufferSource.disconnect();
-          vibratoOscillator?.stop();
-          node.disconnect();
+        onceEnded(bufferSource, () => {
+          releaseAudioNode(bufferSource);
+          vibratoHandle?.stop();
          onended();
-        };
-        return { node, stop };
+        });
+        return { node, stop, nodes: { source: [bufferSource], ...vibratoHandle?.nodes } };
      },
      { type: 'soundfont', prebake: true, fonts },
    );
--- a/packages/soundfonts/package.json
+++ b/packages/soundfonts/package.json
@ -1,6 +1,6 @@
 {
  "name": "@strudel/soundfonts",
-  "version": "1.2.6",
+  "version": "1.3.0",
  "description": "Soundsfont support for strudel",
  "main": "index.mjs",
  "publishConfig": {
--- a/packages/superdough/audioContext.mjs
+++ b/packages/superdough/audioContext.mjs
@ -1,3 +1,12 @@
+/*
+audioContext.mjs - Audio Context manager
+
+Sets up a common and accessible audio context for all superdough operations
+
+Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/audiocontext.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/>.
+*/
+
 let audioContext;

 export const setDefaultAudioContext = () => {
@ -5,6 +14,11 @@ export const setDefaultAudioContext = () => {
  return audioContext;
 };

+export const setAudioContext = (context) => {
+  audioContext = context;
+  return audioContext;
+};
+
 export const getAudioContext = () => {
  if (!audioContext) {
    return setDefaultAudioContext();
--- a/packages/superdough/feedbackdelay.mjs
+++ b/packages/superdough/feedbackdelay.mjs
@ -5,19 +5,18 @@ if (typeof DelayNode !== 'undefined') {
      wet = Math.abs(wet);
      this.delayTime.value = time;

-      const feedbackGain = ac.createGain();
-      feedbackGain.gain.value = Math.min(Math.abs(feedback), 0.995);
-      this.feedback = feedbackGain.gain;
+      this.feedbackGain = ac.createGain();
+      this.feedbackGain.gain.value = Math.min(Math.abs(feedback), 0.995);
+      this.feedback = this.feedbackGain.gain;

-      const delayGain = ac.createGain();
-      delayGain.gain.value = wet;
-      this.delayGain = delayGain;
+      this.delayGain = ac.createGain();
+      this.delayGain.gain.value = wet;

-      this.connect(feedbackGain);
-      this.connect(delayGain);
-      feedbackGain.connect(this);
+      this.connect(this.feedbackGain);
+      this.connect(this.delayGain);
+      this.feedbackGain.connect(this);

-      this.connect = (target) => delayGain.connect(target);
+      this.connect = (target) => this.delayGain.connect(target);
      return this;
    }
    start(t) {
@ -25,7 +24,7 @@ if (typeof DelayNode !== 'undefined') {
    }
  }

-  AudioContext.prototype.createFeedbackDelay = function (wet, time, feedback) {
+  BaseAudioContext.prototype.createFeedbackDelay = function (wet, time, feedback) {
    return new FeedbackDelayNode(this, wet, time, feedback);
  };
 }
--- a/packages/superdough/helpers.mjs
+++ b/packages/superdough/helpers.mjs
@ -1,7 +1,8 @@
 import { getAudioContext } from './audioContext.mjs';
-import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';
-import { getNoiseBuffer } from './noise.mjs';
 import { logger } from './logger.mjs';
+import { getNoiseBuffer } from './noise.mjs';
+import { getNodeFromPool } from './nodePools.mjs';
+import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';

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

@ -42,6 +43,7 @@ export const getParamADSR = (
  decay,
  sustain,
  release,
+  // min = value at start of attack, max = value at end of attack; it is possible that max < min
  min,
  max,
  begin,
@ -59,17 +61,15 @@ export const getParamADSR = (
    max = max === 0 ? 0.001 : max;
  }
  const range = max - min;
-  const peak = max;
  const sustainVal = min + sustain * range;
  const duration = end - begin;

  const envValAtTime = (time) => {
    let val;
    if (attack > time) {
-      let slope = getSlope(min, peak, 0, attack);
-      val = time * slope + (min > peak ? min : 0);
+      val = time * getSlope(min, max, 0, attack) + min;
    } else {
-      val = (time - attack) * getSlope(peak, sustainVal, 0, decay) + peak;
+      val = (time - attack) * getSlope(max, sustainVal, 0, decay) + max;
    }
    if (curve === 'exponential') {
      val = val || 0.001;
@ -105,22 +105,40 @@ function getModulationShapeInput(val) {
  return { tri: 0, triangle: 0, sine: 1, ramp: 2, saw: 3, square: 4 }[val] ?? 0;
 }

-export function getLfo(audioContext, begin, end, properties = {}) {
-  const { shape = 0, ...props } = properties;
-  const { dcoffset = -0.5, depth = 1 } = properties;
+export function getEnvelope(audioContext, properties = {}) {
+  return getWorklet(audioContext, 'envelope-processor', properties);
+}
+
+export function getLfo(audioContext, properties = {}) {
+  const {
+    shape = 0,
+    begin = 0,
+    end = 0,
+    time,
+    depth = 1,
+    dcoffset = -0.5,
+    frequency = 1,
+    skew = 0.5,
+    phaseoffset = 0,
+    curve = 1,
+    min,
+    max,
+    ...props
+  } = properties;
+
  const lfoprops = {
-    frequency: 1,
-    depth,
-    skew: 0.5,
-    phaseoffset: 0,
-    time: begin,
    begin,
    end,
-    shape: getModulationShapeInput(shape),
+    time: time ?? begin,
+    depth,
    dcoffset,
-    min: dcoffset * depth,
-    max: dcoffset * depth + depth,
-    curve: 1,
+    frequency,
+    skew,
+    phaseoffset,
+    curve,
+    shape: getModulationShapeInput(shape),
+    min: min ?? dcoffset * depth,
+    max: max ?? dcoffset * depth + depth,
    ...props,
  };

@ -128,6 +146,7 @@ export function getLfo(audioContext, begin, end, properties = {}) {
 }

 export function getCompressor(ac, threshold, ratio, knee, attack, release) {
+  const node = getNodeFromPool('compressor', () => new DynamicsCompressorNode(ac, {}));
  const options = {
    threshold: threshold ?? -3,
    ratio: ratio ?? 10,
@ -135,7 +154,10 @@ export function getCompressor(ac, threshold, ratio, knee, attack, release) {
    attack: attack ?? 0.005,
    release: release ?? 0.05,
  };
-  return new DynamicsCompressorNode(ac, options);
+  Object.entries(options).forEach(([key, value]) => {
+    node[key].value = value;
+  });
+  return node;
 }

 // changes the default values of the envelope based on what parameters the user has defined
@ -150,6 +172,7 @@ export const getADSRValues = (params, curve = 'linear', defaultValues) => {
  if (a == null && d == null && s == null && r == null) {
    return defaultValues ?? [envmin, envmin, envmax, releaseMin];
  }
+
  const sustain = s != null ? s : (a != null && d == null) || (a == null && d == null) ? envmax : envmin;
  return [Math.max(a ?? 0, envmin), Math.max(d ?? 0, envmin), Math.min(sustain, envmax), Math.max(r ?? 0, releaseMin)];
 };
@ -162,7 +185,9 @@ export function getParamLfo(audioContext, param, start, end, lfoValues) {
  }
  let lfo;
  if (depth) {
-    lfo = getLfo(audioContext, start, end, {
+    lfo = getLfo(audioContext, {
+      begin: start,
+      end,
      depth,
      dcoffset,
      ...getLfoInputs,
@ -189,7 +214,7 @@ export function applyParameterModulators(audioContext, param, start, end, envelo
    getParamADSR(param, attack, decay, sustain, release, min, max, start, holdEnd, curve);
  }
  const lfo = getParamLfo(audioContext, param, start, end, lfoValues);
-  return { lfo, disconnect: () => lfo?.disconnect() };
+  return lfo;
 }
 export function createFilter(context, start, end, params, cps, cycle) {
  let {
@ -214,10 +239,12 @@ export function createFilter(context, start, end, params, cps, cycle) {
    filter = getWorklet(context, 'ladder-processor', { frequency, q, drive });
    frequencyParam = filter.parameters.get('frequency');
  } else {
-    filter = context.createBiquadFilter();
+    const factory = () => context.createBiquadFilter();
+    filter = getNodeFromPool('filter', factory);
    filter.type = type;
-    filter.Q.value = q;
-    filter.frequency.value = frequency;
+    Object.entries({ Q: q, frequency }).forEach(([key, value]) => {
+      filter[key].value = value;
+    });
    frequencyParam = filter.frequency;
  }
  const envelopeValues = [params.attack, params.decay, params.sustain, params.release];
@ -283,9 +310,12 @@ export function drywet(dry, wet, wetAmount = 0) {
  wet_gain.connect(mix);
  return {
    node: mix,
-    onended: () => {
-      dry_gain.disconnect(mix);
-      wet_gain.disconnect(mix);
+    teardown: () => {
+      releaseAudioNode(dry_gain);
+      releaseAudioNode(wet_gain);
+      // it is not the responsability of drywet
+      // to call `releaseAudioNode` on
+      // the 2 external args dry and wet
      dry.disconnect(dry_gain);
      wet.disconnect(wet_gain);
    },
@ -324,12 +354,12 @@ export function getVibratoOscillator(param, value, t) {
    gain.gain.value = vibmod * 100;
    vibratoOscillator.connect(gain);
    gain.connect(param);
-    vibratoOscillator.onended = () => {
-      gain.disconnect(param);
-      vibratoOscillator.disconnect(gain);
-    };
+    onceEnded(vibratoOscillator, () => {
+      releaseAudioNode(gain);
+      releaseAudioNode(vibratoOscillator);
+    });
    vibratoOscillator.start(t);
-    return vibratoOscillator;
+    return { stop: (t) => vibratoOscillator.stop(t), nodes: { vib: [vibratoOscillator], vib_gain: [gain] } };
  }
 }

@ -349,25 +379,17 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
  constantNode.connect(zeroGain);

  // Schedule the `onComplete` callback to occur at `stopTime`
-  constantNode.onended = () => {
-    // Ensure garbage collection
-    try {
-      zeroGain.disconnect();
-    } catch {
-      // pass
-    }
-    try {
-      constantNode.disconnect();
-    } catch {
-      // pass
-    }
+  onceEnded(constantNode, () => {
+    releaseAudioNode(zeroGain);
+    releaseAudioNode(constantNode);
    onComplete();
-  };
+  });
  constantNode.start(startTime);
  constantNode.stop(stopTime);
  return constantNode;
 }
-const mod = (freq, range = 1, type = 'sine') => {
+
+const mod = (freq, type = 'sine') => {
  const ctx = getAudioContext();
  let osc;
  if (noises.includes(type)) {
@ -379,69 +401,94 @@ const mod = (freq, range = 1, type = 'sine') => {
    osc.type = type;
    osc.frequency.value = freq;
  }
-
  osc.start();
-  const g = gainNode(range);
-  osc.connect(g); // -range, range
-  return { node: g, stop: (t) => osc.stop(t), osc: osc };
+  return osc;
 };
-const fm = (frequencyparam, harmonicityRatio, modulationIndex, wave = 'sine') => {
+
+const fm = (frequencyparam, harmonicityRatio, wave = 'sine') => {
  const carrfreq = frequencyparam.value;
  const modfreq = carrfreq * harmonicityRatio;
-  const modgain = modfreq * modulationIndex;
-  return mod(modfreq, modgain, wave);
+  return { osc: mod(modfreq, wave), freq: modfreq };
 };
+
 export function applyFM(param, value, begin) {
-  const {
-    fmh: fmHarmonicity = 1,
-    fmi: fmModulationIndex,
-    fmenv: fmEnvelopeType = 'exp',
-    fmattack: fmAttack,
-    fmdecay: fmDecay,
-    fmsustain: fmSustain,
-    fmrelease: fmRelease,
-    fmvelocity: fmVelocity,
-    fmwave: fmWaveform = 'sine',
-    duration,
-  } = value;
-  let modulator;
-  let stop = () => {};
-
-  if (fmModulationIndex) {
-    const ac = getAudioContext();
-    const envGain = ac.createGain();
-    const fmmod = fm(param, fmHarmonicity, fmModulationIndex, fmWaveform);
-
-    modulator = fmmod.node;
-    stop = fmmod.stop;
-    if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].some((v) => v !== undefined)) {
-      // no envelope by default
-      modulator.connect(param);
-    } else {
-      const [attack, decay, sustain, release] = getADSRValues([fmAttack, fmDecay, fmSustain, fmRelease]);
-      const holdEnd = begin + duration;
-      getParamADSR(
-        envGain.gain,
-        attack,
-        decay,
-        sustain,
-        release,
-        0,
-        1,
-        begin,
-        holdEnd,
-        fmEnvelopeType === 'exp' ? 'exponential' : 'linear',
-      );
-      modulator.connect(envGain);
-      envGain.connect(param);
+  const ac = getAudioContext();
+  const toStop = []; // fm oscillators we will expose `stop` for
+  const fms = {};
+  const nodes = {};
+  // Matrix
+  for (let i = 1; i <= 8; i++) {
+    for (let j = 0; j <= 8; j++) {
+      let control;
+      if (i === j + 1) {
+        // Standard fm3 -> fm2 -> fm1 -> param usage
+        const iS = i === 1 ? '' : i;
+        control = `fmi${iS}`;
+      } else {
+        control = `fmi${i}${j}`;
+      }
+      const amt = value[control];
+      if (!amt) continue;
+      let io = [];
+      for (let [isMod, idx] of [
+        [true, i], // source
+        [false, j], // target
+      ]) {
+        if (idx === 0) {
+          io.push(param);
+          continue;
+        }
+        if (!fms[idx]) {
+          const idxS = idx === 1 ? '' : idx;
+          const { osc, freq } = fm(param, value[`fmh${idxS}`] ?? 1, value[`fmwave${idxS}`] ?? 'sine');
+          toStop.push(osc);
+          const toCleanup = [osc]; // nodes we want to cleanup after oscillator `stop`
+          const adsr = ['attack', 'decay', 'sustain', 'release'].map((s) => value[`fm${s}${idxS}`]);
+          let output = osc;
+          if (adsr.some((v) => v !== undefined)) {
+            const envGain = ac.createGain();
+            const [attack, decay, sustain, release] = getADSRValues(adsr);
+            const holdEnd = begin + value.duration;
+            const fmEnvelopeType = value[`fmenv${idxS}`] ?? 'exp';
+            getParamADSR(
+              envGain.gain,
+              attack,
+              decay,
+              sustain,
+              release,
+              0,
+              1,
+              begin,
+              holdEnd,
+              fmEnvelopeType === 'exp' ? 'exponential' : 'linear',
+            );
+            toCleanup.push(envGain);
+            output = osc.connect(envGain);
+          }
+          fms[idx] = { input: osc.frequency, output, freq, osc, toCleanup };
+          nodes[`fm_${idx}`] = [osc];
+        }
+        const { input, output, freq, osc, toCleanup } = fms[idx];
+        const gAmt = gainNode(amt);
+        const gFreq = gainNode(freq);
+        io.push(isMod ? output.connect(gAmt).connect(gFreq) : input);
+        cleanupOnEnd(osc, [...toCleanup, gAmt, gFreq]);
+        nodes[`fm_${idx}_gain`] = [gAmt];
+      }
+      if (!io[1]) {
+        logger(
+          `[superdough] control ${control} failed to connect FM ${i} to target ${j} due to missing frequency parameter (likely because fm${j} is noise)`,
+          'warning',
+        );
+        continue;
+      }
+      io[0].connect(io[1]);
    }
-    fmmod.osc.onended = () => {
-      envGain.disconnect();
-      modulator.disconnect();
-      fmmod.osc.disconnect();
-    };
  }
-  return { stop };
+  return {
+    nodes,
+    stop: (t) => toStop.forEach((m) => m?.stop(t)),
+  };
 }

 // Saturation curves
@ -554,10 +601,60 @@ export const getFrequencyFromValue = (value, defaultNote = 36) => {
  return Number(freq);
 };

-export const destroyAudioWorkletNode = (node) => {
-  if (node == null) {
-    return;
-  }
-  node.disconnect();
-  node.parameters.get('end')?.setValueAtTime(0, 0);
+// This helper should be used instead of the `node.onended = callback` pattern
+// It adds a mechanism to help minimize gc retention
+export const onceEnded = (node, callback) => {
+  const onended = callback;
+  node.onended = function cleanup() {
+    onended && onended();
+    this.onended = null;
+  };
+};
+
+export const releaseAudioNode = (node) => {
+  if (node == null) return;
+
+  // check we received an AudioNode
+  if (!(node instanceof AudioNode)) {
+    throw new Error('releaseAudioNode can only release an AudioNode');
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/AudioNode/disconnect
+  node.disconnect();
+
+  // make sure all AudioScheduledSourceNodes are in a stopped state
+  // https://developer.mozilla.org/en-US/docs/Web/API/AudioScheduledSourceNode
+  if (node instanceof AudioScheduledSourceNode) {
+    if (process.env.NODE_ENV === 'development' && node.onended && node.onended.name !== 'cleanup') {
+      logger(
+        `[superdough] Deprecation warning: it seems your code path is setting 'node.onended = callback' instead of using the onceEnded helper`,
+      );
+    }
+    try {
+      node.stop();
+    } catch (e) {
+      // At the stage, `start` was not called on the node
+      // but an `onended` callback releasing resources may exist
+      // and we want it to fire :
+      // - we force a start/stop cycle so that `onended` gets called
+      // - we `lock` the node so that no-one can start it
+      node.start(node.context.currentTime + 5); // will never happen
+      node.stop();
+    }
+  }
+
+  // https://www.w3.org/TR/webaudio-1.1/#AudioNode-actively-processing
+  // An AudioWorkletNode is actively processing when its AudioWorkletProcessor's [[callable process]]
+  // returns true and either its active source flag is true or
+  // any AudioNode connected to one of its inputs is actively processing.
+  if (node instanceof AudioWorkletNode) {
+    // while `end` is not native to the web audio API, it is common practice in superdough
+    // to use that param in the worklets to trigger returning false from the processor
+    node.parameters.get('end')?.setValueAtTime(0, 0);
+  }
+};
+
+// Once the `anchor` node has ended, release all nodes in `toCleanup`
+export const cleanupOnEnd = (anchor, toCleanup) => {
+  onceEnded(anchor, () => toCleanup.forEach((n) => releaseAudioNode(n)));
 };
--- a/packages/superdough/index.mjs
+++ b/packages/superdough/index.mjs
@ -10,6 +10,7 @@ export * from './helpers.mjs';
 export * from './synth.mjs';
 export * from './zzfx.mjs';
 export * from './logger.mjs';
+export * from './modulators.mjs';
 export * from './dspworklet.mjs';
 export * from './audioContext.mjs';
 export * from './wavetable.mjs';
--- a/packages/superdough/modulators.mjs
+++ b/packages/superdough/modulators.mjs
@ -0,0 +1,179 @@
+/*
+modulators.mjs - Helpers for constructing modulators (envelopes, LFOs, etc.)
+Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/modulators.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/>.
+*/
+
+import { getAudioContext } from './audioContext.mjs';
+import { gainNode, getEnvelope, getLfo, webAudioTimeout } from './helpers.mjs';
+import { errorLogger } from './logger.mjs';
+import { getSuperdoughControlTargets } from './superdoughdata.mjs';
+import { clamp } from './util.mjs';
+
+const getNodeParam = (node, name) => {
+  // Worklet case
+  if (node?.parameters) {
+    const p = node.parameters.get(name);
+    if (p instanceof AudioParam) {
+      return p;
+    }
+  }
+  // Built-in node case
+  let p = node?.[name];
+  if (p === undefined && name === 'frequency') {
+    // Fallbacks for source nodes without 'frequency' params (e.g. soundfonts)
+    p = node?.['detune'] ?? node?.['playbackRate'];
+  }
+  if (p instanceof AudioParam) {
+    return p;
+  }
+  return undefined;
+};
+
+const controlTargets = getSuperdoughControlTargets();
+
+const getControlData = (control, subControl) => {
+  const controlNoIdx = control.split('_')[0];
+  return controlTargets[`${controlNoIdx}_${subControl}`] ?? controlTargets[controlNoIdx];
+};
+
+const getRangeForParam = (paramName, currentValue) => {
+  // We clamp the frequency to a reasonable range unless the currentValue
+  // is low, which indicates this may be an LFO
+  if (paramName === 'frequency' && currentValue >= 30) {
+    return { min: 20 - currentValue, max: 24000 - currentValue };
+  }
+  return { min: undefined, max: undefined };
+};
+
+const clampWithWaveShaper = (modulator, min, max) => {
+  const ac = getAudioContext();
+  const curve = new Float32Array(256);
+  for (let i = 0; i < curve.length; i++) {
+    const x = (i / (curve.length - 1)) * 2 - 1;
+    curve[i] = clamp(x * max, min, max);
+  }
+  const shaper = new WaveShaperNode(ac, { curve });
+  const scaleGain = gainNode(1 / max);
+  modulator.connect(scaleGain).connect(shaper);
+  return { modulator, toCleanup: [shaper, scaleGain] };
+};
+
+const getTargetParamsForControl = (control, nodes, subControl) => {
+  const targetInfo = getControlData(control, subControl);
+  if (!targetInfo) {
+    errorLogger(
+      new Error(`Could not find control data for target '${control}'. It may not be modulatable.`),
+      'superdough',
+    );
+    return { targetParams: [], paramName: control };
+  }
+  const paramName = targetInfo.param;
+  const nodeKey = nodes[targetInfo.node] ? targetInfo.node : control;
+  const targetNodes = nodes[nodeKey];
+  if (!targetNodes) {
+    const keys = Object.keys(nodes);
+    errorLogger(
+      new Error(`Could not connect to target '${nodeKey}' — it does not exist. Available targets: ${keys.join(', ')}`),
+      'superdough',
+    );
+    return { targetParams: [], paramName };
+  }
+  const audioParams = [];
+  targetNodes.forEach((targetNode) => {
+    const targetParam = getNodeParam(targetNode, paramName);
+    audioParams.push(targetParam);
+  });
+  return { targetParams: audioParams, paramName };
+};
+
+export const connectLFO = (id, params, nodeTracker) => {
+  const {
+    rate = 1,
+    sync,
+    cps,
+    cycle,
+    control = 'lfo',
+    subControl,
+    fxi = 'main',
+    depth = 1,
+    depthabs,
+    retrig = 0,
+    ...filteredParams
+  } = params;
+  const { targetParams, paramName } = getTargetParamsForControl(control, nodeTracker[fxi], subControl);
+  if (!targetParams.length) return;
+  let currentValue = targetParams[0].value;
+  currentValue = currentValue === 0 ? 1 : currentValue;
+  const { min, max } = getRangeForParam(paramName, currentValue);
+  const depthValue = depthabs != null ? depthabs : depth * currentValue;
+  const modParams = {
+    ...filteredParams,
+    frequency: sync !== undefined ? sync * cps : rate,
+    time: retrig > 0.5 ? 0 : cycle / cps,
+    depth: depthValue,
+    min,
+    max,
+  };
+  const lfoNode = getLfo(getAudioContext(), modParams);
+  nodeTracker.main[`lfo_${id}`] = [lfoNode];
+  targetParams.forEach((t) => lfoNode.connect(t));
+  return lfoNode;
+};
+
+export const connectEnvelope = (id, params, nodeTracker) => {
+  const { control, subControl, acurve, dcurve, rcurve, depth = 1, depthabs, fxi = 'main', ...filteredParams } = params;
+  const { targetParams, paramName } = getTargetParamsForControl(control, nodeTracker[fxi], subControl);
+  if (!targetParams.length) return;
+  let currentValue = targetParams[0].value;
+  currentValue = currentValue === 0 ? 1 : currentValue;
+  const { min, max } = getRangeForParam(paramName, currentValue);
+  const depthValue = depthabs != null ? depthabs : depth * currentValue;
+  const envNode = getEnvelope(getAudioContext(), {
+    ...filteredParams,
+    depth: depthValue,
+    min,
+    max,
+    attackCurve: acurve,
+    decayCurve: dcurve,
+    releaseCurve: rcurve,
+  });
+  nodeTracker.main[`env_${id}`] = [envNode];
+  targetParams.forEach((t) => envNode.connect(t));
+  return envNode;
+};
+
+export const connectBusModulator = (params, nodeTracker, controller) => {
+  const ac = getAudioContext();
+  const { control, subControl, depth = 1, depthabs, fxi = 'main' } = params;
+  const { targetParams, paramName } = getTargetParamsForControl(control, nodeTracker[fxi], subControl);
+  if (!targetParams.length) return { toCleanup: [] };
+  const signal = controller.getBus(params.bus);
+  const dc = new ConstantSourceNode(ac, { offset: params.dc ?? 0 });
+  dc.start(params.begin);
+  const shifted = dc.connect(gainNode(1));
+  signal.connect(shifted);
+  let currentValue = targetParams[0].value;
+  currentValue = currentValue === 0 ? 1 : currentValue;
+  const { min, max } = getRangeForParam(paramName, currentValue);
+  const depthValue = depthabs != null ? depthabs : depth * currentValue;
+  const depthGain = gainNode((Math.sign(depthValue) * Math.abs(depthValue)) / 0.3);
+  const unClamped = shifted.connect(depthGain);
+  const toCleanup = [];
+  let modulator = unClamped;
+  if (min !== undefined && max !== undefined) {
+    const wsData = clampWithWaveShaper(unClamped, min, max);
+    modulator = wsData.modulator;
+    toCleanup.push(...wsData.toCleanup);
+  }
+  webAudioTimeout(
+    ac,
+    () => {
+      targetParams.forEach((t) => modulator.connect(t));
+    },
+    0,
+    params.begin,
+  );
+  toCleanup.push(dc, shifted, depthGain);
+  return { modulator, toCleanup };
+};
--- a/packages/superdough/nodePools.mjs
+++ b/packages/superdough/nodePools.mjs
@ -0,0 +1,84 @@
+/*
+nodePools.mjs - Helper functions related to pooling and re-using audio nodes
+
+Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/nodePools.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/>.
+*/
+
+const nodePools = new Map();
+const POOL_KEY = Symbol('nodePoolKey');
+
+export const isPoolable = (node) => !!node[POOL_KEY];
+
+const getNodeTime = (node) => {
+  return node.context?.currentTime ?? 0;
+};
+
+const getParams = (node) => {
+  const params = new Set();
+  node.parameters?.forEach((param) => params.add(param));
+  const visited = new Set(); // prioritize deepest definition
+  let proto = node;
+  // Move up the prototype chain
+  while (proto !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      if (visited.has(key)) continue;
+      visited.add(key);
+      const value = node[key];
+      if (value instanceof AudioParam) {
+        params.add(value);
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return params;
+};
+
+export const releaseNodeToPool = (node) => {
+  node.disconnect();
+  if (node instanceof AudioScheduledSourceNode) {
+    // not reusable
+    return;
+  }
+  const key = node[POOL_KEY];
+  if (key == null) return;
+  const now = getNodeTime(node);
+  getParams(node).forEach((param) => param.cancelScheduledValues(now));
+  const pool = nodePools.get(key) ?? [];
+  pool.push(new WeakRef(node));
+  nodePools.set(key, pool);
+};
+
+// Audio worklets are given a grace period to survive (`return true`) after
+// being released. This concludes at time `end + 0.5`. We test here whether we are
+// within some safe distance of that (`end + 0.45`) and if so, permit the node to be
+// released. This helps to prevent race conditions between node termination and node
+// re-use
+const isNodeAlive = (node) => {
+  // Skip check if node is not a worklet
+  if (!(node instanceof AudioWorkletNode)) return true;
+  const now = getNodeTime(node);
+  const end = node?.parameters?.get('end').value ?? 0;
+  return now < end + 0.45;
+};
+
+// Attempt to get node from the pool. If this fails, fall back
+// to building it with the factory
+export const getNodeFromPool = (key, factory) => {
+  const pool = nodePools.get(key) ?? [];
+  let node;
+  let found = false;
+  while (pool.length) {
+    const ref = pool.pop();
+    node = ref?.deref();
+    if (node != null && isNodeAlive(node)) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    node = factory();
+  }
+  node[POOL_KEY] = key;
+  return node;
+};
--- a/packages/superdough/noise.mjs
+++ b/packages/superdough/noise.mjs
@ -1,4 +1,4 @@
-import { drywet } from './helpers.mjs';
+import { drywet, onceEnded, releaseAudioNode } from './helpers.mjs';
 import { getAudioContext } from './audioContext.mjs';

 let noiseCache = {};
@ -65,9 +65,12 @@ export function getNoiseOscillator(type = 'white', t, density = 0.02) {
 export function getNoiseMix(inputNode, wet, t) {
  const noiseOscillator = getNoiseOscillator('pink', t);
  const noiseMix = drywet(inputNode, noiseOscillator.node, wet);
-  noiseOscillator.node.onended = () => noiseMix.onended();
+  onceEnded(noiseOscillator.node, () => {
+    releaseAudioNode(noiseOscillator.node);
+  });
  return {
    node: noiseMix.node,
    stop: (time) => noiseOscillator?.stop(time),
+    teardown: noiseMix.teardown,
  };
 }
--- a/packages/superdough/ola-processor.js
+++ b/packages/superdough/ola-processor.js
@ -35,7 +35,9 @@ class OLAProcessor extends AudioWorkletProcessor {
  }

  /** Handles dynamic reallocation of input/output channels buffer
-     (channel numbers may lety during lifecycle) **/
+   * (channel numbers may vary during lifecycle)
+   * @tags internals
+   **/
  reallocateChannelsIfNeeded(inputs, outputs) {
    for (let i = 0; i < this.nbInputs; i++) {
      let nbChannels = inputs[i].length;
@ -88,7 +90,10 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Read next web audio block to input buffers **/
+  /**
+   * Read next web audio block to input buffers
+   * @tags internals
+   **/
  readInputs(inputs) {
    // when playback is paused, we may stop receiving new samples
    if (inputs[0].length && inputs[0][0].length == 0) {
@ -108,7 +113,9 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Write next web audio block from output buffers **/
+  /** Write next web audio block from output buffers
+   * @tags internals
+   **/
  writeOutputs(outputs) {
    for (let i = 0; i < this.nbInputs; i++) {
      for (let j = 0; j < this.inputBuffers[i].length; j++) {
@ -118,7 +125,9 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Shift left content of input buffers to receive new web audio block **/
+  /** Shift left content of input buffers to receive new web audio block
+   * @tags internals
+   **/
  shiftInputBuffers() {
    for (let i = 0; i < this.nbInputs; i++) {
      for (let j = 0; j < this.inputBuffers[i].length; j++) {
@ -127,7 +136,9 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Shift left content of output buffers to receive new web audio block **/
+  /** Shift left content of output buffers to receive new web audio block
+   * @tags internals
+   **/
  shiftOutputBuffers() {
    for (let i = 0; i < this.nbOutputs; i++) {
      for (let j = 0; j < this.outputBuffers[i].length; j++) {
@ -137,7 +148,9 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Copy contents of input buffers to buffer actually sent to process **/
+  /** Copy contents of input buffers to buffer actually sent to process
+   * @tags internals
+   **/
  prepareInputBuffersToSend() {
    for (let i = 0; i < this.nbInputs; i++) {
      for (let j = 0; j < this.inputBuffers[i].length; j++) {
@ -146,7 +159,9 @@ class OLAProcessor extends AudioWorkletProcessor {
    }
  }

-  /** Add contents of output buffers just processed to output buffers **/
+  /** Add contents of output buffers just processed to output buffers
+   * @tags internals
+   **/
  handleOutputBuffersToRetrieve() {
    for (let i = 0; i < this.nbOutputs; i++) {
      for (let j = 0; j < this.outputBuffers[i].length; j++) {
--- a/packages/superdough/package.json
+++ b/packages/superdough/package.json
@ -1,6 +1,6 @@
 {
  "name": "superdough",
-  "version": "1.2.6",
+  "version": "1.3.0",
  "description": "simple web audio synth and sampler intended for live coding. inspired by superdirt and webdirt.",
  "main": "index.mjs",
  "type": "module",
@ -36,6 +36,8 @@
    "vite-plugin-bundle-audioworklet": "workspace:*"
  },
  "dependencies": {
+    "@kabelsalat/lib": "^0.4.1",
+    "@kabelsalat/web": "^0.4.1",
    "nanostores": "^0.11.3"
  },
  "engines": {
--- a/packages/superdough/reverb.mjs
+++ b/packages/superdough/reverb.mjs
@ -2,7 +2,7 @@ import reverbGen from './reverbGen.mjs';
 import { clamp } from './util.mjs';

 if (typeof AudioContext !== 'undefined') {
-  AudioContext.prototype.adjustLength = function (duration, buffer, speed = 1, offsetAmount = 0) {
+  BaseAudioContext.prototype.adjustLength = function (duration, buffer, speed = 1, offsetAmount = 0) {
    const sampleOffset = Math.floor(clamp(offsetAmount, 0, 1) * buffer.length);
    const newLength = buffer.sampleRate * duration;
    const newBuffer = this.createBuffer(buffer.numberOfChannels, buffer.length, buffer.sampleRate);
@ -23,7 +23,7 @@ if (typeof AudioContext !== 'undefined') {
    return newBuffer;
  };

-  AudioContext.prototype.createReverb = function (duration, fade, lp, dim, ir, irspeed, irbegin) {
+  BaseAudioContext.prototype.createReverb = function (duration, fade, lp, dim, ir, irspeed, irbegin) {
    const convolver = this.createConvolver();
    convolver.generate = (d = 2, fade = 0.1, lp = 15000, dim = 1000, ir, irspeed, irbegin) => {
      convolver.duration = d;
--- a/packages/superdough/reverbGen.mjs
+++ b/packages/superdough/reverbGen.mjs
@ -12,10 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+import { releaseAudioNode } from './helpers.mjs';
+
 var reverbGen = {};

 /** Generates a reverb impulse response.

+ @tags internals
 @param {!Object} params TODO: Document the properties.
 @param {!function(!AudioBuffer)} callback Function to call when
  the impulse response has been generated. The impulse response
@ -48,7 +51,7 @@ reverbGen.generateReverb = function (params, callback) {

 /** Creates a canvas element showing a graph of the given data.

-
+ @tags internals
 @param {!Float32Array} data An array of numbers, or a Float32Array.
 @param {number} width Width in pixels of the canvas.
 @param {number} height Height in pixels of the canvas.
@ -79,7 +82,9 @@ reverbGen.generateGraph = function (data, width, height, min, max) {
 @param {number} lpFreqEnd
 @param {number} lpFreqEndAt
 @param {!function(!AudioBuffer)} callback May be called
-  immediately within the current execution context, or later.*/
+  immediately within the current execution context, or later.
+ @tags internals
+  */
 var applyGradualLowpass = function (input, lpFreqStart, lpFreqEnd, lpFreqEndAt, callback) {
  if (lpFreqStart == 0) {
    callback(input);
@ -104,8 +109,8 @@ var applyGradualLowpass = function (input, lpFreqStart, lpFreqEnd, lpFreqEndAt,
  player.start();
  context.oncomplete = function (event) {
    callback(event.renderedBuffer);
-    filter.disconnect();
-    player.disconnect();
+    releaseAudioNode(filter);
+    releaseAudioNode(player);
  };
  context.startRendering();

--- a/Show more
+++ b/Show more